() {
+ @Override
+ public boolean apply(View view) {
+ Object tag = view.getTag();
+ return tag != null && tag.equals(tagValue);
+ }
+ };
+ }
+}
diff --git a/android/ReactAndroid/src/androidTest/java/com/facebook/react/testing/ScreenshotingFrameLayout.java b/android/ReactAndroid/src/androidTest/java/com/facebook/react/testing/ScreenshotingFrameLayout.java
new file mode 100644
index 00000000000000..ffc648e7915770
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/java/com/facebook/react/testing/ScreenshotingFrameLayout.java
@@ -0,0 +1,71 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.testing;
+
+import javax.annotation.Nullable;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.os.Looper;
+import android.widget.FrameLayout;
+
+/**
+ * A FrameLayout that allows you to access the result of the last time its hierarchy was drawn. It
+ * accomplishes this by drawing its hierarchy into a software Canvas, saving the resulting Bitmap
+ * and then drawing that Bitmap to the actual Canvas provided by the system.
+ */
+public class ScreenshotingFrameLayout extends FrameLayout {
+
+ private @Nullable Bitmap mBitmap;
+ private Canvas mCanvas;
+
+ public ScreenshotingFrameLayout(Context context) {
+ super(context);
+ mCanvas = new Canvas();
+ }
+
+ @Override
+ protected void dispatchDraw(Canvas canvas) {
+ if (mBitmap == null) {
+ mBitmap = createNewBitmap(canvas);
+ mCanvas.setBitmap(mBitmap);
+ } else if (mBitmap.getWidth() != canvas.getWidth() ||
+ mBitmap.getHeight() != canvas.getHeight()) {
+ mBitmap.recycle();
+ mBitmap = createNewBitmap(canvas);
+ mCanvas.setBitmap(mBitmap);
+ }
+
+ super.dispatchDraw(mCanvas);
+ canvas.drawBitmap(mBitmap, 0, 0, null);
+ }
+
+ private static Bitmap createNewBitmap(Canvas canvas) {
+ return Bitmap.createBitmap(canvas.getWidth(), canvas.getHeight(), Bitmap.Config.ARGB_8888);
+ }
+
+ public Bitmap getLastDrawnBitmap() {
+ if (mBitmap == null) {
+ throw new RuntimeException("View has not been drawn yet!");
+ }
+ if (Looper.getMainLooper() != Looper.myLooper()) {
+ throw new RuntimeException(
+ "Must access screenshots from main thread or you may get partially drawn Bitmaps");
+ }
+ if (!isScreenshotReady()) {
+ throw new RuntimeException("Trying to get screenshot, but the view is dirty or needs layout");
+ }
+ return Bitmap.createBitmap(mBitmap);
+ }
+
+ public boolean isScreenshotReady() {
+ return !isDirty() && !isLayoutRequested();
+ }
+}
diff --git a/android/ReactAndroid/src/androidTest/java/com/facebook/react/testing/SingleTouchGestureGenerator.java b/android/ReactAndroid/src/androidTest/java/com/facebook/react/testing/SingleTouchGestureGenerator.java
new file mode 100644
index 00000000000000..278facbcb280b4
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/java/com/facebook/react/testing/SingleTouchGestureGenerator.java
@@ -0,0 +1,161 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.testing;
+
+import android.os.SystemClock;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewConfiguration;
+
+/**
+ * Provides methods for generating touch events and dispatching them directly to a given view.
+ * Events scenarios are based on {@link android.test.TouchUtils} but they get gets dispatched
+ * directly through the view hierarchy using {@link View#dispatchTouchEvent} method instead of
+ * using instrumentation API.
+ *
+ * All the events for a gesture are dispatched immediately which makes tests run very fast.
+ * The eventTime for each event is still set correctly. Android's gesture recognizers check
+ * eventTime in order to figure out gesture speed, and therefore scroll vs fling is recognized.
+ */
+public class SingleTouchGestureGenerator {
+
+ private static final long DEFAULT_DELAY_MS = 20;
+
+ private View mDispatcherView;
+ private IdleWaiter mIdleWaiter;
+ private long mLastDownTime;
+ private long mEventTime;
+ private float mLastX;
+ private float mLastY;
+
+ private ViewConfiguration mViewConfig;
+
+ public SingleTouchGestureGenerator(View view, IdleWaiter idleWaiter) {
+ mDispatcherView = view;
+ mIdleWaiter = idleWaiter;
+ mViewConfig = ViewConfiguration.get(view.getContext());
+ }
+
+ private SingleTouchGestureGenerator dispatchEvent(
+ final int action,
+ final float x,
+ final float y,
+ long eventTime) {
+ mEventTime = eventTime;
+ if (action == MotionEvent.ACTION_DOWN) {
+ mLastDownTime = eventTime;
+ }
+ mLastX = x;
+ mLastY = y;
+ mDispatcherView.post(
+ new Runnable() {
+ @Override
+ public void run() {
+ MotionEvent event = MotionEvent.obtain(mLastDownTime, mEventTime, action, x, y, 0);
+ mDispatcherView.dispatchTouchEvent(event);
+ event.recycle();
+ }
+ });
+ mIdleWaiter.waitForBridgeAndUIIdle();
+ return this;
+ }
+
+ private float getViewCenterX(View view) {
+ int[] xy = new int[2];
+ view.getLocationOnScreen(xy);
+ int viewWidth = view.getWidth();
+ return xy[0] + (viewWidth / 2.0f);
+ }
+
+ private float getViewCenterY(View view) {
+ int[] xy = new int[2];
+ view.getLocationOnScreen(xy);
+ int viewHeight = view.getHeight();
+ return xy[1] + (viewHeight / 2.0f);
+ }
+
+ public SingleTouchGestureGenerator startGesture(float x, float y) {
+ return dispatchEvent(MotionEvent.ACTION_DOWN, x, y, SystemClock.uptimeMillis());
+ }
+
+ public SingleTouchGestureGenerator startGesture(View view) {
+ return startGesture(getViewCenterX(view), getViewCenterY(view));
+ }
+
+ private SingleTouchGestureGenerator dispatchDelayedEvent(
+ int action,
+ float x,
+ float y,
+ long delay) {
+ return dispatchEvent(action, x, y, mEventTime + delay);
+ }
+
+ public SingleTouchGestureGenerator endGesture(float x, float y, long delay) {
+ return dispatchDelayedEvent(MotionEvent.ACTION_UP, x, y, delay);
+ }
+
+ public SingleTouchGestureGenerator endGesture(float x, float y) {
+ return endGesture(x, y, DEFAULT_DELAY_MS);
+ }
+
+ public SingleTouchGestureGenerator endGesture() {
+ return endGesture(mLastX, mLastY);
+ }
+
+ public SingleTouchGestureGenerator moveGesture(float x, float y, long delay) {
+ return dispatchDelayedEvent(MotionEvent.ACTION_MOVE, x, y, delay);
+ }
+
+ public SingleTouchGestureGenerator moveBy(float dx, float dy, long delay) {
+ return moveGesture(mLastX + dx, mLastY + dy, delay);
+ }
+
+ public SingleTouchGestureGenerator moveBy(float dx, float dy) {
+ return moveBy(dx, dy, DEFAULT_DELAY_MS);
+ }
+
+ public SingleTouchGestureGenerator clickViewAt(float x, float y) {
+ float touchSlop = mViewConfig.getScaledTouchSlop();
+ return startGesture(x, y).moveBy(touchSlop / 2.0f, touchSlop / 2.0f).endGesture();
+ }
+
+ public SingleTouchGestureGenerator drag(
+ float fromX,
+ float fromY,
+ float toX,
+ float toY,
+ int stepCount,
+ long totalDelay) {
+
+ float xStep = (toX - fromX) / stepCount;
+ float yStep = (toY - fromY) / stepCount;
+
+ float x = fromX;
+ float y = fromY;
+
+ for (int i = 0; i < stepCount; i++) {
+ x += xStep;
+ y += yStep;
+ moveGesture(x, y, totalDelay / stepCount);
+ }
+ return this;
+ }
+
+ public SingleTouchGestureGenerator dragTo(float toX, float toY, int stepCount, long totalDelay) {
+ return drag(mLastX, mLastY, toX, toY, stepCount, totalDelay);
+ }
+
+ public SingleTouchGestureGenerator dragTo(View view, int stepCount, long totalDelay) {
+ return dragTo(getViewCenterX(view), getViewCenterY(view), stepCount, totalDelay);
+ }
+
+ public SingleTouchGestureGenerator dragTo(View view, int stepCount) {
+ return dragTo(view, stepCount, stepCount * DEFAULT_DELAY_MS);
+ }
+}
diff --git a/android/ReactAndroid/src/androidTest/java/com/facebook/react/testing/StringRecordingModule.java b/android/ReactAndroid/src/androidTest/java/com/facebook/react/testing/StringRecordingModule.java
new file mode 100644
index 00000000000000..8caa3b8f7117b1
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/java/com/facebook/react/testing/StringRecordingModule.java
@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.testing;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.facebook.react.bridge.BaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+
+/**
+ * Native module provides single method {@link #record} which records its single string argument
+ * in calls array
+ */
+public class StringRecordingModule extends BaseJavaModule {
+
+ private final List mCalls = new ArrayList();
+
+ @Override
+ public String getName() {
+ return "Recording";
+ }
+
+ @ReactMethod
+ public void record(String text) {
+ mCalls.add(text);
+ }
+
+ public void reset() {
+ mCalls.clear();
+ }
+
+ public List getCalls() {
+ return mCalls;
+ }
+}
diff --git a/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/BUCK b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/BUCK
new file mode 100644
index 00000000000000..b9ba1265462874
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/BUCK
@@ -0,0 +1,54 @@
+include_defs('//ReactAndroid/DEFS')
+
+# Tests that are too flaky to run on SandCastle
+# TODO t11057216 stabilise them
+SANDCASTLE_FLAKY = [
+]
+
+deps = [
+ react_native_dep('third-party/android/support/v4:lib-support-v4'),
+ react_native_dep('third-party/java/jsr-305:jsr-305'),
+ react_native_dep('third-party/java/junit:junit'),
+ react_native_integration_tests_target('java/com/facebook/react/testing:testing'),
+ react_native_target('java/com/facebook/react/bridge:bridge'),
+ react_native_target('java/com/facebook/react/common:common'),
+ react_native_target('java/com/facebook/react/modules/core:core'),
+ react_native_target('java/com/facebook/react/modules/datepicker:datepicker'),
+ react_native_target('java/com/facebook/react/modules/systeminfo:systeminfo'),
+ react_native_target('java/com/facebook/react/modules/timepicker:timepicker'),
+ react_native_target('java/com/facebook/react/touch:touch'),
+ react_native_target('java/com/facebook/react/uimanager/annotations:annotations'),
+ react_native_target('java/com/facebook/react/uimanager:uimanager'),
+ react_native_target('java/com/facebook/react/views/picker:picker'),
+ react_native_target('java/com/facebook/react/views/progressbar:progressbar'),
+ react_native_target('java/com/facebook/react/views/recyclerview:recyclerview'),
+ react_native_target('java/com/facebook/react/views/scroll:scroll'),
+ react_native_target('java/com/facebook/react/views/slider:slider'),
+ react_native_target('java/com/facebook/react/views/swiperefresh:swiperefresh'),
+ react_native_target('java/com/facebook/react/views/text:text'),
+ react_native_target('java/com/facebook/react/views/textinput:textinput'),
+ react_native_target('java/com/facebook/react/views/view:view'),
+ react_native_target('java/com/facebook/react:react'),
+]
+
+android_library(
+ name = 'tests',
+ srcs = glob(['**/*.java']),
+ deps = deps,
+ visibility = [
+ 'PUBLIC',
+ ],
+)
+
+android_library(
+ name = 'stable-tests',
+ srcs = glob(['**/*.java'], excludes=SANDCASTLE_FLAKY),
+ deps = deps,
+ visibility = [
+ 'PUBLIC',
+ ],
+)
+
+project_config(
+ src_target = ':tests',
+)
diff --git a/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/CatalystMeasureLayoutTest.java b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/CatalystMeasureLayoutTest.java
new file mode 100644
index 00000000000000..ba34dda0858e42
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/CatalystMeasureLayoutTest.java
@@ -0,0 +1,131 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.tests;
+
+import com.facebook.react.testing.ReactInstanceSpecForTest;
+import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.uimanager.UIManagerModule;
+import com.facebook.react.testing.AssertModule;
+import com.facebook.react.testing.ReactAppInstrumentationTestCase;
+
+/**
+ * Tests for {@link UIManagerModule#measure}, {@link UIManagerModule#measureLayout}, and
+ * {@link UIManagerModule#measureLayoutRelativeToParent}. Tests measurement for views in the
+ * following hierarchy:
+ *
+ * +---------------------------------------------+
+ * | A |
+ * | |
+ * | +-----------+ +---------+ |
+ * | | B | | D | |
+ * | | +---+ | | | |
+ * | | | C | | | | |
+ * | | | | | +---------+ |
+ * | | +---+ | |
+ * | +-----------+ |
+ * | |
+ * | |
+ * | |
+ * +---------------------------------------------+
+ *
+ * View locations and dimensions:
+ * A - (0,0) to (500, 500) (500x500)
+ * B - (50,80) to (250, 380) (200x300)
+ * C - (150,150) to (200, 300) (50x150)
+ * D - (400,100) to (450, 300) (50x200)
+ */
+public class CatalystMeasureLayoutTest extends ReactAppInstrumentationTestCase {
+
+ private static interface MeasureLayoutTestModule extends JavaScriptModule {
+ public void verifyMeasureOnViewA();
+ public void verifyMeasureOnViewC();
+ public void verifyMeasureLayoutCRelativeToA();
+ public void verifyMeasureLayoutCRelativeToB();
+ public void verifyMeasureLayoutCRelativeToSelf();
+ public void verifyMeasureLayoutRelativeToParentOnViewA();
+ public void verifyMeasureLayoutRelativeToParentOnViewB();
+ public void verifyMeasureLayoutRelativeToParentOnViewC();
+ public void verifyMeasureLayoutDRelativeToB();
+ public void verifyMeasureLayoutNonExistentTag();
+ public void verifyMeasureLayoutNonExistentAncestor();
+ public void verifyMeasureLayoutRelativeToParentNonExistentTag();
+ }
+
+ private MeasureLayoutTestModule mTestJSModule;
+ private AssertModule mAssertModule;
+
+ @Override
+ protected void setUp() throws Exception {
+ super.setUp();
+ mTestJSModule = getReactContext().getJSModule(MeasureLayoutTestModule.class);
+ }
+
+ @Override
+ protected String getReactApplicationKeyUnderTest() {
+ return "MeasureLayoutTestApp";
+ }
+
+ @Override
+ protected ReactInstanceSpecForTest createReactInstanceSpecForTest() {
+ mAssertModule = new AssertModule();
+ return new ReactInstanceSpecForTest()
+ .addNativeModule(mAssertModule)
+ .addJSModule(MeasureLayoutTestModule.class);
+ }
+
+ private void waitForBridgeIdleAndVerifyAsserts() {
+ waitForBridgeAndUIIdle();
+ mAssertModule.verifyAssertsAndReset();
+ }
+
+ public void testMeasure() {
+ mTestJSModule.verifyMeasureOnViewA();
+ waitForBridgeIdleAndVerifyAsserts();
+ mTestJSModule.verifyMeasureOnViewC();
+ waitForBridgeIdleAndVerifyAsserts();
+ }
+
+ public void testMeasureLayout() {
+ mTestJSModule.verifyMeasureLayoutCRelativeToA();
+ waitForBridgeIdleAndVerifyAsserts();
+ mTestJSModule.verifyMeasureLayoutCRelativeToB();
+ waitForBridgeIdleAndVerifyAsserts();
+ mTestJSModule.verifyMeasureLayoutCRelativeToSelf();
+ waitForBridgeIdleAndVerifyAsserts();
+ }
+
+ public void testMeasureLayoutRelativeToParent() {
+ mTestJSModule.verifyMeasureLayoutRelativeToParentOnViewA();
+ waitForBridgeIdleAndVerifyAsserts();
+ mTestJSModule.verifyMeasureLayoutRelativeToParentOnViewB();
+ waitForBridgeIdleAndVerifyAsserts();
+ mTestJSModule.verifyMeasureLayoutRelativeToParentOnViewC();
+ waitForBridgeIdleAndVerifyAsserts();
+ }
+
+ public void testMeasureLayoutCallsErrorCallbackWhenViewIsNotChildOfAncestor() {
+ mTestJSModule.verifyMeasureLayoutDRelativeToB();
+ waitForBridgeIdleAndVerifyAsserts();
+ }
+
+ public void testMeasureLayoutCallsErrorCallbackWhenViewDoesNotExist() {
+ mTestJSModule.verifyMeasureLayoutNonExistentTag();
+ waitForBridgeIdleAndVerifyAsserts();
+ }
+
+ public void testMeasureLayoutCallsErrorCallbackWhenAncestorDoesNotExist() {
+ mTestJSModule.verifyMeasureLayoutNonExistentAncestor();
+ waitForBridgeIdleAndVerifyAsserts();
+ }
+
+ public void testMeasureLayoutRelativeToParentCallsErrorCallbackWhenViewDoesNotExist() {
+ mTestJSModule.verifyMeasureLayoutRelativeToParentNonExistentTag();
+ waitForBridgeIdleAndVerifyAsserts();
+ }
+}
diff --git a/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/CatalystMultitouchHandlingTestCase.java b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/CatalystMultitouchHandlingTestCase.java
new file mode 100644
index 00000000000000..ec21f0c2f066da
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/CatalystMultitouchHandlingTestCase.java
@@ -0,0 +1,656 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.tests;
+
+import java.util.List;
+
+import android.view.MotionEvent;
+
+import com.facebook.react.testing.ReactInstanceSpecForTest;
+import com.facebook.react.testing.ReactAppInstrumentationTestCase;
+import com.facebook.react.testing.StringRecordingModule;
+
+/**
+ * Test case for verifying that multitouch events are directed to the React's view touch handlers
+ * properly
+ */
+public class CatalystMultitouchHandlingTestCase extends ReactAppInstrumentationTestCase {
+
+ private final StringRecordingModule mRecordingModule = new StringRecordingModule();
+
+ @Override
+ protected String getReactApplicationKeyUnderTest() {
+ return "MultitouchHandlingTestAppModule";
+ }
+
+ @Override
+ protected ReactInstanceSpecForTest createReactInstanceSpecForTest() {
+ return new ReactInstanceSpecForTest()
+ .addNativeModule(mRecordingModule);
+ }
+
+ /**
+ * In this test case we send pre-recorded stream of pinch out gesture and verify that we have
+ * recorded important touch events in JS module
+ */
+ public void testMultitouchEvents() throws InterruptedException {
+ generateRecordedPinchTouchEvents();
+ waitForBridgeAndUIIdle();
+
+ // Expect to receive at least 5 events (DOWN for each pointer, UP for each pointer and at least
+ // one MOVE event with both pointers down)
+ List calls = mRecordingModule.getCalls();
+
+ int moveWithBothPointersEventIndex = -1;
+ int startEventIndex = -1;
+ int startExtraPointerEventIndex = -1;
+ int endEventIndex = -1;
+ int endExtraPointerEventIndex = -1;
+
+ for (int i = 0; i < calls.size(); i++) {
+ String call = calls.get(i);
+ if (call.equals("start;ExtraPointer")) {
+ assertEquals(-1, startExtraPointerEventIndex);
+ startExtraPointerEventIndex = i;
+ } else if (call.equals("end;ExtraPointer")) {
+ assertEquals(-1, endExtraPointerEventIndex);
+ endExtraPointerEventIndex = i;
+ } else if (call.equals("start;1")) {
+ assertEquals(-1, startEventIndex);
+ startEventIndex = i;
+ } else if (call.equals("end;0")) {
+ assertEquals(-1, endEventIndex);
+ endEventIndex = i;
+ } else if (call.equals("move;2")) {
+ // this will happen more than once, let's just capture the last occurence
+ moveWithBothPointersEventIndex = i;
+ }
+ }
+
+ assertEquals(0, startEventIndex);
+ assertTrue(-1 != startExtraPointerEventIndex);
+ assertTrue(-1 != moveWithBothPointersEventIndex);
+ assertTrue(-1 != endExtraPointerEventIndex);
+ assertTrue(startExtraPointerEventIndex < moveWithBothPointersEventIndex);
+ assertTrue(endExtraPointerEventIndex > moveWithBothPointersEventIndex);
+ assertEquals(calls.size() - 1, endEventIndex);
+ }
+
+ private MotionEvent.PointerProperties createPointerProps(int id, int toolType) {
+ MotionEvent.PointerProperties pointerProps = new MotionEvent.PointerProperties();
+ pointerProps.id = id;
+ pointerProps.toolType = toolType;
+ return pointerProps;
+ }
+
+ private MotionEvent.PointerCoords createPointerCoords(float x, float y) {
+ MotionEvent.PointerCoords pointerCoords = new MotionEvent.PointerCoords();
+ pointerCoords.x = x;
+ pointerCoords.y = y;
+ return pointerCoords;
+ }
+
+ private void dispatchEvent(
+ final int action,
+ final long start,
+ final long when,
+ final int pointerCount,
+ final MotionEvent.PointerProperties[] pointerProps,
+ final MotionEvent.PointerCoords[] pointerCoords) {
+ getRootView().post(
+ new Runnable() {
+ @Override
+ public void run() {
+ MotionEvent event =
+ MotionEvent.obtain(start, when, action, pointerCount, pointerProps, pointerCoords, 0, 0, 1.0f, 1.0f, 0, 0, 0, 0);
+ getRootView().dispatchTouchEvent(event);
+ event.recycle();
+ }
+ });
+ getInstrumentation().waitForIdleSync();
+ }
+
+ /**
+ * This method "replay" multi-touch gesture recorded with modified TouchesHelper class that
+ * generated this piece of code (see https://phabricator.fb.com/P19756940).
+ * This is not intended to be copied/reused and once we need to have more multitouch gestures
+ * in instrumentation tests we should either:
+ * - implement nice generator similar to {@link SingleTouchGestureGenerator}
+ * - implement gesture recorded that will record touch data using arbitrary format and then read
+ * this recorded touch sequence during tests instead of generating code like this
+ */
+ private void generateRecordedPinchTouchEvents() {
+ // START OF GENERATED CODE
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[1];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[1];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(268.0f, 347.0f);
+ dispatchEvent(MotionEvent.ACTION_DOWN, 446560605, 446560605, 1, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[1];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[1];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(267.0f, 346.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446560630, 1, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(267.0f, 346.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(225.0f, 542.0f);
+ dispatchEvent(MotionEvent.ACTION_POINTER_DOWN | (1 << MotionEvent.ACTION_POINTER_INDEX_SHIFT), 446560605, 446560630, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(266.0f, 345.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(225.0f, 542.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446560647, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(265.0f, 344.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(224.0f, 541.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446560664, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(264.0f, 342.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(223.0f, 540.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446560681, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(263.0f, 340.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(222.0f, 539.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446560698, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(262.0f, 337.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(221.0f, 538.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446560714, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(262.0f, 333.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(220.0f, 537.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446560731, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(261.0f, 328.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(219.0f, 536.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446560748, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(260.0f, 321.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(218.0f, 536.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446560765, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(260.0f, 313.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(216.0f, 536.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446560781, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(260.0f, 304.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(214.0f, 537.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446560798, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(260.0f, 295.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(211.0f, 539.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446560815, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(261.0f, 285.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(208.0f, 542.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446560832, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(264.0f, 274.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(203.0f, 547.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446560849, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(266.0f, 264.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(199.0f, 551.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446560865, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(269.0f, 254.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(194.0f, 556.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446560882, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(273.0f, 245.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(190.0f, 561.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446560899, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(276.0f, 236.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(186.0f, 567.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446560916, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(280.0f, 227.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(183.0f, 573.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446560933, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(283.0f, 219.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(181.0f, 579.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446560949, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(287.0f, 211.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(179.0f, 584.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446560966, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(291.0f, 202.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(177.0f, 589.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446560983, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(296.0f, 193.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(175.0f, 593.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446561000, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(301.0f, 184.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(174.0f, 598.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446561016, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(307.0f, 176.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(173.0f, 603.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446561033, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(313.0f, 168.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(172.0f, 608.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446561050, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(317.0f, 160.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(171.0f, 613.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446561067, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(320.0f, 154.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(170.0f, 619.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446561084, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(323.0f, 149.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(169.0f, 624.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446561100, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(325.0f, 145.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(168.0f, 628.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446561117, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(328.0f, 141.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(167.0f, 632.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446561134, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(331.0f, 137.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(166.0f, 636.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446561151, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(334.0f, 134.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(165.0f, 639.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446561167, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(337.0f, 131.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(164.0f, 643.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446561184, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(338.0f, 128.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(164.0f, 646.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446561201, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(340.0f, 126.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(164.0f, 649.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446561218, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(341.0f, 124.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(163.0f, 652.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446561234, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(342.0f, 122.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(163.0f, 655.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446561251, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(343.0f, 120.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(162.0f, 659.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446561268, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(344.0f, 118.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(161.0f, 664.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446561285, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(345.0f, 116.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(160.0f, 667.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446561302, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(346.0f, 115.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(158.0f, 670.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446561318, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(347.0f, 114.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(157.0f, 673.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446561335, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(348.0f, 113.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(156.0f, 676.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446561352, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(348.0f, 112.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(155.0f, 677.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446561369, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(349.0f, 111.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(154.0f, 678.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446561386, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(349.0f, 110.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(153.0f, 679.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446561402, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(349.0f, 109.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(152.0f, 680.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446561419, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(349.0f, 110.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(151.0f, 680.0f);
+ dispatchEvent(MotionEvent.ACTION_MOVE, 446560605, 446561435, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[2];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[2];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(349.0f, 110.0f);
+ pointerProps[1] = createPointerProps(1, 1);
+ pointerCoords[1] = createPointerCoords(151.0f, 680.0f);
+ dispatchEvent(MotionEvent.ACTION_POINTER_UP | (0 << MotionEvent.ACTION_POINTER_INDEX_SHIFT), 446560605, 446561443, 2, pointerProps, pointerCoords);
+ }
+
+ {
+ MotionEvent.PointerProperties[] pointerProps = new MotionEvent.PointerProperties[1];
+ MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[1];
+ pointerProps[0] = createPointerProps(0, 1);
+ pointerCoords[0] = createPointerCoords(151.0f, 680.0f);
+ dispatchEvent(MotionEvent.ACTION_UP, 446560605, 446561451, 1, pointerProps, pointerCoords);
+ }
+ // END OF GENERATED CODE
+ }
+
+}
diff --git a/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/CatalystNativeJSToJavaParametersTestCase.java b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/CatalystNativeJSToJavaParametersTestCase.java
new file mode 100644
index 00000000000000..06ff91a0cfa626
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/CatalystNativeJSToJavaParametersTestCase.java
@@ -0,0 +1,709 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.tests;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import com.facebook.react.bridge.BaseJavaModule;
+import com.facebook.react.bridge.CatalystInstance;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.InvalidIteratorException;
+import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.bridge.NoSuchKeyException;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableType;
+import com.facebook.react.bridge.ReadableNativeMap;
+import com.facebook.react.bridge.ReadableMapKeySetIterator;
+import com.facebook.react.bridge.UnexpectedNativeTypeException;
+import com.facebook.react.bridge.UiThreadUtil;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+import com.facebook.react.modules.systeminfo.AndroidInfoModule;
+import com.facebook.react.testing.FakeWebSocketModule;
+import com.facebook.react.testing.ReactIntegrationTestCase;
+import com.facebook.react.testing.ReactTestHelper;
+import com.facebook.react.uimanager.UIImplementation;
+import com.facebook.react.uimanager.UIManagerModule;
+import com.facebook.react.uimanager.ViewManager;
+import com.facebook.react.views.view.ReactViewManager;
+
+/**
+ * Integration test to verify passing various types of parameters from JS to Java works
+ */
+public class CatalystNativeJSToJavaParametersTestCase extends ReactIntegrationTestCase {
+
+ private interface TestJSToJavaParametersModule extends JavaScriptModule {
+ void returnBasicTypes();
+
+ void returnArrayWithBasicTypes();
+ void returnNestedArray();
+ void returnArrayWithMaps();
+
+ void returnMapWithBasicTypes();
+ void returnNestedMap();
+ void returnMapWithArrays();
+
+ void returnArrayWithStringDoubleIntMapArrayBooleanNull();
+ void returnMapWithStringDoubleIntMapArrayBooleanNull();
+
+ void returnMapForMerge1();
+ void returnMapForMerge2();
+
+ void returnMapWithMultibyteUTF8CharacterString();
+ void returnArrayWithMultibyteUTF8CharacterString();
+
+ void returnArrayWithLargeInts();
+ void returnMapWithLargeInts();
+ }
+
+ private RecordingTestModule mRecordingTestModule;
+ private CatalystInstance mCatalystInstance;
+
+ @Override
+ protected void setUp() throws Exception {
+ super.setUp();
+
+ List viewManagers = Arrays.asList(
+ new ReactViewManager());
+ final UIManagerModule mUIManager = new UIManagerModule(
+ getContext(),
+ viewManagers,
+ new UIImplementation(getContext(), viewManagers));
+ UiThreadUtil.runOnUiThread(
+ new Runnable() {
+ @Override
+ public void run() {
+ mUIManager.onHostResume();
+ }
+ });
+ waitForIdleSync();
+
+ mRecordingTestModule = new RecordingTestModule();
+ mCatalystInstance = ReactTestHelper.catalystInstanceBuilder(this)
+ .addNativeModule(mRecordingTestModule)
+ .addNativeModule(new AndroidInfoModule())
+ .addNativeModule(new FakeWebSocketModule())
+ .addNativeModule(mUIManager)
+ .addJSModule(TestJSToJavaParametersModule.class)
+ .build();
+ }
+
+ public void testBasicTypes() {
+ mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnBasicTypes();
+ waitForBridgeAndUIIdle();
+
+ List basicTypesCalls = mRecordingTestModule.getBasicTypesCalls();
+ assertEquals(1, basicTypesCalls.size());
+
+ Object[] args = basicTypesCalls.get(0);
+ assertEquals("foo", args[0]);
+ assertEquals(3.14, args[1]);
+ assertEquals(true, args[2]);
+ assertNull(args[3]);
+ }
+
+ public void testArrayWithBasicTypes() {
+ mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnArrayWithBasicTypes();
+ waitForBridgeAndUIIdle();
+
+ List calls = mRecordingTestModule.getArrayCalls();
+ assertEquals(1, calls.size());
+ ReadableArray array = calls.get(0);
+ assertNotNull(array);
+ assertEquals(5, array.size());
+ assertFalse(array.isNull(0));
+ assertEquals("foo", array.getString(0));
+ assertFalse(array.isNull(1));
+ assertEquals(3.14, array.getDouble(1));
+ assertFalse(array.isNull(2));
+ assertEquals(-111, array.getInt(2));
+ assertFalse(array.isNull(3));
+ assertTrue(array.getBoolean(3));
+ assertTrue(array.isNull(4));
+ assertEquals(null, array.getString(4));
+ assertEquals(null, array.getMap(4));
+ assertEquals(null, array.getArray(4));
+ }
+
+ public void testNestedArray() {
+ mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnNestedArray();
+ waitForBridgeAndUIIdle();
+
+ List calls = mRecordingTestModule.getArrayCalls();
+ assertEquals(1, calls.size());
+ ReadableArray array = calls.get(0);
+ assertNotNull(array);
+ assertEquals(2, array.size());
+ assertEquals("we", array.getString(0));
+
+ assertFalse(array.isNull(1));
+ ReadableArray subArray = array.getArray(1);
+ assertEquals(2, subArray.size());
+ assertEquals("have", subArray.getString(0));
+
+ subArray = subArray.getArray(1);
+ assertEquals(2, subArray.size());
+ assertEquals("to", subArray.getString(0));
+
+ subArray = subArray.getArray(1);
+ assertEquals(2, subArray.size());
+ assertEquals("go", subArray.getString(0));
+
+ subArray = subArray.getArray(1);
+ assertEquals(1, subArray.size());
+ assertEquals("deeper", subArray.getString(0));
+ }
+
+ public void testArrayWithMaps() {
+ mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnArrayWithMaps();
+ waitForBridgeAndUIIdle();
+
+ List calls = mRecordingTestModule.getArrayCalls();
+ assertEquals(1, calls.size());
+ ReadableArray array = calls.get(0);
+ assertEquals(2, array.size());
+
+ assertFalse(array.isNull(0));
+ ReadableMap m1 = array.getMap(0);
+ ReadableMap m2 = array.getMap(1);
+
+ assertEquals("m1v1", m1.getString("m1k1"));
+ assertEquals("m1v2", m1.getString("m1k2"));
+ assertEquals("m2v1", m2.getString("m2k1"));
+ }
+
+ public void testMapWithBasicTypes() {
+ mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnMapWithBasicTypes();
+ waitForBridgeAndUIIdle();
+
+ List calls = mRecordingTestModule.getMapCalls();
+ assertEquals(1, calls.size());
+ ReadableMap map = calls.get(0);
+ assertNotNull(map);
+
+ assertTrue(map.hasKey("stringKey"));
+ assertFalse(map.isNull("stringKey"));
+ assertEquals("stringValue", map.getString("stringKey"));
+
+ assertTrue(map.hasKey("doubleKey"));
+ assertFalse(map.isNull("doubleKey"));
+ assertTrue(Math.abs(3.14 - map.getDouble("doubleKey")) < .0001);
+
+ assertTrue(map.hasKey("intKey"));
+ assertFalse(map.isNull("intKey"));
+ assertEquals(-11, map.getInt("intKey"));
+
+ assertTrue(map.hasKey("booleanKey"));
+ assertFalse(map.isNull("booleanKey"));
+ assertTrue(map.getBoolean("booleanKey"));
+
+ assertTrue(map.hasKey("nullKey"));
+ assertTrue(map.isNull("nullKey"));
+ assertNull(map.getString("nullKey"));
+ assertNull(map.getMap("nullKey"));
+ assertNull(map.getArray("nullKey"));
+
+ assertFalse(map.hasKey("nonExistentKey"));
+ }
+
+ public void testNestedMap() {
+ mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnNestedMap();
+ waitForBridgeAndUIIdle();
+
+ List calls = mRecordingTestModule.getMapCalls();
+ assertEquals(1, calls.size());
+ ReadableMap map = calls.get(0);
+ assertNotNull(map);
+
+ assertTrue(map.hasKey("weHaveToGoDeeper"));
+ assertFalse(map.isNull("weHaveToGoDeeper"));
+ ReadableMap nestedMap = map.getMap("weHaveToGoDeeper");
+ assertTrue(nestedMap.hasKey("inception"));
+ assertTrue(nestedMap.getBoolean("inception"));
+ }
+
+ public void testMapParameterWithArrays() throws InterruptedException {
+ mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnMapWithArrays();
+ waitForBridgeAndUIIdle();
+
+ List calls = mRecordingTestModule.getMapCalls();
+ assertEquals(1, calls.size());
+ ReadableMap map = calls.get(0);
+ assertNotNull(map);
+
+ ReadableArray arrayParameter;
+ assertTrue(map.hasKey("empty"));
+ arrayParameter = map.getArray("empty");
+ assertNotNull(arrayParameter);
+ assertEquals(0, arrayParameter.size());
+
+ assertTrue(map.hasKey("ints"));
+ assertFalse(map.isNull("ints"));
+ arrayParameter = map.getArray("ints");
+ assertNotNull(arrayParameter);
+ assertEquals(2, arrayParameter.size());
+ assertEquals(43, arrayParameter.getInt(0));
+ assertEquals(44, arrayParameter.getInt(1));
+
+ assertTrue(map.hasKey("mixed"));
+ arrayParameter = map.getArray("mixed");
+ assertNotNull(arrayParameter);
+ assertEquals(3, arrayParameter.size());
+ assertEquals(77, arrayParameter.getInt(0));
+ assertEquals("string", arrayParameter.getString(1));
+ ReadableArray nestedArray = arrayParameter.getArray(2);
+ assertEquals(2, nestedArray.size());
+ }
+
+ public void testMapParameterDump() {
+ mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnMapWithBasicTypes();
+ mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnNestedMap();
+ mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnMapWithArrays();
+ waitForBridgeAndUIIdle();
+
+ List calls = mRecordingTestModule.getMapCalls();
+ assertEquals(3, calls.size());
+
+ // App should not crash while generating debug string representation of arguments
+ assertNotNull(calls.get(0).toString());
+ assertNotNull(calls.get(1).toString());
+ assertNotNull(calls.get(2).toString());
+ }
+
+ public void testGetTypeFromArray() {
+ mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class)
+ .returnArrayWithStringDoubleIntMapArrayBooleanNull();
+ waitForBridgeAndUIIdle();
+
+ List calls = mRecordingTestModule.getArrayCalls();
+ assertEquals(1, calls.size());
+ ReadableArray array = calls.get(0);
+
+ assertEquals(ReadableType.String, array.getType(0));
+ assertEquals(ReadableType.Number, array.getType(1));
+ assertEquals(ReadableType.Number, array.getType(2));
+ assertEquals(ReadableType.Map, array.getType(3));
+ assertEquals(ReadableType.Array, array.getType(4));
+ assertEquals(ReadableType.Boolean, array.getType(5));
+ assertEquals(ReadableType.Null, array.getType(6));
+ }
+
+ public void testGetTypeFromMap() {
+ mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class)
+ .returnMapWithStringDoubleIntMapArrayBooleanNull();
+ waitForBridgeAndUIIdle();
+
+ List calls = mRecordingTestModule.getMapCalls();
+ assertEquals(1, calls.size());
+ ReadableMap map = calls.get(0);
+
+ assertEquals(ReadableType.String, map.getType("string"));
+ assertEquals(ReadableType.Number, map.getType("double"));
+ assertEquals(ReadableType.Number, map.getType("int"));
+ assertEquals(ReadableType.Map, map.getType("map"));
+ assertEquals(ReadableType.Array, map.getType("array"));
+ assertEquals(ReadableType.Boolean, map.getType("boolean"));
+ assertEquals(ReadableType.Null, map.getType("null"));
+ }
+
+ public void testGetWrongTypeFromArray() {
+ mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class)
+ .returnArrayWithStringDoubleIntMapArrayBooleanNull();
+ waitForBridgeAndUIIdle();
+
+ List calls = mRecordingTestModule.getArrayCalls();
+ assertEquals(1, calls.size());
+ ReadableArray array = calls.get(0);
+
+ assertUnexpectedTypeExceptionThrown(array, 0, "boolean");
+ assertUnexpectedTypeExceptionThrown(array, 1, "string");
+ assertUnexpectedTypeExceptionThrown(array, 2, "array");
+ assertUnexpectedTypeExceptionThrown(array, 3, "double");
+ assertUnexpectedTypeExceptionThrown(array, 4, "map");
+ assertUnexpectedTypeExceptionThrown(array, 5, "array");
+ }
+
+ public void testGetWrongTypeFromMap() {
+ mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class)
+ .returnMapWithStringDoubleIntMapArrayBooleanNull();
+ waitForBridgeAndUIIdle();
+
+ List calls = mRecordingTestModule.getMapCalls();
+ assertEquals(1, calls.size());
+ ReadableMap map = calls.get(0);
+
+ assertUnexpectedTypeExceptionThrown(map, "string", "double");
+ assertUnexpectedTypeExceptionThrown(map, "double", "map");
+ assertUnexpectedTypeExceptionThrown(map, "int", "boolean");
+ assertUnexpectedTypeExceptionThrown(map, "map", "array");
+ assertUnexpectedTypeExceptionThrown(map, "array", "boolean");
+ assertUnexpectedTypeExceptionThrown(map, "boolean", "string");
+ }
+
+ public void testArrayOutOfBoundsExceptionThrown() {
+ mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnArrayWithBasicTypes();
+ waitForBridgeAndUIIdle();
+
+ List calls = mRecordingTestModule.getArrayCalls();
+ assertEquals(1, calls.size());
+ ReadableArray array = calls.get(0);
+ assertNotNull(array);
+
+ assertArrayOutOfBoundsExceptionThrown(array, -1, "boolean");
+ assertArrayOutOfBoundsExceptionThrown(array, -1, "string");
+ assertArrayOutOfBoundsExceptionThrown(array, -1, "double");
+ assertArrayOutOfBoundsExceptionThrown(array, -1, "int");
+ assertArrayOutOfBoundsExceptionThrown(array, -1, "map");
+ assertArrayOutOfBoundsExceptionThrown(array, -1, "array");
+
+ assertArrayOutOfBoundsExceptionThrown(array, 10, "boolean");
+ assertArrayOutOfBoundsExceptionThrown(array, 10, "string");
+ assertArrayOutOfBoundsExceptionThrown(array, 10, "double");
+ assertArrayOutOfBoundsExceptionThrown(array, 10, "int");
+ assertArrayOutOfBoundsExceptionThrown(array, 10, "map");
+ assertArrayOutOfBoundsExceptionThrown(array, 10, "array");
+ }
+
+ public void testNoSuchKeyExceptionThrown() {
+ mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnMapWithBasicTypes();
+ waitForBridgeAndUIIdle();
+
+ List calls = mRecordingTestModule.getMapCalls();
+ assertEquals(1, calls.size());
+ ReadableMap map = calls.get(0);
+ assertNotNull(map);
+
+ assertNoSuchKeyExceptionThrown(map, "noSuchKey", "double");
+ assertNoSuchKeyExceptionThrown(map, "noSuchKey", "int");
+ assertNoSuchKeyExceptionThrown(map, "noSuchKey", "map");
+ assertNoSuchKeyExceptionThrown(map, "noSuchKey", "array");
+ assertNoSuchKeyExceptionThrown(map, "noSuchKey", "boolean");
+ assertNoSuchKeyExceptionThrown(map, "noSuchKey", "string");
+ }
+
+ public void testIntOutOfRangeThrown() {
+ mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnArrayWithLargeInts();
+ mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnMapWithLargeInts();
+ waitForBridgeAndUIIdle();
+
+ assertEquals(1, mRecordingTestModule.getArrayCalls().size());
+ assertEquals(1, mRecordingTestModule.getMapCalls().size());
+
+ ReadableArray array = mRecordingTestModule.getArrayCalls().get(0);
+ assertNotNull(array);
+
+ ReadableMap map = mRecordingTestModule.getMapCalls().get(0);
+ assertNotNull(map);
+
+ assertEquals(ReadableType.Number, array.getType(0));
+ assertUnexpectedTypeExceptionThrown(array, 0, "int");
+ assertEquals(ReadableType.Number, array.getType(1));
+ assertUnexpectedTypeExceptionThrown(array, 1, "int");
+
+ assertEquals(ReadableType.Number, map.getType("first"));
+ assertUnexpectedTypeExceptionThrown(map, "first", "int");
+ assertEquals(ReadableType.Number, map.getType("second"));
+ assertUnexpectedTypeExceptionThrown(map, "second", "int");
+ }
+
+ public void testMapMerging() {
+ mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnMapForMerge1();
+ mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnMapForMerge2();
+ waitForBridgeAndUIIdle();
+
+ List maps = mRecordingTestModule.getMapCalls();
+ assertEquals(2, maps.size());
+
+ WritableMap dest = new WritableNativeMap();
+ dest.merge(maps.get(0));
+ dest.merge(maps.get(1));
+
+ assertTrue(dest.hasKey("a"));
+ assertTrue(dest.hasKey("b"));
+ assertTrue(dest.hasKey("c"));
+ assertTrue(dest.hasKey("d"));
+ assertTrue(dest.hasKey("e"));
+ assertTrue(dest.hasKey("f"));
+ assertTrue(dest.hasKey("newkey"));
+
+ assertEquals("overwrite", dest.getString("a"));
+ assertEquals(41, dest.getInt("b"));
+ assertEquals("string", dest.getString("c"));
+ assertEquals(77, dest.getInt("d"));
+ assertTrue(dest.isNull("e"));
+ assertEquals(3, dest.getArray("f").size());
+ assertEquals("newvalue", dest.getString("newkey"));
+ }
+
+ public void testMapAccessibleAfterMerge() {
+ mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnMapForMerge1();
+ mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnMapForMerge2();
+ waitForBridgeAndUIIdle();
+
+ List maps = mRecordingTestModule.getMapCalls();
+ assertEquals(2, maps.size());
+
+ WritableMap dest = new WritableNativeMap();
+ dest.merge(maps.get(0));
+ dest.merge(maps.get(1));
+
+ ReadableMap source = maps.get(1);
+
+ assertTrue(source.hasKey("a"));
+ assertTrue(source.hasKey("d"));
+ assertTrue(source.hasKey("e"));
+ assertTrue(source.hasKey("f"));
+ assertTrue(source.hasKey("newkey"));
+
+ assertFalse(source.hasKey("b"));
+ assertFalse(source.hasKey("c"));
+
+ assertEquals("overwrite", source.getString("a"));
+ assertEquals(77, source.getInt("d"));
+ assertTrue(source.isNull("e"));
+ assertEquals(3, source.getArray("f").size());
+ assertEquals("newvalue", source.getString("newkey"));
+ }
+
+ public void testMapIterateOverMapWithBasicTypes() {
+ mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnMapWithBasicTypes();
+ waitForBridgeAndUIIdle();
+
+ List calls = mRecordingTestModule.getMapCalls();
+ assertEquals(1, calls.size());
+ ReadableNativeMap map = (ReadableNativeMap) calls.get(0);
+ assertNotNull(map);
+
+ ReadableMapKeySetIterator mapIterator = map.keySetIterator();
+ Set keys = new HashSet();
+ while (mapIterator.hasNextKey()) {
+ keys.add(mapIterator.nextKey());
+ }
+
+ Set expectedKeys = new HashSet(
+ Arrays.asList("stringKey", "doubleKey", "intKey", "booleanKey", "nullKey"));
+ assertEquals(keys, expectedKeys);
+ }
+
+ public void testMapIterateOverNestedMaps() {
+ mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnNestedMap();
+ waitForBridgeAndUIIdle();
+
+ List calls = mRecordingTestModule.getMapCalls();
+ assertEquals(1, calls.size());
+ ReadableNativeMap map = (ReadableNativeMap) calls.get(0);
+ assertNotNull(map);
+
+ ReadableMapKeySetIterator firstLevelIterator = map.keySetIterator();
+ String firstLevelKey = firstLevelIterator.nextKey();
+ assertEquals(firstLevelKey, "weHaveToGoDeeper");
+
+ ReadableNativeMap secondMap = map.getMap("weHaveToGoDeeper");
+ ReadableMapKeySetIterator secondLevelIterator = secondMap.keySetIterator();
+ String secondLevelKey = secondLevelIterator.nextKey();
+ assertEquals(secondLevelKey, "inception");
+ assertTrue(secondMap.getBoolean(secondLevelKey));
+ }
+
+ public void testInvalidIteratorExceptionThrown() {
+ mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnMapWithBasicTypes();
+ waitForBridgeAndUIIdle();
+
+ List calls = mRecordingTestModule.getMapCalls();
+ assertEquals(1, calls.size());
+ ReadableNativeMap map = (ReadableNativeMap) calls.get(0);
+ assertNotNull(map);
+
+ ReadableMapKeySetIterator mapIterator = map.keySetIterator();
+ while (mapIterator.hasNextKey()) {
+ mapIterator.nextKey();
+ }
+ assertInvalidIteratorExceptionThrown(mapIterator);
+ }
+
+ public void testStringWithMultibyteUTF8Characters() {
+ TestJSToJavaParametersModule jsModule =
+ mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class);
+ jsModule.returnMapWithMultibyteUTF8CharacterString();
+ jsModule.returnArrayWithMultibyteUTF8CharacterString();
+ waitForBridgeAndUIIdle();
+
+ List maps = mRecordingTestModule.getMapCalls();
+ assertEquals(1, maps.size());
+
+ ReadableMap map = maps.get(0);
+ assertEquals("a", map.getString("one-byte"));
+ assertEquals("\u00A2", map.getString("two-bytes"));
+ assertEquals("\u20AC", map.getString("three-bytes"));
+ assertEquals("\uD83D\uDE1C", map.getString("four-bytes"));
+ assertEquals(
+ "\u017C\u00F3\u0142\u0107 g\u0119\u015Bl\u0105 \u6211 \uD83D\uDE0E ja\u017A\u0107",
+ map.getString("mixed"));
+
+ List arrays = mRecordingTestModule.getArrayCalls();
+ assertEquals(1, arrays.size());
+
+ ReadableArray array = arrays.get(0);
+ assertEquals("a", array.getString(0));
+ assertEquals("\u00A2", array.getString(1));
+ assertEquals("\u20AC", array.getString(2));
+ assertEquals("\uD83D\uDE1C", array.getString(3));
+ assertEquals(
+ "\u017C\u00F3\u0142\u0107 g\u0119\u015Bl\u0105 \u6211 \uD83D\uDE0E ja\u017A\u0107",
+ array.getString(4));
+ }
+
+ private void assertUnexpectedTypeExceptionThrown(
+ ReadableArray array,
+ int index,
+ String typeToAskFor) {
+ boolean gotException = false;
+ try {
+ arrayGetByType(array, index, typeToAskFor);
+ } catch (UnexpectedNativeTypeException expected) {
+ gotException = true;
+ }
+
+ assertTrue(gotException);
+ }
+
+ private void assertUnexpectedTypeExceptionThrown(
+ ReadableMap map,
+ String key,
+ String typeToAskFor) {
+ boolean gotException = false;
+ try {
+ mapGetByType(map, key, typeToAskFor);
+ } catch (UnexpectedNativeTypeException expected) {
+ gotException = true;
+ }
+
+ assertTrue(gotException);
+ }
+
+ private void assertArrayOutOfBoundsExceptionThrown(
+ ReadableArray array,
+ int index,
+ String typeToAskFor) {
+ boolean gotException = false;
+ try {
+ arrayGetByType(array, index, typeToAskFor);
+ } catch (ArrayIndexOutOfBoundsException expected) {
+ gotException = true;
+ }
+
+ assertTrue(gotException);
+ }
+
+ private void assertNoSuchKeyExceptionThrown(
+ ReadableMap map,
+ String key,
+ String typeToAskFor) {
+ boolean gotException = false;
+ try {
+ mapGetByType(map, key, typeToAskFor);
+ } catch (NoSuchKeyException expected) {
+ gotException = true;
+ }
+
+ assertTrue(gotException);
+ }
+
+ private static void assertInvalidIteratorExceptionThrown(
+ ReadableMapKeySetIterator iterator) {
+ boolean gotException = false;
+ try {
+ iterator.nextKey();
+ } catch (InvalidIteratorException expected) {
+ gotException = true;
+ }
+
+ assertTrue(gotException);
+ }
+
+ private void arrayGetByType(ReadableArray array, int index, String typeToAskFor) {
+ if (typeToAskFor.equals("double")) {
+ array.getDouble(index);
+ } else if (typeToAskFor.equals("int")) {
+ array.getInt(index);
+ } else if (typeToAskFor.equals("string")) {
+ array.getString(index);
+ } else if (typeToAskFor.equals("array")) {
+ array.getArray(index);
+ } else if (typeToAskFor.equals("map")) {
+ array.getMap(index);
+ } else if (typeToAskFor.equals("boolean")) {
+ array.getBoolean(index);
+ } else {
+ throw new RuntimeException("Unknown type: " + typeToAskFor);
+ }
+ }
+
+ private void mapGetByType(ReadableMap map, String key, String typeToAskFor) {
+ if (typeToAskFor.equals("double")) {
+ map.getDouble(key);
+ } else if (typeToAskFor.equals("int")) {
+ map.getInt(key);
+ } else if (typeToAskFor.equals("string")) {
+ map.getString(key);
+ } else if (typeToAskFor.equals("array")) {
+ map.getArray(key);
+ } else if (typeToAskFor.equals("map")) {
+ map.getMap(key);
+ } else if (typeToAskFor.equals("boolean")) {
+ map.getBoolean(key);
+ } else {
+ throw new RuntimeException("Unknown type: " + typeToAskFor);
+ }
+ }
+
+ private class RecordingTestModule extends BaseJavaModule {
+
+ private final List mBasicTypesCalls = new ArrayList();
+ private final List mArrayCalls = new ArrayList();
+ private final List mMapCalls = new ArrayList();
+
+ @Override
+ public String getName() {
+ return "Recording";
+ }
+
+ @ReactMethod
+ public void receiveBasicTypes(String s, double d, boolean b, String nullableString) {
+ mBasicTypesCalls.add(new Object[]{s, d, b, nullableString});
+ }
+
+ @ReactMethod
+ public void receiveArray(ReadableArray array) {
+ mArrayCalls.add(array);
+ }
+
+ @ReactMethod
+ public void receiveMap(ReadableMap map) {
+ mMapCalls.add(map);
+ }
+
+ public List getBasicTypesCalls() {
+ return mBasicTypesCalls;
+ }
+
+ public List getArrayCalls() {
+ return mArrayCalls;
+ }
+
+ public List getMapCalls() {
+ return mMapCalls;
+ }
+ }
+}
diff --git a/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/CatalystNativeJavaToJSArgumentsTestCase.java b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/CatalystNativeJavaToJSArgumentsTestCase.java
new file mode 100644
index 00000000000000..587f99121860ea
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/CatalystNativeJavaToJSArgumentsTestCase.java
@@ -0,0 +1,381 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.tests;
+
+import java.util.Arrays;
+import java.util.List;
+
+import com.facebook.react.bridge.CatalystInstance;
+import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.bridge.ObjectAlreadyConsumedException;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeArray;
+import com.facebook.react.bridge.WritableNativeMap;
+import com.facebook.react.bridge.UiThreadUtil;
+import com.facebook.react.testing.AssertModule;
+import com.facebook.react.testing.FakeWebSocketModule;
+import com.facebook.react.testing.ReactIntegrationTestCase;
+import com.facebook.react.testing.ReactTestHelper;
+import com.facebook.react.uimanager.UIImplementation;
+import com.facebook.react.uimanager.UIManagerModule;
+import com.facebook.react.uimanager.ViewManager;
+import com.facebook.react.views.view.ReactViewManager;
+
+/**
+ * Test marshalling arguments from Java to JS to appropriate native classes.
+ */
+public class CatalystNativeJavaToJSArgumentsTestCase extends ReactIntegrationTestCase {
+
+ private interface TestJavaToJSArgumentsModule extends JavaScriptModule {
+ void receiveBasicTypes(String s, double d, boolean b, String nullString);
+
+ void receiveArrayWithBasicTypes(WritableArray array);
+ void receiveNestedArray(WritableArray nestedArray);
+ void receiveArrayWithMaps(WritableArray arrayWithMaps);
+
+ void receiveMapWithBasicTypes(WritableMap map);
+ void receiveNestedMap(WritableMap nestedMap);
+ void receiveMapWithArrays(WritableMap mapWithArrays);
+ void receiveMapAndArrayWithNullValues(
+ WritableMap map,
+ WritableArray array);
+ void receiveMapWithMultibyteUTF8CharacterString(WritableMap map);
+ void receiveArrayWithMultibyteUTF8CharacterString(WritableArray array);
+ }
+
+ private AssertModule mAssertModule;
+ private CatalystInstance mInstance;
+
+ @Override
+ protected void setUp() throws Exception {
+ super.setUp();
+
+ List viewManagers = Arrays.asList(
+ new ReactViewManager());
+ final UIManagerModule mUIManager = new UIManagerModule(
+ getContext(),
+ viewManagers,
+ new UIImplementation(getContext(), viewManagers));
+ UiThreadUtil.runOnUiThread(
+ new Runnable() {
+ @Override
+ public void run() {
+ mUIManager.onHostResume();
+ }
+ });
+ waitForIdleSync();
+
+ mAssertModule = new AssertModule();
+
+ mInstance = ReactTestHelper.catalystInstanceBuilder(this)
+ .addNativeModule(mAssertModule)
+ .addNativeModule(new FakeWebSocketModule())
+ .addJSModule(TestJavaToJSArgumentsModule.class)
+ .addNativeModule(mUIManager)
+ .build();
+ }
+
+ public void testBasicTypes() {
+ mInstance.getJSModule(TestJavaToJSArgumentsModule.class)
+ .receiveBasicTypes("foo", 3.14, true, null);
+ waitForBridgeAndUIIdle();
+ mAssertModule.verifyAssertsAndReset();
+ }
+
+ public void testArrayWithBasicTypes() {
+ WritableNativeArray array = new WritableNativeArray();
+ array.pushString("red panda");
+ array.pushDouble(1.19);
+ array.pushBoolean(true);
+ array.pushNull();
+
+ mInstance.getJSModule(TestJavaToJSArgumentsModule.class).receiveArrayWithBasicTypes(array);
+ waitForBridgeAndUIIdle();
+ mAssertModule.verifyAssertsAndReset();
+ }
+
+ public void testNestedArray() {
+ WritableNativeArray level1 = new WritableNativeArray();
+ WritableNativeArray level2 = new WritableNativeArray();
+ WritableNativeArray level3 = new WritableNativeArray();
+ level3.pushString("level3");
+ level2.pushString("level2");
+ level2.pushArray(level3);
+ level1.pushString("level1");
+ level1.pushArray(level2);
+
+ mInstance.getJSModule(TestJavaToJSArgumentsModule.class).receiveNestedArray(level1);
+ waitForBridgeAndUIIdle();
+ mAssertModule.verifyAssertsAndReset();
+ }
+
+ public void testArrayWithMaps() {
+ WritableNativeMap m1 = new WritableNativeMap();
+ WritableNativeMap m2 = new WritableNativeMap();
+ m1.putString("m1k1", "m1v1");
+ m1.putString("m1k2", "m1v2");
+ m2.putString("m2k1", "m2v1");
+
+ WritableNativeArray array = new WritableNativeArray();
+ array.pushMap(m1);
+ array.pushMap(m2);
+ mInstance.getJSModule(TestJavaToJSArgumentsModule.class).receiveArrayWithMaps(array);
+ waitForBridgeAndUIIdle();
+ mAssertModule.verifyAssertsAndReset();
+ }
+
+ public void testMapWithBasicTypes() {
+ WritableNativeMap map = new WritableNativeMap();
+ map.putString("stringKey", "stringValue");
+ map.putDouble("doubleKey", 3.14);
+ map.putBoolean("booleanKey", true);
+ map.putNull("nullKey");
+
+ mInstance.getJSModule(TestJavaToJSArgumentsModule.class).receiveMapWithBasicTypes(map);
+ waitForBridgeAndUIIdle();
+ mAssertModule.verifyAssertsAndReset();
+ }
+
+ public void testNestedMap() {
+ WritableNativeMap map = new WritableNativeMap();
+ WritableNativeMap nestedMap = new WritableNativeMap();
+ nestedMap.putString("animals", "foxes");
+ map.putMap("nestedMap", nestedMap);
+
+ mInstance.getJSModule(TestJavaToJSArgumentsModule.class).receiveNestedMap(map);
+ waitForBridgeAndUIIdle();
+ mAssertModule.verifyAssertsAndReset();
+ }
+
+ public void testMapWithArrays() {
+ WritableNativeMap map = new WritableNativeMap();
+ WritableNativeArray a1 = new WritableNativeArray();
+ WritableNativeArray a2 = new WritableNativeArray();
+ a1.pushDouble(3);
+ a1.pushDouble(1);
+ a1.pushDouble(4);
+ a2.pushDouble(1);
+ a2.pushDouble(9);
+ map.putArray("array1", a1);
+ map.putArray("array2", a2);
+
+ mInstance.getJSModule(TestJavaToJSArgumentsModule.class).receiveMapWithArrays(map);
+ waitForBridgeAndUIIdle();
+ mAssertModule.verifyAssertsAndReset();
+ }
+
+ public void testMapWithNullStringValue() {
+ WritableNativeMap map = new WritableNativeMap();
+ map.putString("string", null);
+ map.putArray("array", null);
+ map.putMap("map", null);
+
+ WritableNativeArray array = new WritableNativeArray();
+ array.pushString(null);
+ array.pushArray(null);
+ array.pushMap(null);
+
+ mInstance.getJSModule(TestJavaToJSArgumentsModule.class)
+ .receiveMapAndArrayWithNullValues(map, array);
+ waitForBridgeAndUIIdle();
+ mAssertModule.verifyAssertsAndReset();
+ }
+
+ public void testStringWithMultibyteUTF8Characters() {
+ TestJavaToJSArgumentsModule jsModule = mInstance.getJSModule(TestJavaToJSArgumentsModule.class);
+
+ WritableNativeMap map = new WritableNativeMap();
+ map.putString("two-bytes", "\u00A2");
+ map.putString("three-bytes", "\u20AC");
+ map.putString("four-bytes", "\uD83D\uDE1C");
+ map.putString(
+ "mixed",
+ "\u017C\u00F3\u0142\u0107 g\u0119\u015Bl\u0105 \u6211 \uD83D\uDE0E ja\u017A\u0107");
+
+ jsModule.receiveMapWithMultibyteUTF8CharacterString(map);
+ waitForBridgeAndUIIdle();
+ mAssertModule.verifyAssertsAndReset();
+
+ WritableArray array = new WritableNativeArray();
+ array.pushString("\u00A2");
+ array.pushString("\u20AC");
+ array.pushString("\uD83D\uDE1C");
+ array.pushString(
+ "\u017C\u00F3\u0142\u0107 g\u0119\u015Bl\u0105 \u6211 \uD83D\uDE0E ja\u017A\u0107");
+
+ jsModule.receiveArrayWithMultibyteUTF8CharacterString(array);
+ waitForBridgeAndUIIdle();
+ mAssertModule.verifyAssertsAndReset();
+ }
+
+ public void testThrowWhenArrayReusedInArray() {
+ boolean gotException = false;
+ try {
+ WritableNativeArray array1 = new WritableNativeArray();
+ WritableNativeArray array2 = new WritableNativeArray();
+ WritableNativeArray child = new WritableNativeArray();
+ array1.pushArray(child);
+ array2.pushArray(child);
+ } catch (ObjectAlreadyConsumedException e) {
+ gotException = true;
+ }
+ assertTrue(gotException);
+ }
+
+ public void testThrowWhenArrayReusedInMap() {
+ boolean gotException = false;
+ try {
+ WritableNativeMap map1 = new WritableNativeMap();
+ WritableNativeMap map2 = new WritableNativeMap();
+ WritableNativeArray child = new WritableNativeArray();
+ map1.putArray("child", child);
+ map2.putArray("child", child);
+ } catch (ObjectAlreadyConsumedException e) {
+ gotException = true;
+ }
+ assertTrue(gotException);
+ }
+
+ public void testThrowWhenMapReusedInArray() {
+ boolean gotException = false;
+ try {
+ WritableNativeArray array1 = new WritableNativeArray();
+ WritableNativeArray array2 = new WritableNativeArray();
+ WritableNativeMap child = new WritableNativeMap();
+ array1.pushMap(child);
+ array2.pushMap(child);
+ } catch (ObjectAlreadyConsumedException e) {
+ gotException = true;
+ }
+ assertTrue(gotException);
+ }
+
+ public void testThrowWhenMapReusedInMap() {
+ boolean gotException = false;
+ try {
+ WritableNativeMap map1 = new WritableNativeMap();
+ WritableNativeMap map2 = new WritableNativeMap();
+ WritableNativeMap child = new WritableNativeMap();
+ map1.putMap("child", child);
+ map2.putMap("child", child);
+ } catch (ObjectAlreadyConsumedException e) {
+ gotException = true;
+ }
+ assertTrue(gotException);
+ }
+
+ public void testThrowWhenAddToConsumedArray() {
+ WritableNativeArray array = new WritableNativeArray();
+ WritableNativeArray parent = new WritableNativeArray();
+ parent.pushArray(array);
+
+ boolean gotException = false;
+ try {
+ array.pushNull();
+ } catch (ObjectAlreadyConsumedException e) {
+ gotException = true;
+ }
+ assertTrue(gotException);
+
+ gotException = false;
+ try {
+ array.pushBoolean(true);
+ } catch (ObjectAlreadyConsumedException e) {
+ gotException = true;
+ }
+ assertTrue(gotException);
+
+ gotException = false;
+ try {
+ array.pushDouble(1);
+ } catch (ObjectAlreadyConsumedException e) {
+ gotException = true;
+ }
+ assertTrue(gotException);
+
+ gotException = false;
+ try {
+ array.pushString("foo");
+ } catch (ObjectAlreadyConsumedException e) {
+ gotException = true;
+ }
+ assertTrue(gotException);
+
+ gotException = false;
+ try {
+ array.pushArray(new WritableNativeArray());
+ } catch (ObjectAlreadyConsumedException e) {
+ gotException = true;
+ }
+ assertTrue(gotException);
+
+ gotException = false;
+ try {
+ array.pushMap(new WritableNativeMap());
+ } catch (ObjectAlreadyConsumedException e) {
+ gotException = true;
+ }
+ assertTrue(gotException);
+ }
+
+ public void testThrowWhenAddToConsumedMap() {
+ WritableNativeMap map = new WritableNativeMap();
+ WritableNativeArray parent = new WritableNativeArray();
+ parent.pushMap(map);
+
+ boolean gotException = false;
+ try {
+ map.putNull("key");
+ } catch (ObjectAlreadyConsumedException e) {
+ gotException = true;
+ }
+ assertTrue(gotException);
+
+ gotException = false;
+ try {
+ map.putBoolean("key", true);
+ } catch (ObjectAlreadyConsumedException e) {
+ gotException = true;
+ }
+ assertTrue(gotException);
+
+ gotException = false;
+ try {
+ map.putDouble("key", 1);
+ } catch (ObjectAlreadyConsumedException e) {
+ gotException = true;
+ }
+ assertTrue(gotException);
+
+ gotException = false;
+ try {
+ map.putString("key", "foo");
+ } catch (ObjectAlreadyConsumedException e) {
+ gotException = true;
+ }
+ assertTrue(gotException);
+
+ gotException = false;
+ try {
+ map.putArray("key", new WritableNativeArray());
+ } catch (ObjectAlreadyConsumedException e) {
+ gotException = true;
+ }
+ assertTrue(gotException);
+
+ gotException = false;
+ try {
+ map.putMap("key", new WritableNativeMap());
+ } catch (ObjectAlreadyConsumedException e) {
+ gotException = true;
+ }
+ assertTrue(gotException);
+ }
+}
diff --git a/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/CatalystSubviewsClippingTestCase.java b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/CatalystSubviewsClippingTestCase.java
new file mode 100644
index 00000000000000..04f1f8a2effc15
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/CatalystSubviewsClippingTestCase.java
@@ -0,0 +1,300 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.tests;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import android.content.Context;
+import javax.annotation.Nullable;
+import android.widget.ScrollView;
+
+import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.testing.ReactAppInstrumentationTestCase;
+import com.facebook.react.testing.ReactInstanceSpecForTest;
+import com.facebook.react.uimanager.PixelUtil;
+import com.facebook.react.uimanager.annotations.ReactProp;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.views.view.ReactViewGroup;
+import com.facebook.react.views.view.ReactViewManager;
+
+import org.junit.Assert;
+import org.junit.Ignore;
+
+/**
+ * Integration test for {@code removeClippedSubviews} property that verify correct scrollview
+ * behavior
+ */
+public class CatalystSubviewsClippingTestCase extends ReactAppInstrumentationTestCase {
+
+ private interface SubviewsClippingTestModule extends JavaScriptModule {
+ void renderClippingSample1();
+ void renderClippingSample2();
+ void renderScrollViewTest();
+ void renderUpdatingSample1(boolean update1, boolean update2);
+ void renderUpdatingSample2(boolean update);
+ }
+
+ private final List mEvents = new ArrayList<>();
+
+ @Override
+ protected String getReactApplicationKeyUnderTest() {
+ return "SubviewsClippingTestApp";
+ }
+
+ @Override
+ protected ReactInstanceSpecForTest createReactInstanceSpecForTest() {
+ ReactInstanceSpecForTest instanceSpec = new ReactInstanceSpecForTest();
+ instanceSpec.addJSModule(SubviewsClippingTestModule.class);
+ instanceSpec.addViewManager(new ClippableViewManager(mEvents));
+ return instanceSpec;
+ }
+
+ /**
+ * In this test view are layout in a following way:
+ * +-----------------------------+
+ * | |
+ * | +---------------------+ |
+ * | | inner1 | |
+ * | +---------------------+ |
+ * | +-------------------------+ |
+ * | | outer (clip=true) | |
+ * | | +---------------------+ | |
+ * | | | inner2 | | |
+ * | | +---------------------+ | |
+ * | | | |
+ * | +-------------------------+ |
+ * | +---------------------+ |
+ * | | inner3 | |
+ * | +---------------------+ |
+ * | |
+ * +-----------------------------+
+ *
+ * We expect only outer and inner2 to be attached
+ */
+ public void XtestOneLevelClippingInView() throws Throwable {
+ mEvents.clear();
+ getReactContext().getJSModule(SubviewsClippingTestModule.class).renderClippingSample1();
+ waitForBridgeAndUIIdle();
+ Assert.assertArrayEquals(new String[]{"Attach_outer", "Attach_inner2"}, mEvents.toArray());
+ }
+
+ /**
+ * In this test view are layout in a following way:
+ * +-----------------------------+
+ * | outer (clip=true) |
+ * | |
+ * | |
+ * | |
+ * | +-----------------------------+
+ * | | complexInner (clip=true) |
+ * | | +----------+ | +---------+ |
+ * | | | inner1 | | | inner2 | |
+ * | | | | | | | |
+ * | | +----------+ | +---------+ |
+ * +--------------+--------------+ |
+ * | +----------+ +---------+ |
+ * | | inner3 | | inner4 | |
+ * | | | | | |
+ * | +----------+ +---------+ |
+ * | |
+ * +-----------------------------+
+ *
+ * We expect outer, complexInner & inner1 to be attached
+ */
+ public void XtestTwoLevelClippingInView() throws Throwable {
+ mEvents.clear();
+ getReactContext().getJSModule(SubviewsClippingTestModule.class).renderClippingSample2();
+ waitForBridgeAndUIIdle();
+ Assert.assertArrayEquals(
+ new String[]{"Attach_outer", "Attach_complexInner", "Attach_inner1"},
+ mEvents.toArray());
+ }
+
+ /**
+ * This test verifies that we update clipped subviews appropriately when some of them gets
+ * re-layouted.
+ *
+ * In this test scenario we render clipping view ("outer") with two subviews, one is outside and
+ * clipped and one is inside (absolutely positioned). By updating view props we first change the
+ * height of the first element so that it should intersect with clipping "outer" view. Then we
+ * update top position of the second view so that is should go off screen.
+ */
+ public void testClippingAfterLayoutInner() {
+ SubviewsClippingTestModule subviewsClippingTestModule =
+ getReactContext().getJSModule(SubviewsClippingTestModule.class);
+
+ mEvents.clear();
+ subviewsClippingTestModule.renderUpdatingSample1(false, false);
+ waitForBridgeAndUIIdle();
+ Assert.assertArrayEquals(new String[]{"Attach_outer", "Attach_inner2"}, mEvents.toArray());
+
+ mEvents.clear();
+ subviewsClippingTestModule.renderUpdatingSample1(true, false);
+ waitForBridgeAndUIIdle();
+ Assert.assertArrayEquals(new String[]{"Attach_inner1"}, mEvents.toArray());
+
+ mEvents.clear();
+ subviewsClippingTestModule.renderUpdatingSample1(true, true);
+ waitForBridgeAndUIIdle();
+ Assert.assertArrayEquals(new String[]{"Detach_inner2"}, mEvents.toArray());
+ }
+
+ /**
+ * This test verifies that we update clipping views appropriately when parent view layout changes
+ * in a way that affects clipping.
+ *
+ * In this test we render clipping view ("outer") set to be 100x100dp with inner view that is
+ * absolutely positioned out of the clipping area of the parent view. Then we resize parent view
+ * so that inner view should be visible.
+ */
+ public void testClippingAfterLayoutParent() {
+ SubviewsClippingTestModule subviewsClippingTestModule =
+ getReactContext().getJSModule(SubviewsClippingTestModule.class);
+
+ mEvents.clear();
+ subviewsClippingTestModule.renderUpdatingSample2(false);
+ waitForBridgeAndUIIdle();
+ Assert.assertArrayEquals(new String[]{"Attach_outer"}, mEvents.toArray());
+
+ mEvents.clear();
+ subviewsClippingTestModule.renderUpdatingSample2(true);
+ waitForBridgeAndUIIdle();
+ Assert.assertArrayEquals(new String[]{"Attach_inner"}, mEvents.toArray());
+ }
+
+ public void testOneLevelClippingInScrollView() throws Throwable {
+ getReactContext().getJSModule(SubviewsClippingTestModule.class).renderScrollViewTest();
+ waitForBridgeAndUIIdle();
+
+ // Only 3 first views should be attached at the beginning
+ Assert.assertArrayEquals(new String[]{"Attach_0", "Attach_1", "Attach_2"}, mEvents.toArray());
+ mEvents.clear();
+
+ // We scroll down such that first view get out of the bounds, we expect the first view to be
+ // detached and 4th view to get attached
+ scrollToDpInUIThread(120);
+ Assert.assertArrayEquals(new String[]{"Detach_0", "Attach_3"}, mEvents.toArray());
+ }
+
+ public void testTwoLevelClippingInScrollView() throws Throwable {
+ getReactContext().getJSModule(SubviewsClippingTestModule.class).renderScrollViewTest();
+ waitForBridgeAndUIIdle();
+
+ final int complexViewOffset = 4 * 120 - 300;
+
+ // Step 1
+ // We scroll down such that first "complex" view is clipped & just below the bottom of the
+ // scroll view
+ scrollToDpInUIThread(complexViewOffset);
+
+ mEvents.clear();
+
+ // Step 2
+ // Scroll a little bit so that "complex" view is visible, but it's inner views are not
+ scrollToDpInUIThread(complexViewOffset + 5);
+
+ Assert.assertArrayEquals(new String[]{"Attach_C0"}, mEvents.toArray());
+ mEvents.clear();
+
+ // Step 3
+ // Scroll even more so that first subview of "complex" view is visible, view 1 will get off
+ // screen
+ scrollToDpInUIThread(complexViewOffset + 100);
+ Assert.assertArrayEquals(new String[]{"Detach_1", "Attach_C0.1"}, mEvents.toArray());
+ mEvents.clear();
+
+ // Step 4
+ // Scroll even more to reveal second subview of "complex" view
+ scrollToDpInUIThread(complexViewOffset + 150);
+ Assert.assertArrayEquals(new String[]{"Attach_C0.2"}, mEvents.toArray());
+ mEvents.clear();
+
+ // Step 5
+ // Scroll back to previous position (Step 3), second view should get detached
+ scrollToDpInUIThread(complexViewOffset + 100);
+ Assert.assertArrayEquals(new String[]{"Detach_C0.2"}, mEvents.toArray());
+ mEvents.clear();
+
+ // Step 6
+ // Scroll back to Step 2, complex view should be visible but all subviews should be detached
+ scrollToDpInUIThread(complexViewOffset + 5);
+ Assert.assertArrayEquals(new String[]{"Attach_1", "Detach_C0.1"}, mEvents.toArray());
+ mEvents.clear();
+
+ // Step 7
+ // Scroll back to Step 1, complex view should be gone
+ scrollToDpInUIThread(complexViewOffset);
+ Assert.assertArrayEquals(new String[]{"Detach_C0"}, mEvents.toArray());
+ }
+
+ private void scrollToDpInUIThread(final int yPositionInDP) throws Throwable {
+ final ScrollView mainScrollView = getViewByTestId("scroll_view");
+ runTestOnUiThread(
+ new Runnable() {
+ @Override
+ public void run() {
+ mainScrollView.scrollTo(0, (int) PixelUtil.toPixelFromDIP(yPositionInDP));
+ }
+ });
+ waitForBridgeAndUIIdle();
+ }
+
+ private static class ClippableView extends ReactViewGroup {
+
+ private String mClippableViewID;
+ private final List mEvents;
+
+ public ClippableView(Context context, List events) {
+ super(context);
+ mEvents = events;
+ }
+
+ @Override
+ protected void onAttachedToWindow() {
+ super.onAttachedToWindow();
+ mEvents.add("Attach_" + mClippableViewID);
+ }
+
+ @Override
+ protected void onDetachedFromWindow() {
+ super.onDetachedFromWindow();
+ mEvents.add("Detach_" + mClippableViewID);
+ }
+
+ public void setClippableViewID(String clippableViewID) {
+ mClippableViewID = clippableViewID;
+ }
+ }
+
+ private static class ClippableViewManager extends ReactViewManager {
+
+ private final List mEvents;
+
+ public ClippableViewManager(List events) {
+ mEvents = events;
+ }
+
+ @Override
+ public String getName() {
+ return "ClippableView";
+ }
+
+ @Override
+ public ReactViewGroup createViewInstance(ThemedReactContext context) {
+ return new ClippableView(context, mEvents);
+ }
+
+ @ReactProp(name = "clippableViewID")
+ public void setClippableViewId(ReactViewGroup view, @Nullable String clippableViewId) {
+ ((ClippableView) view).setClippableViewID(clippableViewId);
+ }
+ }
+}
diff --git a/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/CatalystTouchBubblingTestCase.java b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/CatalystTouchBubblingTestCase.java
new file mode 100644
index 00000000000000..4eac61d1f4d295
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/CatalystTouchBubblingTestCase.java
@@ -0,0 +1,159 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.tests;
+
+import android.view.View;
+
+import com.facebook.react.testing.ReactInstanceSpecForTest;
+import com.facebook.react.testing.ReactAppInstrumentationTestCase;
+import com.facebook.react.testing.SingleTouchGestureGenerator;
+import com.facebook.react.testing.StringRecordingModule;
+
+/**
+ * This test is to verify that touch events bubbles up to the right handler. We emulate couple
+ * of different gestures on top of the application reflecting following layout:
+ *
+ * +---------------------------------------------------------------------------------------+
+ * | |
+ * | +----------------------------------------------------------------------------------+ |
+ * | | +-------------+ +----------------+ | |
+ * | | | +---+ | | | | |
+ * | | | | A | | | | | |
+ * | | | +---+ | | C | | |
+ * | | | {B} | | | | |
+ * | | | | {D} | | | |
+ * | | +-------------+ +----------------+ | |
+ * | | | |
+ * | | | |
+ * | +----------------------------------------------------------------------------------+ |
+ * |
+ * | +----------------------------------------------------------------------------------+ |
+ * | | | |
+ * | | | |
+ * | | | |
+ * | | {E} | |
+ * | | | |
+ * | | | |
+ * | +----------------------------------------------------------------------------------+ |
+ * +---------------------------------------------------------------------------------------+
+ *
+ * Then in each test case we eiter tap the center of a particular view (from A to E) or we start
+ * a gesture in one view and end it with another.
+ * View with names in brackets (e.g. {D}) have touch handlers set whereas all other views are not
+ * declared to handler touch events.
+ */
+public class CatalystTouchBubblingTestCase extends ReactAppInstrumentationTestCase {
+
+ private final StringRecordingModule mRecordingModule = new StringRecordingModule();
+
+ @Override
+ protected String getReactApplicationKeyUnderTest() {
+ return "TouchBubblingTestAppModule";
+ }
+
+ /**
+ * 1) Simulate touch event at view A, expect {B} touch handler to fire
+ * 2) Simulate touch event at view C, expect {D} touch handler to fire
+ */
+ public void testSimpleClickAtInnerElements() {
+ mRecordingModule.reset();
+ View innerButton = getViewByTestId("A");
+ assertNotNull(innerButton);
+ createGestureGenerator().startGesture(innerButton).endGesture();
+ waitForBridgeAndUIIdle();
+ assertEquals(1, mRecordingModule.getCalls().size());
+ assertEquals("inner", mRecordingModule.getCalls().get(0));
+
+ mRecordingModule.reset();
+ innerButton = getViewByTestId("C");
+ assertNotNull(innerButton);
+ createGestureGenerator().startGesture(innerButton).endGesture();
+ waitForBridgeAndUIIdle();
+ assertEquals(1, mRecordingModule.getCalls().size());
+ assertEquals("outer", mRecordingModule.getCalls().get(0));
+ }
+
+ /**
+ * 1) Start touch at view A, then drag and release on view {B} (but outside of A), expect {B}'s
+ * touch handler to fire
+ * 2) Do the same with view C and {D}
+ */
+ public void testDownOnInnerUpOnTouchableParent() {
+ View innerButton = getViewByTestId("A");
+ View touchableParent = getViewByTestId("B");
+
+ SingleTouchGestureGenerator gestureGenerator = createGestureGenerator();
+ gestureGenerator.startGesture(innerButton);
+ // wait for tapped view measurements
+ waitForBridgeAndUIIdle();
+
+ gestureGenerator.dragTo(touchableParent, 15).endGesture();
+ waitForBridgeAndUIIdle();
+ assertEquals(1, mRecordingModule.getCalls().size());
+ assertEquals("inner", mRecordingModule.getCalls().get(0));
+
+ // Do same with second inner view
+ mRecordingModule.reset();
+
+ touchableParent = getViewByTestId("D");
+ innerButton = getViewByTestId("C");
+
+ gestureGenerator = createGestureGenerator();
+ gestureGenerator.startGesture(innerButton);
+ // wait for tapped view measurements
+ waitForBridgeAndUIIdle();
+
+ gestureGenerator.dragTo(touchableParent, 15).endGesture();
+ waitForBridgeAndUIIdle();
+ assertEquals(1, mRecordingModule.getCalls().size());
+ assertEquals("outer", mRecordingModule.getCalls().get(0));
+ }
+
+ /**
+ * Start gesture at view A, then drag and release on view {E}. Expect no touch handlers to fire
+ */
+ public void testDragOutOfTouchable() {
+ View outsideView = getViewByTestId("E");
+ View innerButton = getViewByTestId("A");
+
+ SingleTouchGestureGenerator gestureGenerator = createGestureGenerator();
+ gestureGenerator.startGesture(innerButton);
+ // wait for tapped view measurements
+ waitForBridgeAndUIIdle();
+
+ gestureGenerator.dragTo(outsideView, 15).endGesture();
+ waitForBridgeAndUIIdle();
+ assertTrue(mRecordingModule.getCalls().isEmpty());
+ }
+
+ /**
+ * In this scenario we start gesture at view A (has two touchable parents {B} and {D}) then we
+ * drag and release gesture on view {D}, but outside of {B}. We expect no touch handler to fire
+ */
+ public void testNoEventWhenDragOutOfFirstTouchableParentToItsTouchableParent() {
+ View topLevelTouchable = getViewByTestId("C");
+ View innerButton = getViewByTestId("A");
+
+ SingleTouchGestureGenerator gestureGenerator = createGestureGenerator();
+ gestureGenerator.startGesture(innerButton);
+ // wait for tapped view measurements
+ waitForBridgeAndUIIdle();
+
+ gestureGenerator.dragTo(topLevelTouchable, 15).endGesture();
+ waitForBridgeAndUIIdle();
+ assertTrue(mRecordingModule.getCalls().isEmpty());
+ }
+
+ @Override
+ protected ReactInstanceSpecForTest createReactInstanceSpecForTest() {
+ return new ReactInstanceSpecForTest()
+ .addNativeModule(mRecordingModule);
+ }
+}
diff --git a/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/CatalystUIManagerTestCase.java b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/CatalystUIManagerTestCase.java
new file mode 100644
index 00000000000000..a5945a02d3f317
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/CatalystUIManagerTestCase.java
@@ -0,0 +1,252 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.tests;
+
+import java.util.Arrays;
+import java.util.List;
+
+import android.util.DisplayMetrics;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.FrameLayout;
+import android.widget.TextView;
+
+import com.facebook.react.ReactRootView;
+import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.bridge.UiThreadUtil;
+import com.facebook.react.modules.systeminfo.AndroidInfoModule;
+import com.facebook.react.uimanager.PixelUtil;
+import com.facebook.react.uimanager.UIImplementation;
+import com.facebook.react.uimanager.UIManagerModule;
+import com.facebook.react.uimanager.ViewManager;
+import com.facebook.react.views.text.ReactRawTextManager;
+import com.facebook.react.views.text.ReactTextViewManager;
+import com.facebook.react.views.view.ReactViewManager;
+import com.facebook.react.testing.FakeWebSocketModule;
+import com.facebook.react.testing.ReactIntegrationTestCase;
+import com.facebook.react.testing.ReactTestHelper;
+
+/**
+ * Test case for basic {@link UIManagerModule} functionality.
+ */
+public class CatalystUIManagerTestCase extends ReactIntegrationTestCase {
+ private interface UIManagerTestModule extends JavaScriptModule {
+ void renderFlexTestApplication(int rootTag);
+ void renderFlexWithTextApplication(int rootTag);
+ void renderAbsolutePositionTestApplication(int rootTag);
+ void renderAbsolutePositionBottomRightTestApplication(int rootTag);
+ void renderCenteredTextViewTestApplication(int rootTag, String text);
+ void renderUpdatePositionInListTestApplication(int rootTag);
+ void flushUpdatePositionInList();
+ }
+
+ private UIManagerTestModule jsModule;
+ private UIManagerModule uiManager;
+
+ private int inPixelRounded(int val) {
+ return Math.round(PixelUtil.toPixelFromDIP(val));
+ }
+
+ private boolean isWithinRange(float value, float lower, float upper) {
+ return value >= lower && value <= upper;
+ }
+
+ private ReactRootView createRootView() {
+ ReactRootView rootView = new ReactRootView(getContext());
+ final DisplayMetrics metrics = getContext().getResources().getDisplayMetrics();
+ rootView.setLayoutParams(
+ new FrameLayout.LayoutParams(metrics.widthPixels, metrics.heightPixels));
+ uiManager.addMeasuredRootView(rootView);
+ // We add the root view by posting to the main thread so wait for that to complete so that the
+ // root view tag is added to the view
+ waitForIdleSync();
+ return rootView;
+ }
+
+ @Override
+ protected void setUp() throws Exception {
+ super.setUp();
+
+ List viewManagers = Arrays.asList(
+ new ReactViewManager(),
+ new ReactTextViewManager(),
+ new ReactRawTextManager());
+ uiManager = new UIManagerModule(
+ getContext(),
+ viewManagers,
+ new UIImplementation(getContext(), viewManagers));
+ UiThreadUtil.runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ uiManager.onHostResume();
+ }
+ });
+ waitForIdleSync();
+
+ jsModule = ReactTestHelper.catalystInstanceBuilder(this)
+ .addNativeModule(uiManager)
+ .addNativeModule(new AndroidInfoModule())
+ .addNativeModule(new FakeWebSocketModule())
+ .addJSModule(UIManagerTestModule.class)
+ .build()
+ .getJSModule(UIManagerTestModule.class);
+ }
+
+ public void testFlexUIRendered() {
+ FrameLayout rootView = createRootView();
+ jsModule.renderFlexTestApplication(rootView.getId());
+ waitForBridgeAndUIIdle();
+
+ assertEquals(1, rootView.getChildCount());
+
+ ViewGroup container = getViewByTestId(rootView, "container");
+ assertEquals(inPixelRounded(200), container.getWidth());
+ assertEquals(inPixelRounded(200), container.getHeight());
+ assertEquals(2, container.getChildCount());
+
+ View child0 = container.getChildAt(0);
+ assertEquals(inPixelRounded(100), child0.getWidth());
+ assertEquals(inPixelRounded(200), child0.getHeight());
+
+ View child1 = container.getChildAt(1);
+ assertEquals(inPixelRounded(100), child1.getWidth());
+ assertEquals(inPixelRounded(200), child1.getHeight());
+ }
+
+ public void testFlexWithTextViews() {
+ FrameLayout rootView = createRootView();
+ jsModule.renderFlexWithTextApplication(rootView.getId());
+ waitForBridgeAndUIIdle();
+
+ assertEquals(1, rootView.getChildCount());
+
+ ViewGroup container = getViewByTestId(rootView, "container");
+ assertEquals(inPixelRounded(300), container.getHeight());
+ assertEquals(1, container.getChildCount());
+
+ ViewGroup row = (ViewGroup) container.getChildAt(0);
+ assertEquals(inPixelRounded(300), row.getHeight());
+ assertEquals(2, row.getChildCount());
+
+ // Text measurement adds padding that isn't completely dependent on density so we can't easily
+ // get an exact value here
+ float approximateExpectedTextHeight = inPixelRounded(19);
+ View leftText = row.getChildAt(0);
+ assertTrue(
+ isWithinRange(
+ leftText.getHeight(),
+ approximateExpectedTextHeight - PixelUtil.toPixelFromDIP(1),
+ approximateExpectedTextHeight + PixelUtil.toPixelFromDIP(1)));
+ assertEquals(row.getWidth() / 2 - inPixelRounded(20), leftText.getWidth());
+ assertEquals(inPixelRounded(290), (leftText.getTop() + leftText.getHeight()));
+
+ View rightText = row.getChildAt(1);
+ assertTrue(
+ isWithinRange(
+ rightText.getHeight(),
+ approximateExpectedTextHeight - PixelUtil.toPixelFromDIP(1),
+ approximateExpectedTextHeight + PixelUtil.toPixelFromDIP(1)));
+ assertEquals(leftText.getWidth(), rightText.getWidth());
+ assertEquals(leftText.getTop(), rightText.getTop());
+ assertEquals(leftText.getWidth() + inPixelRounded(30), rightText.getLeft());
+ }
+
+ public void testAbsolutePositionUIRendered() {
+ FrameLayout rootView = createRootView();
+ jsModule.renderAbsolutePositionTestApplication(rootView.getId());
+ waitForBridgeAndUIIdle();
+
+ assertEquals(1, rootView.getChildCount());
+
+ View absoluteView = getViewByTestId(rootView, "absolute");
+ assertEquals(inPixelRounded(50), absoluteView.getWidth());
+ assertEquals(inPixelRounded(60), absoluteView.getHeight());
+ assertEquals(inPixelRounded(10), absoluteView.getLeft());
+ assertEquals(inPixelRounded(15), absoluteView.getTop());
+ }
+
+ public void testUpdatePositionInList() {
+ FrameLayout rootView = createRootView();
+ jsModule.renderUpdatePositionInListTestApplication(rootView.getId());
+ waitForBridgeAndUIIdle();
+
+ ViewGroup containerView = getViewByTestId(rootView, "container");
+ View c0 = containerView.getChildAt(0);
+ View c1 = containerView.getChildAt(1);
+ View c2 = containerView.getChildAt(2);
+
+ assertEquals(inPixelRounded(10), c0.getHeight());
+ assertEquals(inPixelRounded(0), c0.getTop());
+ assertEquals(inPixelRounded(10), c1.getHeight());
+ assertEquals(inPixelRounded(10), c1.getTop());
+ assertEquals(inPixelRounded(10), c2.getHeight());
+ assertEquals(inPixelRounded(20), c2.getTop());
+
+ // Let's make the second elements 50px height instead of 10px
+ jsModule.flushUpdatePositionInList();
+ waitForBridgeAndUIIdle();
+
+ assertEquals(inPixelRounded(10), c0.getHeight());
+ assertEquals(inPixelRounded(0), c0.getTop());
+ assertEquals(inPixelRounded(50), c1.getHeight());
+ assertEquals(inPixelRounded(10), c1.getTop());
+ assertEquals(inPixelRounded(10), c2.getHeight());
+ assertEquals(inPixelRounded(60), c2.getTop());
+ }
+
+ public void testAbsolutePositionBottomRightUIRendered() {
+ FrameLayout rootView = createRootView();
+ jsModule.renderAbsolutePositionBottomRightTestApplication(rootView.getId());
+ waitForBridgeAndUIIdle();
+
+ assertEquals(1, rootView.getChildCount());
+
+ ViewGroup containerView = getViewByTestId(rootView, "container");
+ View absoluteView = containerView.getChildAt(0);
+
+ assertEquals(inPixelRounded(50), absoluteView.getWidth());
+ assertEquals(inPixelRounded(60), absoluteView.getHeight());
+ assertEquals(inPixelRounded(100 - 50 - 10), Math.round(absoluteView.getLeft()));
+ assertEquals(inPixelRounded(100 - 60 - 15), Math.round(absoluteView.getTop()));
+ }
+
+ public void _testCenteredText(String text) {
+ ReactRootView rootView = new ReactRootView(getContext());
+ int rootTag = uiManager.addMeasuredRootView(rootView);
+
+ jsModule.renderCenteredTextViewTestApplication(rootTag, text);
+ waitForBridgeAndUIIdle();
+
+ TextView textView = getViewByTestId(rootView, "text");
+
+ // text view should be centered
+ String msg = "text `" + text + "` is not centered";
+ assertTrue(msg, textView.getLeft() > 0.1);
+ assertTrue(msg, textView.getTop() > 0.1);
+ assertEquals(
+ msg,
+ (int) Math.ceil((inPixelRounded(200) - textView.getWidth()) * 0.5f),
+ textView.getLeft());
+ assertEquals(
+ msg,
+ (int) Math.ceil((inPixelRounded(100) - textView.getHeight()) * 0.5f),
+ textView.getTop());
+ }
+
+ public void testCenteredTextCases() {
+ String[] cases = new String[] {
+ "test",
+ "with whitespace",
+ };
+ for (String text : cases) {
+ _testCenteredText(text);
+ }
+ }
+}
diff --git a/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/DatePickerDialogTestCase.java b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/DatePickerDialogTestCase.java
new file mode 100644
index 00000000000000..2ca86f482367f8
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/DatePickerDialogTestCase.java
@@ -0,0 +1,177 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.tests;
+
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.List;
+
+import android.app.DatePickerDialog;
+import android.content.DialogInterface;
+import android.support.v4.app.DialogFragment;
+import android.support.v4.app.Fragment;
+import android.widget.DatePicker;
+
+import com.facebook.react.bridge.BaseJavaModule;
+import com.facebook.react.testing.ReactInstanceSpecForTest;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+import com.facebook.react.modules.datepicker.DatePickerDialogModule;
+import com.facebook.react.testing.ReactAppInstrumentationTestCase;
+
+/**
+ * Test case for {@link DatePickerDialogModule} options and callbacks.
+ */
+public class DatePickerDialogTestCase extends ReactAppInstrumentationTestCase {
+
+ private static interface DatePickerDialogTestModule extends JavaScriptModule {
+ public void showDatePickerDialog(WritableMap options);
+ }
+
+ private static class DatePickerDialogRecordingModule extends BaseJavaModule {
+
+ private final List mDates = new ArrayList();
+ private int mDismissed = 0;
+ private int mErrors = 0;
+
+ @Override
+ public String getName() {
+ return "DatePickerDialogRecordingModule";
+ }
+
+ @ReactMethod
+ public void recordDate(int year, int month, int day) {
+ mDates.add(new Integer[] {year, month, day});
+ }
+
+ @ReactMethod
+ public void recordDismissed() {
+ mDismissed++;
+ }
+
+ @ReactMethod
+ public void recordError() {
+ mErrors++;
+ }
+
+ public List getDates() {
+ return new ArrayList(mDates);
+ }
+
+ public int getDismissed() {
+ return mDismissed;
+ }
+
+ public int getErrors() {
+ return mErrors;
+ }
+ }
+
+ final DatePickerDialogRecordingModule mRecordingModule = new DatePickerDialogRecordingModule();
+
+ @Override
+ protected ReactInstanceSpecForTest createReactInstanceSpecForTest() {
+ return super.createReactInstanceSpecForTest()
+ .addNativeModule(mRecordingModule)
+ .addJSModule(DatePickerDialogTestModule.class);
+ }
+
+ @Override
+ protected String getReactApplicationKeyUnderTest() {
+ return "DatePickerDialogTestApp";
+ }
+
+ private static long getDateInMillis(int year, int month, int date) {
+ final Calendar c = Calendar.getInstance();
+ c.set(Calendar.YEAR, year);
+ c.set(Calendar.MONTH, month);
+ c.set(Calendar.DATE, date);
+ return c.getTimeInMillis();
+ }
+
+ private DatePickerDialogTestModule getTestModule() {
+ return getReactContext().getCatalystInstance().getJSModule(DatePickerDialogTestModule.class);
+ }
+
+ private DialogFragment showDialog(WritableMap options) {
+ getTestModule().showDatePickerDialog(options);
+
+ waitForBridgeAndUIIdle();
+ getInstrumentation().waitForIdleSync();
+
+ return (DialogFragment) getActivity().getSupportFragmentManager()
+ .findFragmentByTag(DatePickerDialogModule.FRAGMENT_TAG);
+ }
+
+ public void testShowBasicDatePicker() {
+ final Fragment datePickerFragment = showDialog(null);
+
+ assertNotNull(datePickerFragment);
+ }
+
+ public void testPresetDate() {
+ final WritableMap options = new WritableNativeMap();
+ options.putDouble("date", getDateInMillis(2020, 5, 6));
+
+ final DialogFragment datePickerFragment = showDialog(options);
+ final DatePicker datePicker =
+ ((DatePickerDialog) datePickerFragment.getDialog()).getDatePicker();
+
+ assertEquals(2020, datePicker.getYear());
+ assertEquals(5, datePicker.getMonth());
+ assertEquals(6, datePicker.getDayOfMonth());
+ }
+
+ public void testCallback() throws Throwable {
+ final WritableMap options = new WritableNativeMap();
+ options.putDouble("date", getDateInMillis(2020, 5, 6));
+
+ final DialogFragment datePickerFragment = showDialog(options);
+
+ runTestOnUiThread(
+ new Runnable() {
+ @Override
+ public void run() {
+ ((DatePickerDialog) datePickerFragment.getDialog())
+ .getButton(DialogInterface.BUTTON_POSITIVE).performClick();
+ }
+ });
+
+ getInstrumentation().waitForIdleSync();
+ waitForBridgeAndUIIdle();
+
+ assertEquals(0, mRecordingModule.getErrors());
+ assertEquals(1, mRecordingModule.getDates().size());
+ assertEquals(2020, (int) mRecordingModule.getDates().get(0)[0]);
+ assertEquals(5, (int) mRecordingModule.getDates().get(0)[1]);
+ assertEquals(6, (int) mRecordingModule.getDates().get(0)[2]);
+ }
+
+ public void testDismissCallback() throws Throwable {
+ final DialogFragment datePickerFragment = showDialog(null);
+
+ runTestOnUiThread(
+ new Runnable() {
+ @Override
+ public void run() {
+ datePickerFragment.getDialog().dismiss();
+ }
+ });
+
+ getInstrumentation().waitForIdleSync();
+ waitForBridgeAndUIIdle();
+
+ assertEquals(0, mRecordingModule.getErrors());
+ assertEquals(0, mRecordingModule.getDates().size());
+ assertEquals(1, mRecordingModule.getDismissed());
+ }
+
+}
diff --git a/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/InitialPropsTestCase.java b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/InitialPropsTestCase.java
new file mode 100644
index 00000000000000..951c593533e453
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/InitialPropsTestCase.java
@@ -0,0 +1,129 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.tests;
+
+import android.os.Bundle;
+import android.test.ActivityInstrumentationTestCase2;
+
+import com.facebook.react.bridge.BaseJavaModule;
+import com.facebook.react.testing.FakeWebSocketModule;
+import com.facebook.react.testing.ReactInstanceSpecForTest;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.testing.ReactAppTestActivity;
+
+/**
+ * Simple test case for passing initial props to the root React application.
+ */
+public class InitialPropsTestCase extends
+ ActivityInstrumentationTestCase2 {
+
+ public static final String DEFAULT_JS_BUNDLE = "AndroidTestBundle.js";
+
+ private static class RecordingModule extends BaseJavaModule {
+ private int mCount = 0;
+ private ReadableMap mProps;
+
+ @Override
+ public String getName() {
+ return "InitialPropsRecordingModule";
+ }
+
+ @ReactMethod
+ public void recordProps(ReadableMap props) {
+ mProps = props;
+ mCount++;
+ }
+
+ public int getCount() {
+ return mCount;
+ }
+
+ public ReadableMap getProps() {
+ return mProps;
+ }
+ }
+
+ private RecordingModule mRecordingModule;
+
+ public InitialPropsTestCase() {
+ super(ReactAppTestActivity.class);
+ }
+
+ @Override
+ protected void setUp() throws Exception {
+ super.setUp();
+
+ mRecordingModule = new RecordingModule();
+ }
+
+ public void testInitialProps() throws Throwable {
+ final ReactAppTestActivity activity = getActivity();
+ runTestOnUiThread(
+ new Runnable() {
+ @Override
+ public void run() {
+ ReactInstanceSpecForTest catalystInstanceSpec = new ReactInstanceSpecForTest();
+ catalystInstanceSpec.addNativeModule(new FakeWebSocketModule());
+ catalystInstanceSpec.addNativeModule(mRecordingModule);
+ Bundle props = new Bundle();
+ props.putString("key1", "string");
+ props.putInt("key2", 5);
+ props.putDouble("key3", 5.5);
+ props.putFloat("key4", 5.6f);
+ props.putBoolean("key5", true);
+ props.putStringArray("key6", new String[]{"one", "two", "three"});
+ props.putIntArray("key7", new int[]{1, 2, 3});
+ props.putDoubleArray("key8", new double[]{1.5, 2.5, 3.5});
+ props.putFloatArray("key9", new float[]{1.6f, 2.6f, 3.6f});
+ props.putBooleanArray("key10", new boolean[]{true, false});
+ activity.loadApp(
+ "InitialPropsTestApp",
+ catalystInstanceSpec,
+ props,
+ DEFAULT_JS_BUNDLE,
+ false);
+ }
+ });
+ activity.waitForBridgeAndUIIdle();
+
+ assertEquals(1, mRecordingModule.getCount());
+ ReadableMap props = mRecordingModule.getProps();
+ assertEquals("string", props.getString("key1"));
+ assertEquals(5, props.getInt("key2"));
+ assertEquals(5.5, props.getDouble("key3"));
+ assertEquals(5.6f, (float) props.getDouble("key4"));
+ assertEquals(true, props.getBoolean("key5"));
+
+ ReadableArray stringArray = props.getArray("key6");
+ assertEquals("one", stringArray.getString(0));
+ assertEquals("two", stringArray.getString(1));
+ assertEquals("three", stringArray.getString(2));
+
+ ReadableArray intArray = props.getArray("key7");
+ assertEquals(1, intArray.getInt(0));
+ assertEquals(2, intArray.getInt(1));
+ assertEquals(3, intArray.getInt(2));
+
+ ReadableArray doubleArray = props.getArray("key8");
+ assertEquals(1.5, doubleArray.getDouble(0));
+ assertEquals(2.5, doubleArray.getDouble(1));
+ assertEquals(3.5, doubleArray.getDouble(2));
+
+ ReadableArray floatArray = props.getArray("key9");
+ assertEquals(1.6f, (float) floatArray.getDouble(0));
+ assertEquals(2.6f, (float) floatArray.getDouble(1));
+ assertEquals(3.6f, (float) floatArray.getDouble(2));
+
+ ReadableArray booleanArray = props.getArray("key10");
+ assertEquals(true, booleanArray.getBoolean(0));
+ assertEquals(false, booleanArray.getBoolean(1));
+ }
+}
diff --git a/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/JSLocaleTest.java b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/JSLocaleTest.java
new file mode 100644
index 00000000000000..d20b72fb47c613
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/JSLocaleTest.java
@@ -0,0 +1,104 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.tests;
+
+import java.util.Arrays;
+import java.util.List;
+
+import com.facebook.react.testing.FakeWebSocketModule;
+import com.facebook.react.testing.ReactIntegrationTestCase;
+import com.facebook.react.testing.ReactTestHelper;
+import com.facebook.react.testing.StringRecordingModule;
+import com.facebook.react.bridge.CatalystInstance;
+import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.bridge.UiThreadUtil;
+import com.facebook.react.uimanager.UIImplementation;
+import com.facebook.react.uimanager.UIManagerModule;
+import com.facebook.react.uimanager.ViewManager;
+import com.facebook.react.views.view.ReactViewManager;
+
+/**
+ * Test locale-based functionality of JS VM
+ */
+public class JSLocaleTest extends ReactIntegrationTestCase {
+
+ private interface TestJSLocaleModule extends JavaScriptModule {
+ void toUpper(String string);
+ void toLower(String string);
+ }
+
+ StringRecordingModule mStringRecordingModule;
+
+ private CatalystInstance mInstance;
+
+ @Override
+ protected void setUp() throws Exception {
+ super.setUp();
+
+ List viewManagers = Arrays.asList(
+ new ReactViewManager());
+ final UIManagerModule mUIManager = new UIManagerModule(
+ getContext(),
+ viewManagers,
+ new UIImplementation(getContext(), viewManagers));
+ UiThreadUtil.runOnUiThread(
+ new Runnable() {
+ @Override
+ public void run() {
+ mUIManager.onHostResume();
+ }
+ });
+ waitForIdleSync();
+
+ mStringRecordingModule = new StringRecordingModule();
+ mInstance = ReactTestHelper.catalystInstanceBuilder(this)
+ .addNativeModule(mStringRecordingModule)
+ .addNativeModule(mUIManager)
+ .addNativeModule(new FakeWebSocketModule())
+ .addJSModule(TestJSLocaleModule.class)
+ .build();
+ }
+
+ public void testToUpper() {
+ TestJSLocaleModule testModule = mInstance.getJSModule(TestJSLocaleModule.class);
+ waitForBridgeAndUIIdle();
+
+ testModule.toUpper("test");
+ testModule.toUpper("W niżach mógł zjeść truflę koń bądź psy");
+ testModule.toUpper("Шеф взъÑрён тчк щипцы Ñ Ñхом гудбай Жюль");
+ testModule.toUpper("Γαζίες καὶ μυÏτιὲς δὲν θὰ βÏῶ πιὰ στὸ χÏυσαφὶ ξÎφωτο");
+ testModule.toUpper("chinese: 幓 åŽåªå™ éˆŠé‡¿é– ç¢žç¢ ç²» 曮禷");
+ waitForBridgeAndUIIdle();
+
+ String[] answers = mStringRecordingModule.getCalls().toArray(new String[0]);
+ assertEquals("TEST", answers[0]);
+ assertEquals("W NIŻACH MÓGŠZJEŚĆ TRUFLĘ KOŃ BĄDŹ PSY", answers[1]);
+ assertEquals("ШЕФ ВЗЪЯРÐРТЧК ЩИПЦЫ С ÐХОМ ГУДБÐЙ ЖЮЛЬ", answers[2]);
+ assertEquals("ΓΑΖΊΕΣ ΚΑῚ ΜΥΡΤΙῈΣ ΔῈΠΘᾺ ΒΡΩ͂ ΠΙᾺ ΣΤῸ ΧΡΥΣΑΦῚ ΞΈΦΩΤΟ", answers[3]);
+ assertEquals("CHINESE: 幓 åŽåªå™ éˆŠé‡¿é– ç¢žç¢ ç²» 曮禷", answers[4]);
+ }
+
+ public void testToLower() {
+ TestJSLocaleModule testModule = mInstance.getJSModule(TestJSLocaleModule.class);
+
+ testModule.toLower("TEST");
+ testModule.toLower("W NIŻACH MÓGŠZJEŚĆ TRUFLĘ KOŃ BĄDŹ psy");
+ testModule.toLower("ШЕФ ВЗЪЯРÐРТЧК ЩИПЦЫ С ÐХОМ ГУДБÐЙ ЖЮЛЬ");
+ testModule.toLower("ΓΑΖΊΕΣ ΚΑῚ ΜΥΡΤΙῈΣ ΔῈΠΘᾺ ΒΡΩ͂ ΠΙᾺ ΣΤῸ ΧΡΥΣΑΦῚ ΞΈΦΩΤΟ");
+ testModule.toLower("CHINESE: 幓 åŽåªå™ éˆŠé‡¿é– ç¢žç¢ ç²» 曮禷");
+ waitForBridgeAndUIIdle();
+
+ String[] answers = mStringRecordingModule.getCalls().toArray(new String[0]);
+ assertEquals("test", answers[0]);
+ assertEquals("w niżach mógł zjeść truflę koń bądź psy", answers[1]);
+ assertEquals("шеф взъÑрён тчк щипцы Ñ Ñхом гудбай жюль", answers[2]);
+ assertEquals("γαζίες καὶ μυÏτιὲς δὲν θὰ βÏῶ πιὰ στὸ χÏυσαφὶ ξÎφωτο", answers[3]);
+ assertEquals("chinese: 幓 åŽåªå™ éˆŠé‡¿é– ç¢žç¢ ç²» 曮禷", answers[4]);
+ }
+}
diff --git a/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/JSResponderTestCase.java b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/JSResponderTestCase.java
new file mode 100644
index 00000000000000..39947db0fea84d
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/JSResponderTestCase.java
@@ -0,0 +1,68 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.tests;
+
+import android.widget.ScrollView;
+
+import com.facebook.react.uimanager.PixelUtil;
+import com.facebook.react.testing.ReactAppInstrumentationTestCase;
+import com.facebook.react.testing.SingleTouchGestureGenerator;
+
+/**
+ * Test case to verify that JSResponder flow work correctly.
+ *
+ * In a single test case scenario we have a view with pan gesture recognizer containing a scrollview
+ * We werify that by vertical drags affects a scrollview while horizontal drags are suppose to
+ * be recognized by pan responder and setJSResponder should be triggered resulting in scrollview
+ * events being intercepted.
+ */
+public class JSResponderTestCase extends ReactAppInstrumentationTestCase {
+
+ @Override
+ protected String getReactApplicationKeyUnderTest() {
+ return "JSResponderTestApp";
+ }
+
+ public void testResponderLocksScrollView() {
+ ScrollView scrollView = getViewByTestId("scroll_view");
+ assertNotNull(scrollView);
+ assertEquals(0, scrollView.getScrollY());
+
+ float inpx40dp = PixelUtil.toPixelFromDIP(40f);
+ float inpx100dp = PixelUtil.toPixelFromDIP(100f);
+
+ SingleTouchGestureGenerator gestureGenerator = createGestureGenerator();
+
+ gestureGenerator
+ .startGesture(30, 30 + inpx100dp)
+ .dragTo(30 + inpx40dp, 30, 10, 1200)
+ .endGesture(180, 100);
+
+ waitForBridgeAndUIIdle();
+
+ assertTrue("Expected to scroll by at least 80 dp", scrollView.getScrollY() >= inpx100dp * .8f);
+
+ int previousScroll = scrollView.getScrollY();
+
+ gestureGenerator
+ .startGesture(30, 30 + inpx100dp)
+ .dragTo(30 + inpx40dp, 30 + inpx100dp, 10, 1200);
+
+ waitForBridgeAndUIIdle();
+
+ gestureGenerator
+ .dragTo(30 + inpx40dp, 30, 10, 1200)
+ .endGesture();
+
+ waitForBridgeAndUIIdle();
+ assertEquals("Expected not to scroll", scrollView.getScrollY(), previousScroll);
+
+ }
+
+}
diff --git a/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/LayoutEventsTestCase.java b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/LayoutEventsTestCase.java
new file mode 100644
index 00000000000000..6e201641e7a505
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/LayoutEventsTestCase.java
@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.tests;
+
+import com.facebook.react.testing.ReactAppInstrumentationTestCase;
+import com.facebook.react.testing.ReactInstanceSpecForTest;
+import com.facebook.react.testing.StringRecordingModule;
+
+/**
+ * Simple test to verify that layout events (onLayout) propagate to JS from native.
+ */
+public class LayoutEventsTestCase extends ReactAppInstrumentationTestCase {
+
+ private StringRecordingModule mStringRecordingModule;
+
+ @Override
+ protected String getReactApplicationKeyUnderTest() {
+ return "LayoutEventsTestApp";
+ }
+
+ /**
+ * Creates a UI in JS and verifies the onLayout handler is called.
+ */
+ public void testOnLayoutCalled() {
+ assertEquals(1, mStringRecordingModule.getCalls().size());
+ assertEquals("10,10-100x100", mStringRecordingModule.getCalls().get(0));
+ }
+
+ @Override
+ protected ReactInstanceSpecForTest createReactInstanceSpecForTest() {
+ mStringRecordingModule = new StringRecordingModule();
+ return super.createReactInstanceSpecForTest()
+ .addNativeModule(mStringRecordingModule);
+ }
+}
diff --git a/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/ProgressBarTestCase.java b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/ProgressBarTestCase.java
new file mode 100644
index 00000000000000..0886f20fa4b0f5
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/ProgressBarTestCase.java
@@ -0,0 +1,132 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.tests;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+
+import android.content.res.Resources;
+import android.util.DisplayMetrics;
+import android.util.TypedValue;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.FrameLayout;
+import android.widget.ProgressBar;
+
+import com.facebook.react.ReactRootView;
+import com.facebook.react.bridge.CatalystInstance;
+import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.bridge.UiThreadUtil;
+import com.facebook.react.modules.systeminfo.AndroidInfoModule;
+import com.facebook.react.uimanager.UIImplementation;
+import com.facebook.react.uimanager.UIManagerModule;
+import com.facebook.react.uimanager.ViewManager;
+import com.facebook.react.views.progressbar.ReactProgressBarViewManager;
+import com.facebook.react.views.view.ReactViewManager;
+import com.facebook.react.testing.FakeWebSocketModule;
+import com.facebook.react.testing.ReactIntegrationTestCase;
+import com.facebook.react.testing.ReactTestHelper;
+
+/**
+ * Test to verify that Progress bar renders as a view of the right size
+ */
+public class ProgressBarTestCase extends ReactIntegrationTestCase {
+
+ // Has same order of progressBars in ProgressBarTestModule
+ private static final String[] styleList =
+ new String[] {"Horizontal", "Small", "Large", "Inverse", "SmallInverse", "LargeInverse"};
+ private static final HashMap styles = new HashMap();
+
+ static {
+ styles.put("Horizontal", android.R.attr.progressBarStyleHorizontal);
+ styles.put("Small", android.R.attr.progressBarStyleSmall);
+ styles.put("Large", android.R.attr.progressBarStyleLarge);
+ styles.put("Inverse", android.R.attr.progressBarStyleInverse);
+ styles.put("SmallInverse", android.R.attr.progressBarStyleSmallInverse);
+ styles.put("LargeInverse", android.R.attr.progressBarStyleLargeInverse);
+}
+
+ private static interface ProgressBarTestModule extends JavaScriptModule {
+ public void renderProgressBarApplication(int rootTag);
+ }
+
+ private UIManagerModule mUIManager;
+ private CatalystInstance mInstance;
+ private ReactRootView mRootView;
+
+ @Override
+ protected void setUp() throws Exception {
+ super.setUp();
+
+ List viewManagers = Arrays.asList(
+ new ReactViewManager(),
+ new ReactProgressBarViewManager());
+ mUIManager = new UIManagerModule(
+ getContext(),
+ viewManagers,
+ new UIImplementation(getContext(), viewManagers));
+ UiThreadUtil.runOnUiThread(
+ new Runnable() {
+ @Override
+ public void run() {
+ mUIManager.onHostResume();
+ }
+ });
+ waitForIdleSync();
+
+ mInstance = ReactTestHelper.catalystInstanceBuilder(this)
+ .addNativeModule(mUIManager)
+ .addNativeModule(new AndroidInfoModule())
+ .addNativeModule(new FakeWebSocketModule())
+ .addJSModule(ProgressBarTestModule.class)
+ .build();
+
+ mRootView = new ReactRootView(getContext());
+ DisplayMetrics metrics = getContext().getResources().getDisplayMetrics();
+ mRootView.setLayoutParams(
+ new FrameLayout.LayoutParams(metrics.widthPixels, metrics.heightPixels));
+ int rootTag = mUIManager.addMeasuredRootView(mRootView);
+ mInstance.getJSModule(ProgressBarTestModule.class).renderProgressBarApplication(rootTag);
+ waitForBridgeAndUIIdle();
+ }
+
+ /**
+ * Test that the sizes of the progressBars are setup correctly
+ */
+ public void testProgressBarSizes() {
+ for (String style : styleList) {
+ ProgressBar newProgressBar =
+ new ProgressBar(getContext(), null, styles.get(style));
+ final int spec = View.MeasureSpec.makeMeasureSpec(
+ ViewGroup.LayoutParams.WRAP_CONTENT,
+ View.MeasureSpec.UNSPECIFIED);
+ newProgressBar.measure(spec, spec);
+ final int expectedHeight = newProgressBar.getMeasuredHeight();
+
+ // verify correct size of view containing ProgressBar
+ View viewContainingProgressBar = getViewByTestId(mRootView, style);
+ assertEquals(expectedHeight, viewContainingProgressBar.getHeight());
+
+ assertTrue(((ViewGroup) viewContainingProgressBar).getChildAt(0) instanceof ProgressBar);
+ }
+ }
+
+ public void testProgressBarWidth() {
+ View viewContainingProgressBar = getViewByTestId(mRootView, "Horizontal200");
+ assertEquals(viewContainingProgressBar.getWidth(), dpToPixels(200));
+ ProgressBar progressBar = (ProgressBar) ((ViewGroup) viewContainingProgressBar).getChildAt(0);
+ assertEquals(progressBar.getWidth(), dpToPixels(200));
+ }
+
+ private int dpToPixels(int dp) {
+ Resources r = getContext().getResources();
+ return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, dp, r.getDisplayMetrics());
+ }
+}
diff --git a/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/ReactHorizontalScrollViewTestCase.java b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/ReactHorizontalScrollViewTestCase.java
new file mode 100644
index 00000000000000..963442d470624d
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/ReactHorizontalScrollViewTestCase.java
@@ -0,0 +1,134 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.tests;
+
+import java.util.ArrayList;
+
+import android.view.View;
+import android.widget.HorizontalScrollView;
+
+import com.facebook.react.testing.AbstractScrollViewTestCase;
+import com.facebook.react.testing.SingleTouchGestureGenerator;
+import com.facebook.react.uimanager.PixelUtil;
+
+/**
+ * Integration test for horizontal ScrollView.
+ * See ScrollViewTestModule.js
+ */
+public class ReactHorizontalScrollViewTestCase extends AbstractScrollViewTestCase {
+
+ @Override
+ protected String getReactApplicationKeyUnderTest() {
+ return "HorizontalScrollViewTestApp";
+ }
+
+ private void dragLeft() {
+ dragLeft(200);
+ }
+
+ private void dragLeft(int durationMs) {
+ createGestureGenerator()
+ .startGesture(150, 50)
+ .dragTo(50, 60, 10, durationMs)
+ .endGesture(50, 60);
+ }
+
+ public void testScrolling() {
+ HorizontalScrollView scrollView = getViewAtPath(0);
+ assertNotNull(scrollView);
+ assertEquals(0, scrollView.getScrollX());
+
+ dragLeft();
+
+ assertTrue("Expected to scroll by at least 50 pixels", scrollView.getScrollX() >= 50);
+ }
+
+ public void testScrollEvents() {
+ HorizontalScrollView scrollView = getViewAtPath(0);
+
+ dragLeft();
+
+ waitForBridgeAndUIIdle();
+ mScrollListenerModule.waitForScrollIdle();
+ waitForBridgeAndUIIdle();
+
+ ArrayList xOffsets = mScrollListenerModule.getXOffsets();
+ assertFalse("Expected to receive at least one scroll event", xOffsets.isEmpty());
+ assertTrue("Expected offset to be greater than 0", xOffsets.get(xOffsets.size() - 1) > 0);
+ assertTrue(
+ "Expected no item click event fired",
+ mScrollListenerModule.getItemsPressed().isEmpty());
+ assertEquals(
+ "Expected last offset to be offset of scroll view",
+ PixelUtil.toDIPFromPixel(scrollView.getScrollX()),
+ xOffsets.get(xOffsets.size() - 1).doubleValue(),
+ 1e-5);
+ }
+
+ public void testScrollAndClick() throws Exception {
+ SingleTouchGestureGenerator gestureGenerator = createGestureGenerator();
+
+ // Slowly drag the ScrollView to prevent fling
+ dragLeft(15000);
+
+ waitForBridgeAndUIIdle();
+ getInstrumentation().waitForIdleSync();
+
+ // Find visible item to be clicked
+ View visibleItem = null;
+ int visibleItemNumber = 0;
+ for (; visibleItemNumber < 100; visibleItemNumber++) {
+ visibleItem = getViewAtPath(0, 0, visibleItemNumber);
+ int pos[] = new int[2];
+ visibleItem.getLocationInWindow(pos);
+ if (pos[0] >= 0) {
+ break;
+ }
+ }
+
+ // Click first visible item
+ gestureGenerator.startGesture(visibleItem).endGesture();
+ waitForBridgeAndUIIdle();
+
+ ArrayList xOffsets = mScrollListenerModule.getXOffsets();
+ ArrayList itemIds = mScrollListenerModule.getItemsPressed();
+ assertFalse("Expected to receive at least one scroll event", xOffsets.isEmpty());
+ assertTrue("Expected offset to be greater than 0", xOffsets.get(xOffsets.size() - 1) > 0);
+ assertEquals("Expected to receive exactly one item click event", 1, itemIds.size());
+ assertEquals(visibleItemNumber, (int) itemIds.get(0));
+ }
+
+ /**
+ * Verify that 'scrollTo' command makes ScrollView start scrolling
+ */
+ public void testScrollToCommand() throws Exception {
+ HorizontalScrollView scrollView = getViewAtPath(0);
+ ScrollViewTestModule jsModule =
+ getReactContext().getCatalystInstance().getJSModule(ScrollViewTestModule.class);
+
+ assertEquals(0, scrollView.getScrollX());
+
+ jsModule.scrollTo(300, 0);
+ waitForBridgeAndUIIdle();
+ getInstrumentation().waitForIdleSync();
+
+ // Unfortunately we need to use timeouts here in order to wait for scroll animation to happen
+ // there is no better way (yet) for waiting for scroll animation to finish
+ long timeout = 10000;
+ long interval = 50;
+ long start = System.currentTimeMillis();
+ while (System.currentTimeMillis() - start < timeout) {
+ if (scrollView.getScrollX() > 0) {
+ break;
+ }
+ Thread.sleep(interval);
+ }
+ assertNotSame(0, scrollView.getScrollX());
+ }
+}
diff --git a/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/ReactPickerTestCase.java b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/ReactPickerTestCase.java
new file mode 100644
index 00000000000000..5ad6d82e6fdd64
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/ReactPickerTestCase.java
@@ -0,0 +1,208 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.tests;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import android.graphics.Color;
+import android.widget.Spinner;
+import android.widget.SpinnerAdapter;
+import android.widget.TextView;
+
+import com.facebook.react.bridge.BaseJavaModule;
+import com.facebook.react.testing.ReactInstanceSpecForTest;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.views.picker.ReactDialogPickerManager;
+import com.facebook.react.views.picker.ReactDropdownPickerManager;
+import com.facebook.react.views.picker.ReactPicker;
+import com.facebook.react.views.picker.ReactPickerManager;
+import com.facebook.react.testing.ReactAppInstrumentationTestCase;
+
+/**
+ * Integration test for {@link ReactDialogPickerManager} and {@link ReactDropdownPickerManager}
+ * (and, implicitly, {@link ReactPickerManager}). Tests basic properties, events and switching
+ * between spinner modes (which changes the used manager).
+ */
+public class ReactPickerTestCase extends ReactAppInstrumentationTestCase {
+
+ private static interface PickerAndroidTestModule extends JavaScriptModule {
+ public void selectItem(int position);
+ public void setMode(String mode);
+ public void setPrimaryColor(String color);
+ }
+
+ public static class PickerAndroidRecordingModule extends BaseJavaModule {
+ private final List mSelections = new ArrayList();
+
+ @Override
+ public String getName() {
+ return "PickerAndroidRecordingModule";
+ }
+
+ @ReactMethod
+ public void recordSelection(int position) {
+ mSelections.add(position);
+ }
+
+ public List getSelections() {
+ return new ArrayList(mSelections);
+ }
+ }
+
+ private PickerAndroidRecordingModule mRecordingModule;
+
+ @Override
+ protected String getReactApplicationKeyUnderTest() {
+ return "PickerAndroidTestApp";
+ }
+
+ @Override
+ protected ReactInstanceSpecForTest createReactInstanceSpecForTest() {
+ mRecordingModule = new PickerAndroidRecordingModule();
+ return super.createReactInstanceSpecForTest()
+ .addJSModule(PickerAndroidTestModule.class)
+ .addNativeModule(mRecordingModule);
+ }
+
+ public void testBasicProperties() {
+ ReactPicker spinner = getViewAtPath(0, 0);
+ SpinnerAdapter adapter = spinner.getAdapter();
+
+ assertEquals(Spinner.MODE_DIALOG, spinner.getMode());
+ assertEquals("prompt", spinner.getPrompt());
+ assertNotNull(adapter);
+ assertEquals(3, adapter.getCount());
+ assertEquals("item1", ((TextView) adapter.getView(0, null, null)).getText());
+ assertEquals("item2", ((TextView) adapter.getView(1, null, null)).getText());
+ assertEquals("item3", ((TextView) adapter.getView(2, null, null)).getText());
+ assertEquals(1, spinner.getSelectedItemPosition());
+
+ // test colors
+ assertEquals(Color.RED, ((TextView) adapter.getView(0, null, null)).getCurrentTextColor());
+ assertEquals(Color.GREEN, ((TextView) adapter.getView(1, null, null)).getCurrentTextColor());
+ assertEquals(Color.BLUE, ((TextView) adapter.getView(2, null, null)).getCurrentTextColor());
+ assertEquals(
+ Color.RED,
+ ((TextView) adapter.getDropDownView(0, null, null)).getCurrentTextColor());
+ assertEquals(
+ Color.GREEN,
+ ((TextView) adapter.getDropDownView(1, null, null)).getCurrentTextColor());
+ assertEquals(
+ Color.BLUE,
+ ((TextView) adapter.getDropDownView(2, null, null)).getCurrentTextColor());
+ getTestModule().setPrimaryColor("black");
+ waitForBridgeAndUIIdle();
+ assertEquals(Color.BLACK, ((TextView) adapter.getView(0, null, null)).getCurrentTextColor());
+ assertEquals(Color.BLACK, ((TextView) adapter.getView(1, null, null)).getCurrentTextColor());
+ assertEquals(Color.BLACK, ((TextView) adapter.getView(2, null, null)).getCurrentTextColor());
+ assertEquals(
+ Color.RED,
+ ((TextView) adapter.getDropDownView(0, null, null)).getCurrentTextColor());
+ assertEquals(
+ Color.GREEN,
+ ((TextView) adapter.getDropDownView(1, null, null)).getCurrentTextColor());
+ assertEquals(
+ Color.BLUE,
+ ((TextView) adapter.getDropDownView(2, null, null)).getCurrentTextColor());
+
+ }
+
+ public void testDropdownPicker() {
+ ReactPicker spinner = getViewAtPath(0, 1);
+
+ assertEquals(Spinner.MODE_DROPDOWN, spinner.getMode());
+ }
+
+ public void testDisabledPicker() {
+ ReactPicker spinner = getViewAtPath(0, 2);
+
+ assertFalse(spinner.isEnabled());
+ }
+
+ public void testUpdateSelectedItem() {
+ ReactPicker spinner = getViewAtPath(0, 0);
+ assertEquals(1, spinner.getSelectedItemPosition());
+
+ getTestModule().selectItem(2);
+ waitForBridgeAndUIIdle();
+ getInstrumentation().waitForIdleSync();
+
+ assertEquals(2, spinner.getSelectedItemPosition());
+ }
+
+ public void testUpdateMode() {
+ ReactPicker spinner = getViewAtPath(0, 1);
+ assertEquals(Spinner.MODE_DROPDOWN, spinner.getMode());
+
+ getTestModule().setMode("dialog");
+ waitForBridgeAndUIIdle();
+ getInstrumentation().waitForIdleSync();
+
+ // changing the spinner mode in JS actually creates a new component on the native side, as
+ // there's no way to change the mode once you have constructed a Spinner.
+ ReactPicker newPicker = getViewAtPath(0, 1);
+ assertTrue(spinner != newPicker);
+ assertEquals(Spinner.MODE_DIALOG, newPicker.getMode());
+ }
+
+ public void testOnSelect() throws Throwable {
+ runTestOnUiThread(
+ new Runnable() {
+ @Override
+ public void run() {
+ ReactPicker spinner = getViewAtPath(0, 0);
+ spinner.setSelection(2);
+ }
+ });
+
+ getInstrumentation().waitForIdleSync();
+ waitForBridgeAndUIIdle();
+
+ List selections = mRecordingModule.getSelections();
+ assertEquals(1, selections.size());
+ assertEquals(2, (int) selections.get(0));
+ }
+
+ public void testOnSelectSequence() throws Throwable {
+ updateFirstSpinnerAndCheckLastSpinnerMatches(0);
+ updateFirstSpinnerAndCheckLastSpinnerMatches(2);
+ updateFirstSpinnerAndCheckLastSpinnerMatches(0);
+ updateFirstSpinnerAndCheckLastSpinnerMatches(2);
+ }
+
+ private void updateFirstSpinnerAndCheckLastSpinnerMatches(
+ final int indexToSelect
+ ) throws Throwable {
+ // The last spinner has the same selected value as the first one.
+ // Test that user selection is propagated correctly to JS, to setState, and to Spinners.
+ runTestOnUiThread(
+ new Runnable() {
+ @Override
+ public void run() {
+ ReactPicker spinner = getViewAtPath(0, 0);
+ spinner.setSelection(indexToSelect);
+ }
+ });
+ getInstrumentation().waitForIdleSync();
+ waitForBridgeAndUIIdle();
+
+ ReactPicker spinnerInSync = getViewAtPath(0, 3);
+ assertEquals(
+ "Picker selection was not updated correctly via setState.",
+ indexToSelect,
+ spinnerInSync.getSelectedItemPosition());
+ }
+
+ private PickerAndroidTestModule getTestModule() {
+ return getReactContext().getCatalystInstance().getJSModule(PickerAndroidTestModule.class);
+ }
+
+}
diff --git a/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/ReactRootViewTestCase.java b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/ReactRootViewTestCase.java
new file mode 100644
index 00000000000000..6ee0bed8796f27
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/ReactRootViewTestCase.java
@@ -0,0 +1,106 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.tests;
+
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.FrameLayout;
+
+import com.facebook.react.testing.ReactInstanceSpecForTest;
+import com.facebook.react.testing.ReactAppInstrumentationTestCase;
+import com.facebook.react.testing.StringRecordingModule;
+import com.facebook.react.ReactRootView;
+
+import org.junit.Ignore;
+
+/**
+ * Integration test for {@link ReactRootView}.
+ */
+public class ReactRootViewTestCase extends ReactAppInstrumentationTestCase {
+
+ private StringRecordingModule mRecordingModule;
+
+ @Override
+ protected String getReactApplicationKeyUnderTest() {
+ return "CatalystRootViewTestApp";
+ }
+
+ @Ignore("t6596940: fix intermittently failing test")
+ public void testResizeRootView() throws Throwable {
+ final ReactRootView rootView = (ReactRootView) getRootView();
+ final View childView = rootView.getChildAt(0);
+
+ assertEquals(rootView.getWidth(), childView.getWidth());
+
+ final int newWidth = rootView.getWidth() / 2;
+
+ runTestOnUiThread(
+ new Runnable() {
+ @Override
+ public void run() {
+ rootView.setLayoutParams(new FrameLayout.LayoutParams(
+ newWidth,
+ ViewGroup.LayoutParams.MATCH_PARENT));
+ }
+ });
+
+ getInstrumentation().waitForIdleSync();
+ waitForBridgeAndUIIdle();
+
+ assertEquals(newWidth, childView.getWidth());
+ }
+
+ /**
+ * Verify that removing the root view from hierarchy will trigger subviews removal both on JS and
+ * native side
+ */
+ public void testRemoveRootView() throws Throwable {
+ final ReactRootView rootView = (ReactRootView) getRootView();
+
+ assertEquals(1, rootView.getChildCount());
+
+ runTestOnUiThread(
+ new Runnable() {
+ @Override
+ public void run() {
+ ViewGroup parent = (ViewGroup) rootView.getParent();
+ parent.removeView(rootView);
+ // removing from parent should not remove child views, child views should be removed as
+ // an effect of native call to UIManager.removeRootView
+ assertEquals(1, rootView.getChildCount());
+ }
+ });
+
+ getInstrumentation().waitForIdleSync();
+ waitForBridgeAndUIIdle();
+
+ assertEquals("root component should not be automatically unmounted", 0, mRecordingModule.getCalls().size());
+ assertEquals(1, rootView.getChildCount());
+
+ runTestOnUiThread(
+ new Runnable() {
+ @Override
+ public void run() {
+ rootView.unmountReactApplication();
+ }
+ });
+ waitForBridgeAndUIIdle();
+
+ assertEquals(1, mRecordingModule.getCalls().size());
+ assertEquals("RootComponentWillUnmount", mRecordingModule.getCalls().get(0));
+ assertEquals(0, rootView.getChildCount());
+ }
+
+ @Override
+ protected ReactInstanceSpecForTest createReactInstanceSpecForTest() {
+ mRecordingModule = new StringRecordingModule();
+ return new ReactInstanceSpecForTest()
+ .addNativeModule(mRecordingModule);
+ }
+}
diff --git a/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/ReactScrollViewTestCase.java b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/ReactScrollViewTestCase.java
new file mode 100644
index 00000000000000..45a47a67383e5d
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/ReactScrollViewTestCase.java
@@ -0,0 +1,136 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.tests;
+
+import java.util.ArrayList;
+
+import android.view.View;
+import android.widget.ScrollView;
+
+import com.facebook.react.testing.AbstractScrollViewTestCase;
+import com.facebook.react.testing.SingleTouchGestureGenerator;
+import com.facebook.react.uimanager.PixelUtil;
+
+/**
+ * Integration test for vertical ScrollView.
+ * See ScrollViewTestModule.js
+ */
+public class ReactScrollViewTestCase extends AbstractScrollViewTestCase {
+
+ @Override
+ protected String getReactApplicationKeyUnderTest() {
+ return "ScrollViewTestApp";
+ }
+
+ private void dragUp() {
+ dragUp(200);
+ }
+
+ private void dragUp(int durationMs) {
+ createGestureGenerator()
+ .startGesture(200, 200)
+ .dragTo(180, 100, 10, durationMs)
+ .endGesture(180, 100);
+ }
+
+ public void testScrolling() {
+ ScrollView scrollView = getViewAtPath(0);
+ assertNotNull(scrollView);
+ assertEquals(0, scrollView.getScrollY());
+
+ dragUp();
+
+ assertTrue("Expected to scroll by at least 50 pixels", scrollView.getScrollY() >= 50);
+ }
+
+ public void testScrollEvents() {
+ ScrollView scrollView = getViewAtPath(0);
+
+ dragUp();
+
+ waitForBridgeAndUIIdle();
+ mScrollListenerModule.waitForScrollIdle();
+ waitForBridgeAndUIIdle();
+
+ ArrayList yOffsets = mScrollListenerModule.getYOffsets();
+ assertFalse("Expected to receive at least one scroll event", yOffsets.isEmpty());
+ assertTrue("Expected offset to be greater than 0", yOffsets.get(yOffsets.size() - 1) > 0);
+ assertTrue(
+ "Expected no item click event fired",
+ mScrollListenerModule.getItemsPressed().isEmpty());
+ assertEquals(
+ "Expected last offset to be offset of scroll view",
+ PixelUtil.toDIPFromPixel(scrollView.getScrollY()),
+ yOffsets.get(yOffsets.size() - 1).doubleValue(),
+ 1e-5);
+ assertTrue("Begin and End Drag should be called", mScrollListenerModule.dragEventsMatch());
+ }
+
+ public void testScrollAndClick() throws Exception {
+ SingleTouchGestureGenerator gestureGenerator = createGestureGenerator();
+
+ // Slowly drag the ScrollView to prevent fling
+ dragUp(15000);
+
+ waitForBridgeAndUIIdle();
+ getInstrumentation().waitForIdleSync();
+
+ // Find visible item to be clicked
+ View visibleItem = null;
+ int visibleItemNumber = 0;
+ for (; visibleItemNumber < 100; visibleItemNumber++) {
+ visibleItem = getViewAtPath(0, 0, visibleItemNumber);
+ int pos[] = new int[2];
+ visibleItem.getLocationInWindow(pos);
+ if (pos[1] >= 0) {
+ break;
+ }
+ }
+
+ // Click first visible item
+ gestureGenerator.startGesture(visibleItem).endGesture();
+ waitForBridgeAndUIIdle();
+
+ ArrayList yOffsets = mScrollListenerModule.getYOffsets();
+ ArrayList itemIds = mScrollListenerModule.getItemsPressed();
+ assertFalse("Expected to receive at least one scroll event", yOffsets.isEmpty());
+ assertTrue("Expected offset to be greater than 0", yOffsets.get(yOffsets.size() - 1) > 0);
+ assertEquals("Expected to receive exactly one item click event", 1, itemIds.size());
+ assertEquals(visibleItemNumber, (int) itemIds.get(0));
+ }
+
+ /**
+ * Verify that 'scrollTo' command makes ScrollView start scrolling
+ */
+ public void testScrollToCommand() throws Exception {
+ ScrollView scrollView = getViewAtPath(0);
+ ScrollViewTestModule jsModule =
+ getReactContext().getCatalystInstance().getJSModule(ScrollViewTestModule.class);
+
+ assertEquals(0, scrollView.getScrollY());
+
+ jsModule.scrollTo(0, 300);
+ waitForBridgeAndUIIdle();
+ getInstrumentation().waitForIdleSync();
+
+ // Unfortunately we need to use timeouts here in order to wait for scroll animation to happen
+ // there is no better way (yet) for waiting for scroll animation to finish
+ long timeout = 10000;
+ long interval = 50;
+ long start = System.currentTimeMillis();
+ while (System.currentTimeMillis() - start < timeout) {
+ if (scrollView.getScrollY() > 0) {
+ break;
+ }
+ Thread.sleep(interval);
+ }
+ assertNotSame(0, scrollView.getScrollY());
+ assertFalse("Drag should not be called with scrollTo", mScrollListenerModule.dragEventsMatch());
+ }
+}
diff --git a/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/ReactSwipeRefreshLayoutTestCase.java b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/ReactSwipeRefreshLayoutTestCase.java
new file mode 100644
index 00000000000000..1026be3c759947
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/ReactSwipeRefreshLayoutTestCase.java
@@ -0,0 +1,104 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.tests;
+
+import android.view.View;
+
+import com.facebook.react.testing.ReactAppInstrumentationTestCase;
+import com.facebook.react.testing.ReactInstanceSpecForTest;
+import com.facebook.react.bridge.BaseJavaModule;
+import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.views.swiperefresh.ReactSwipeRefreshLayout;
+
+/**
+ * Test case for {@link ReactSwipeRefreshLayout}.
+ */
+public class ReactSwipeRefreshLayoutTestCase extends ReactAppInstrumentationTestCase {
+
+ private class SwipeRefreshLayoutRecordingModule extends BaseJavaModule {
+ private int mCount = 0;
+
+ @Override
+ public String getName() {
+ return "SwipeRefreshLayoutRecordingModule";
+ }
+
+ @ReactMethod
+ public void onRefresh() {
+ mCount++;
+ }
+
+ public int getCount() {
+ return mCount;
+ }
+ }
+
+ private interface SwipeRefreshLayoutTestModule extends JavaScriptModule {
+ void setRows(int rows);
+ }
+
+ private final SwipeRefreshLayoutRecordingModule mRecordingModule =
+ new SwipeRefreshLayoutRecordingModule();
+
+ @Override
+ protected String getReactApplicationKeyUnderTest() {
+ return "SwipeRefreshLayoutTestApp";
+ }
+
+ @Override
+ protected ReactInstanceSpecForTest createReactInstanceSpecForTest() {
+ return super.createReactInstanceSpecForTest()
+ .addNativeModule(mRecordingModule)
+ .addJSModule(SwipeRefreshLayoutTestModule.class);
+ }
+
+ public void testRefreshNoScroll() {
+ View refreshLayout = getViewAtPath(0);
+
+ createGestureGenerator()
+ .startGesture(refreshLayout.getWidth() / 2, 10)
+ .dragTo(refreshLayout.getWidth() / 2, refreshLayout.getHeight() / 2, 100, 1000)
+ .endGesture();
+ waitForBridgeAndUIIdle();
+ assertEquals(1, mRecordingModule.getCount());
+ }
+
+ public void testRefreshScroll() {
+ View refreshLayout = getViewAtPath(0);
+
+ getReactContext().getJSModule(SwipeRefreshLayoutTestModule.class).setRows(100);
+
+ createGestureGenerator()
+ .startGesture(refreshLayout.getWidth() / 2, 10)
+ .dragTo(refreshLayout.getWidth() / 2, refreshLayout.getHeight() / 2, 100, 1000)
+ .endGesture();
+ waitForBridgeAndUIIdle();
+ assertEquals(1, mRecordingModule.getCount());
+ }
+
+ public void testNoRefreshAfterScroll() {
+ View refreshLayout = getViewAtPath(0);
+
+ getReactContext().getJSModule(SwipeRefreshLayoutTestModule.class).setRows(100);
+
+ createGestureGenerator()
+ .startGesture(refreshLayout.getWidth() / 2, refreshLayout.getHeight() / 2)
+ .dragTo(refreshLayout.getWidth() / 2, 10, 100, 1000)
+ .endGesture();
+ waitForBridgeAndUIIdle();
+ createGestureGenerator()
+ .startGesture(refreshLayout.getWidth() / 2, 10)
+ .dragTo(refreshLayout.getWidth() / 2, refreshLayout.getHeight() / 2, 100, 1000)
+ .endGesture();
+ waitForBridgeAndUIIdle();
+ assertEquals(0, mRecordingModule.getCount());
+ }
+
+}
diff --git a/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/TestIdTestCase.java b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/TestIdTestCase.java
new file mode 100644
index 00000000000000..90ac857c2827f5
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/TestIdTestCase.java
@@ -0,0 +1,63 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.tests;
+
+import java.util.Arrays;
+import java.util.List;
+
+import android.view.View;
+
+import com.facebook.react.views.picker.ReactDropdownPickerManager;
+import com.facebook.react.testing.ReactAppInstrumentationTestCase;
+import com.facebook.react.testing.ReactInstanceSpecForTest;
+import com.facebook.react.testing.ReactTestHelper;
+
+
+/**
+ * Tests that the 'testID' property can be set on various views.
+ * The 'testID' property is used to locate views in UI tests.
+ */
+public class TestIdTestCase extends ReactAppInstrumentationTestCase {
+
+ @Override
+ protected String getReactApplicationKeyUnderTest() {
+ return "TestIdTestApp";
+ }
+
+ private final List viewTags = Arrays.asList(
+ "Image",
+ "ProgressBar",
+ "ScrollView",
+ "Horizontal ScrollView",
+ "Dropdown Picker",
+ "Dialog Picker",
+ "Switch",
+ "Text",
+ "TouchableBounce",
+ "TouchableHighlight",
+ "TouchableOpacity",
+ "TouchableWithoutFeedback",
+ "Toolbar",
+ "TextInput",
+ "View",
+ // "WebView", TODO t11449130
+ "ScrollView Item (same id used for all items)"
+ );
+
+ public void testPropertyIsSetForViews() {
+ for (String tag : viewTags) {
+ View viewWithTag = ReactTestHelper.getViewWithReactTestId(
+ getActivity().getRootView(),
+ tag);
+ assertNotNull(
+ "View with testID tag " + tag + " was not found. Check TestIdTestModule.js.",
+ viewWithTag);
+ }
+ }
+}
diff --git a/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/TextInputTestCase.java b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/TextInputTestCase.java
new file mode 100644
index 00000000000000..9558a5d912af60
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/TextInputTestCase.java
@@ -0,0 +1,223 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.tests;
+
+import android.graphics.Color;
+import android.text.style.ForegroundColorSpan;
+import android.util.TypedValue;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.EditText;
+
+import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.common.SystemClock;
+import com.facebook.react.testing.ReactAppInstrumentationTestCase;
+import com.facebook.react.testing.ReactInstanceSpecForTest;
+import com.facebook.react.uimanager.PixelUtil;
+import com.facebook.react.uimanager.UIManagerModule;
+import com.facebook.react.uimanager.events.EventDispatcher;
+import com.facebook.react.views.textinput.ReactEditText;
+import com.facebook.react.views.textinput.ReactTextChangedEvent;
+import com.facebook.react.views.textinput.ReactTextInputEvent;
+
+/**
+ * Test to verify that TextInput renders correctly
+ */
+public class TextInputTestCase extends ReactAppInstrumentationTestCase {
+
+ private interface TextInputTestModule extends JavaScriptModule {
+ void setValueRef(String ref, String value);
+ }
+
+ /**
+ * Test that the actual height of the text input is not dependant on the font size of the text
+ * within.
+ */
+ public void testTextInputMeasurements() {
+ View textInputViewHeightSet = getViewByTestId("textInput1");
+ EditText textInputViewNoHeight = getViewByTestId("textInput2");
+
+ int expectedHeight = Math.round(PixelUtil.toPixelFromDIP(30));
+ assertEquals(expectedHeight, textInputViewHeightSet.getHeight());
+
+ EditText editText = new EditText(textInputViewNoHeight.getContext());
+ editText.setTextSize(
+ TypedValue.COMPLEX_UNIT_PX,
+ (float) Math.ceil(PixelUtil.toPixelFromSP(21.f)));
+ editText.setPadding(0, 0, 0, 0);
+ int measureSpec = View.MeasureSpec.makeMeasureSpec(
+ ViewGroup.LayoutParams.WRAP_CONTENT,
+ View.MeasureSpec.UNSPECIFIED);
+ editText.measure(measureSpec, measureSpec);
+
+ assertEquals(editText.getMeasuredHeight(), textInputViewNoHeight.getHeight());
+ }
+
+ /**
+ * Test that the cursor moves to the end of the word.
+ */
+ public void testTextInputCursorPosition() throws Throwable {
+ final EditText textInputWithText = getViewByTestId("textInput3");
+
+ runTestOnUiThread(
+ new Runnable() {
+ @Override
+ public void run() {
+ textInputWithText.setSelection(3);
+ }
+ });
+ getReactContext().getJSModule(TextInputTestModule.class)
+ .setValueRef("textInput3", "Some other value");
+ waitForBridgeAndUIIdle();
+
+ assertEquals(4, textInputWithText.getSelectionStart());
+ assertEquals(4, textInputWithText.getSelectionEnd());
+ }
+
+ /**
+ * Test that the colors are applied to new text
+ */
+ public void testTextInputColors() throws Throwable {
+ String testIDs[] = new String[] {"textInput4", "textInput5", "textInput6"};
+
+ for (String testID : testIDs) {
+ getReactContext().getJSModule(TextInputTestModule.class).setValueRef(testID, "NewText");
+ }
+ waitForBridgeAndUIIdle();
+
+ for (String testID : testIDs) {
+ ReactEditText reactEditText = getViewByTestId(testID);
+ assertEquals(
+ Color.GREEN,
+ reactEditText.getText().getSpans(0, 1, ForegroundColorSpan.class)[0]
+ .getForegroundColor());
+ }
+ }
+
+ /**
+ * Test that the mentions input has colors displayed correctly.
+ */
+ public void testMetionsInputColors() throws Throwable {
+ EventDispatcher eventDispatcher =
+ getReactContext().getNativeModule(UIManagerModule.class).getEventDispatcher();
+ ReactEditText reactEditText = getViewByTestId("tokenizedInput");
+ String newText = "#Things and more #things";
+ int contentWidth = reactEditText.getWidth();
+ int contentHeight = reactEditText.getHeight();
+ int start = 0;
+ int count = newText.length();
+
+ eventDispatcher.dispatchEvent(
+ new ReactTextChangedEvent(
+ reactEditText.getId(),
+ SystemClock.nanoTime(),
+ newText.toString(),
+ (int) PixelUtil.toDIPFromPixel(contentWidth),
+ (int) PixelUtil.toDIPFromPixel(contentHeight),
+ reactEditText.incrementAndGetEventCounter()));
+
+ eventDispatcher.dispatchEvent(
+ new ReactTextInputEvent(
+ reactEditText.getId(),
+ SystemClock.nanoTime(),
+ newText.toString(),
+ "",
+ start,
+ start + count - 1));
+ waitForBridgeAndUIIdle();
+
+ ForegroundColorSpan[] spans = reactEditText
+ .getText().getSpans(0, reactEditText.getText().length(), ForegroundColorSpan.class);
+ assertEquals(2, spans.length);
+ assertEquals(spans[0].getForegroundColor(), spans[1].getForegroundColor());
+ assertEquals(0, reactEditText.getText().getSpanStart(spans[1]));
+ assertEquals(7, reactEditText.getText().getSpanEnd(spans[1]));
+ assertEquals(newText.length() - 7, reactEditText.getText().getSpanStart(spans[0]));
+ assertEquals(newText.length(), reactEditText.getText().getSpanEnd(spans[0]));
+
+ String moreText = "andsuch ";
+ String previousText = newText;
+ newText += moreText;
+ count = moreText.length();
+ start = previousText.length();
+
+ eventDispatcher.dispatchEvent(
+ new ReactTextChangedEvent(
+ reactEditText.getId(),
+ SystemClock.nanoTime(),
+ newText.toString(),
+ (int) PixelUtil.toDIPFromPixel(contentWidth),
+ (int) PixelUtil.toDIPFromPixel(contentHeight),
+ reactEditText.incrementAndGetEventCounter()));
+
+ eventDispatcher.dispatchEvent(
+ new ReactTextInputEvent(
+ reactEditText.getId(),
+ SystemClock.nanoTime(),
+ moreText,
+ "",
+ start,
+ start + count - 1));
+ waitForBridgeAndUIIdle();
+
+ spans = reactEditText.getText()
+ .getSpans(0, reactEditText.getText().length(), ForegroundColorSpan.class);
+ assertEquals(2, spans.length);
+ assertEquals(spans[0].getForegroundColor(), spans[1].getForegroundColor());
+ assertEquals(0, reactEditText.getText().getSpanStart(spans[1]));
+ assertEquals(7, reactEditText.getText().getSpanEnd(spans[1]));
+ assertEquals(newText.length() - 15, reactEditText.getText().getSpanStart(spans[0]));
+ assertEquals(newText.length() - 1, reactEditText.getText().getSpanEnd(spans[0]));
+
+ moreText = "morethings";
+ previousText = newText;
+ newText += moreText;
+ count = moreText.length();
+ start = previousText.length();
+
+ eventDispatcher.dispatchEvent(
+ new ReactTextChangedEvent(
+ reactEditText.getId(),
+ SystemClock.nanoTime(),
+ newText.toString(),
+ (int) PixelUtil.toDIPFromPixel(contentWidth),
+ (int) PixelUtil.toDIPFromPixel(contentHeight),
+ reactEditText.incrementAndGetEventCounter()));
+
+ eventDispatcher.dispatchEvent(
+ new ReactTextInputEvent(
+ reactEditText.getId(),
+ SystemClock.nanoTime(),
+ moreText,
+ "",
+ start,
+ start + count - 1));
+ waitForBridgeAndUIIdle();
+
+ spans = reactEditText.getText()
+ .getSpans(0, reactEditText.getText().length(), ForegroundColorSpan.class);
+ assertEquals(spans[0].getForegroundColor(), spans[1].getForegroundColor());
+ assertEquals(2, spans.length);
+ assertEquals(0, reactEditText.getText().getSpanStart(spans[1]));
+ assertEquals(7, reactEditText.getText().getSpanEnd(spans[1]));
+ assertEquals(newText.length() - 25, reactEditText.getText().getSpanStart(spans[0]));
+ assertEquals(newText.length() - 11, reactEditText.getText().getSpanEnd(spans[0]));
+ }
+
+ @Override
+ protected ReactInstanceSpecForTest createReactInstanceSpecForTest() {
+ return super.createReactInstanceSpecForTest()
+ .addJSModule(TextInputTestModule.class);
+ }
+
+ @Override
+ protected String getReactApplicationKeyUnderTest() {
+ return "TextInputTestApp";
+ }
+}
diff --git a/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/TimePickerDialogTestCase.java b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/TimePickerDialogTestCase.java
new file mode 100644
index 00000000000000..516170de4bdbf8
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/TimePickerDialogTestCase.java
@@ -0,0 +1,161 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.tests;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import android.app.TimePickerDialog;
+import android.content.DialogInterface;
+import android.support.v4.app.DialogFragment;
+
+import com.facebook.react.bridge.BaseJavaModule;
+import com.facebook.react.testing.ReactInstanceSpecForTest;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+import com.facebook.react.modules.timepicker.TimePickerDialogModule;
+import com.facebook.react.testing.ReactAppInstrumentationTestCase;
+
+/**
+ * Test case for {@link TimePickerDialogModule} options and callbacks.
+ */
+public class TimePickerDialogTestCase extends ReactAppInstrumentationTestCase {
+
+ private static interface TimePickerDialogTestModule extends JavaScriptModule {
+ public void showTimePickerDialog(WritableMap options);
+ }
+
+ private static class TimePickerDialogRecordingModule extends BaseJavaModule {
+
+ private final List mTimes = new ArrayList();
+ private int mDismissed = 0;
+ private int mErrors = 0;
+
+ @Override
+ public String getName() {
+ return "TimePickerDialogRecordingModule";
+ }
+
+ @ReactMethod
+ public void recordTime(int hour, int minute) {
+ mTimes.add(new Integer[] {hour, minute});
+ }
+
+ @ReactMethod
+ public void recordDismissed() {
+ mDismissed++;
+ }
+
+ @ReactMethod
+ public void recordError() {
+ mErrors++;
+ }
+
+ public List getTimes() {
+ return new ArrayList(mTimes);
+ }
+
+ public int getDismissed() {
+ return mDismissed;
+ }
+
+ public int getErrors() {
+ return mErrors;
+ }
+ }
+
+ final TimePickerDialogRecordingModule mRecordingModule = new TimePickerDialogRecordingModule();
+
+ @Override
+ protected ReactInstanceSpecForTest createReactInstanceSpecForTest() {
+ return super.createReactInstanceSpecForTest()
+ .addNativeModule(mRecordingModule)
+ .addJSModule(TimePickerDialogTestModule.class);
+ }
+
+ @Override
+ protected String getReactApplicationKeyUnderTest() {
+ return "TimePickerDialogTestApp";
+ }
+
+ private TimePickerDialogTestModule getTestModule() {
+ return getReactContext().getCatalystInstance().getJSModule(TimePickerDialogTestModule.class);
+ }
+
+ private DialogFragment showDialog(WritableMap options) {
+ getTestModule().showTimePickerDialog(options);
+
+ waitForBridgeAndUIIdle();
+ getInstrumentation().waitForIdleSync();
+
+ return (DialogFragment) getActivity().getSupportFragmentManager()
+ .findFragmentByTag(TimePickerDialogModule.FRAGMENT_TAG);
+ }
+
+ public void testShowBasicTimePicker() {
+ final DialogFragment fragment = showDialog(null);
+
+ assertNotNull(fragment);
+ }
+
+ public void testPresetTimeAndCallback() throws Throwable {
+ final WritableMap options = new WritableNativeMap();
+ options.putInt("hour", 4);
+ options.putInt("minute", 5);
+
+ final DialogFragment fragment = showDialog(options);
+
+ List recordedTimes = mRecordingModule.getTimes();
+ assertEquals(0, recordedTimes.size());
+
+ runTestOnUiThread(
+ new Runnable() {
+ @Override
+ public void run() {
+ ((TimePickerDialog) fragment.getDialog())
+ .getButton(DialogInterface.BUTTON_POSITIVE).performClick();
+ }
+ });
+
+ getInstrumentation().waitForIdleSync();
+ waitForBridgeAndUIIdle();
+
+ assertEquals(0, mRecordingModule.getErrors());
+ assertEquals(0, mRecordingModule.getDismissed());
+
+ recordedTimes = mRecordingModule.getTimes();
+ assertEquals(1, recordedTimes.size());
+ assertEquals(4, (int) recordedTimes.get(0)[0]);
+ assertEquals(5, (int) recordedTimes.get(0)[1]);
+ }
+
+ public void testDismissCallback() throws Throwable {
+ final DialogFragment fragment = showDialog(null);
+
+ assertEquals(0, mRecordingModule.getDismissed());
+
+ runTestOnUiThread(
+ new Runnable() {
+ @Override
+ public void run() {
+ fragment.getDialog().dismiss();
+ }
+ });
+
+ getInstrumentation().waitForIdleSync();
+ waitForBridgeAndUIIdle();
+
+ assertEquals(0, mRecordingModule.getErrors());
+ assertEquals(0, mRecordingModule.getTimes().size());
+ assertEquals(1, mRecordingModule.getDismissed());
+ }
+
+}
diff --git a/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/ViewRenderingTestCase.java b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/ViewRenderingTestCase.java
new file mode 100644
index 00000000000000..38fff46acd7dc7
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/java/com/facebook/react/tests/ViewRenderingTestCase.java
@@ -0,0 +1,152 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.tests;
+
+import java.util.Arrays;
+import java.util.List;
+
+import android.graphics.Color;
+import android.view.View;
+import android.view.ViewGroup;
+
+import com.facebook.react.ReactRootView;
+import com.facebook.react.bridge.CatalystInstance;
+import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.bridge.UiThreadUtil;
+import com.facebook.react.modules.systeminfo.AndroidInfoModule;
+import com.facebook.react.uimanager.PixelUtil;
+import com.facebook.react.uimanager.UIImplementation;
+import com.facebook.react.uimanager.UIManagerModule;
+import com.facebook.react.uimanager.ViewManager;
+import com.facebook.react.views.view.ReactViewGroup;
+import com.facebook.react.views.view.ReactViewManager;
+import com.facebook.react.testing.FakeWebSocketModule;
+import com.facebook.react.testing.ReactIntegrationTestCase;
+import com.facebook.react.testing.ReactTestHelper;
+
+public class ViewRenderingTestCase extends ReactIntegrationTestCase {
+
+ private interface ViewRenderingTestModule extends JavaScriptModule {
+ void renderViewApplication(int rootTag);
+ void renderMarginApplication(int rootTag);
+ void renderBorderApplication(int rootTag);
+ void updateMargins();
+ void renderTransformApplication(int rootTag);
+ }
+
+ private CatalystInstance mCatalystInstance;
+ private ReactRootView mRootView;
+ private int mRootTag;
+
+ @Override
+ protected void setUp() throws Exception {
+ super.setUp();
+
+ List viewManagers = Arrays.asList(new ReactViewManager());
+ final UIManagerModule uiManager = new UIManagerModule(
+ getContext(),
+ viewManagers,
+ new UIImplementation(getContext(), viewManagers));
+ UiThreadUtil.runOnUiThread(
+ new Runnable() {
+ @Override
+ public void run() {
+ uiManager.onHostResume();
+ }
+ });
+ waitForIdleSync();
+
+ mCatalystInstance = ReactTestHelper.catalystInstanceBuilder(this)
+ .addNativeModule(uiManager)
+ .addNativeModule(new AndroidInfoModule())
+ .addNativeModule(new FakeWebSocketModule())
+ .addJSModule(ViewRenderingTestModule.class)
+ .build();
+
+ mRootView = new ReactRootView(getContext());
+ mRootTag = uiManager.addMeasuredRootView(mRootView);
+ }
+
+ public void testViewRenderedWithCorrectProperties() {
+ float expectedOpacity = 0.75f;
+ int expectedBackgroundColor = Color.rgb(255, 0, 0);
+
+ mCatalystInstance.getJSModule(ViewRenderingTestModule.class).renderViewApplication(mRootTag);
+ waitForBridgeAndUIIdle();
+
+ ReactViewGroup view = getViewAtPath(mRootView);
+ assertEquals("Incorrect (or not applied) opacity", expectedOpacity, view.getAlpha());
+ assertEquals(
+ "Incorrect (or not applied) backgroundColor",
+ expectedBackgroundColor,
+ view.getBackgroundColor());
+ }
+
+ public void testMarginsApplied() {
+ mCatalystInstance.getJSModule(ViewRenderingTestModule.class).renderMarginApplication(mRootTag);
+ waitForBridgeAndUIIdle();
+
+ View view = getViewAtPath(mRootView);
+
+ int expectedMargin = Math.round(PixelUtil.toPixelFromDIP(10));
+ int expectedMarginLeft = Math.round(PixelUtil.toPixelFromDIP(20));
+
+ assertEquals(expectedMarginLeft, (int) view.getX());
+ assertEquals(expectedMargin, (int) view.getY());
+ }
+
+ public void testMarginUpdateDoesntForgetPreviousValue() {
+ mCatalystInstance.getJSModule(ViewRenderingTestModule.class).renderMarginApplication(mRootTag);
+ waitForBridgeAndUIIdle();
+
+ View view = getViewAtPath(mRootView);
+
+ // before: margin: 10, marginLeft: 20
+ mCatalystInstance.getJSModule(ViewRenderingTestModule.class).updateMargins();
+ waitForBridgeAndUIIdle();
+ // after: margin: 15; it should not forget marginLeft was set to 20
+
+ int expectedMargin = Math.round(PixelUtil.toPixelFromDIP(15));
+ int expectedMarginLeft = Math.round(PixelUtil.toPixelFromDIP(20));
+
+ assertEquals(expectedMarginLeft, (int) view.getX());
+ assertEquals(expectedMargin, (int) view.getY());
+ }
+
+ public void testBordersApplied() {
+ mCatalystInstance.getJSModule(ViewRenderingTestModule.class).renderBorderApplication(mRootTag);
+ waitForBridgeAndUIIdle();
+
+ View view = getViewAtPath(mRootView);
+ View child = ((ViewGroup) view).getChildAt(0);
+
+ int expectedBorderX = Math.round(PixelUtil.toPixelFromDIP(20));
+ int expectedBorderY = Math.round(PixelUtil.toPixelFromDIP(5));
+
+ assertEquals(expectedBorderX, (int) child.getX());
+ assertEquals(expectedBorderY, (int) child.getY());
+ }
+
+ public void testTransformations() {
+ mCatalystInstance.getJSModule(ViewRenderingTestModule.class)
+ .renderTransformApplication(mRootTag);
+ waitForBridgeAndUIIdle();
+
+ View view = getViewAtPath(mRootView);
+
+ float expectedTranslateX = PixelUtil.toPixelFromDIP(20);
+ float expectedTranslateY = PixelUtil.toPixelFromDIP(25);
+
+ assertEquals(5f, view.getScaleX());
+ assertEquals(10f, view.getScaleY());
+ assertEquals(15f, view.getRotation());
+ assertEquals(expectedTranslateX, view.getTranslationX());
+ assertEquals(expectedTranslateY, view.getTranslationY());
+ }
+}
diff --git a/android/ReactAndroid/src/androidTest/js/Asserts.js b/android/ReactAndroid/src/androidTest/js/Asserts.js
new file mode 100644
index 00000000000000..9a4e9654ad550c
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/js/Asserts.js
@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule Asserts
+ */
+
+'use strict';
+
+var Assert = require('NativeModules').Assert;
+
+var Asserts = {
+ assertEquals: function(expected, actual, msg) {
+ if (expected !== actual) {
+ Assert.fail(
+ msg ||
+ 'Expected: ' + expected + ', received: ' + actual + '\n' +
+ 'at ' + (new Error()).stack);
+ } else {
+ Assert.success();
+ }
+ },
+ assertTrue: function(expr, msg) {
+ Asserts.assertEquals(true, expr, msg);
+ },
+};
+
+module.exports = Asserts;
diff --git a/android/ReactAndroid/src/androidTest/js/CatalystRootViewTestModule.js b/android/ReactAndroid/src/androidTest/js/CatalystRootViewTestModule.js
new file mode 100644
index 00000000000000..1086567a13d197
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/js/CatalystRootViewTestModule.js
@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule CatalystRootViewTestModule
+ */
+
+'use strict';
+
+var React = require('React');
+var Recording = require('NativeModules').Recording;
+var View = require('View');
+
+var CatalystRootViewTestApp = React.createClass({
+ componentWillUnmount: function() {
+ Recording.record('RootComponentWillUnmount');
+ },
+ render: function() {
+ return ;
+ },
+});
+
+module.exports = {
+ CatalystRootViewTestApp: CatalystRootViewTestApp,
+};
diff --git a/android/ReactAndroid/src/androidTest/js/DatePickerDialogTestModule.js b/android/ReactAndroid/src/androidTest/js/DatePickerDialogTestModule.js
new file mode 100644
index 00000000000000..a15eabd4be89ad
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/js/DatePickerDialogTestModule.js
@@ -0,0 +1,47 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule DatePickerDialogTestModule
+ */
+
+'use strict';
+
+var BatchedBridge = require('BatchedBridge');
+var DatePickerAndroid = require('DatePickerAndroid');
+var React = require('React');
+var RecordingModule = require('NativeModules').DatePickerDialogRecordingModule;
+var View = require('View');
+
+var DatePickerDialogTestApp = React.createClass({
+ render: function() {
+ return ();
+ },
+});
+
+var DatePickerDialogTestModule = {
+ DatePickerDialogTestApp: DatePickerDialogTestApp,
+ showDatePickerDialog: function(options) {
+ DatePickerAndroid.open(options).then(
+ ({action, year, month, day}) => {
+ if (action === DatePickerAndroid.dateSetAction) {
+ RecordingModule.recordDate(year, month, day);
+ } else if (action === DatePickerAndroid.dismissedAction) {
+ RecordingModule.recordDismissed();
+ }
+ },
+ ({code, message}) => RecordingModule.recordError()
+ );
+ },
+};
+
+BatchedBridge.registerCallableModule(
+ 'DatePickerDialogTestModule',
+ DatePickerDialogTestModule
+);
+
+module.exports = DatePickerDialogTestModule;
diff --git a/android/ReactAndroid/src/androidTest/js/InitialPropsTestApp.js b/android/ReactAndroid/src/androidTest/js/InitialPropsTestApp.js
new file mode 100644
index 00000000000000..9b5142c241f971
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/js/InitialPropsTestApp.js
@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule InitialPropsTestApp
+ */
+
+'use strict';
+
+var React = require('React');
+var RecordingModule = require('NativeModules').InitialPropsRecordingModule;
+var Text = require('Text');
+
+var InitialPropsTestApp = React.createClass({
+ componentDidMount: function() {
+ RecordingModule.recordProps(this.props);
+ },
+ render: function() {
+ return dummy;
+ }
+});
+
+module.exports = InitialPropsTestApp;
diff --git a/android/ReactAndroid/src/androidTest/js/JSResponderTestApp.js b/android/ReactAndroid/src/androidTest/js/JSResponderTestApp.js
new file mode 100644
index 00000000000000..314f7f39d9fb63
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/js/JSResponderTestApp.js
@@ -0,0 +1,63 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule JSResponderTestApp
+ */
+'use strict';
+
+var React = require('React');
+var StyleSheet = require('StyleSheet');
+var View = require('View');
+var Text = require('Text');
+var PanResponder = require('PanResponder');
+var ScrollView = require('ScrollView');
+
+var JSResponderTestApp = React.createClass({
+ _handleMoveShouldSetPanResponder: function(e, gestureState) {
+ return Math.abs(gestureState.dx) > 30;
+ },
+ componentWillMount: function() {
+ this.panGesture = PanResponder.create({
+ onMoveShouldSetPanResponder: this._handleMoveShouldSetPanResponder,
+ });
+ },
+ render: function() {
+ var views = [];
+ for (var i = 0; i < 100; i++) {
+ views[i] = (
+
+ I am row {i}
+
+ );
+ }
+ return (
+
+
+ {views}
+
+
+ );
+ },
+});
+
+var styles = StyleSheet.create({
+ container: {
+ flex: 1,
+ },
+ scrollview: {
+ flex: 1,
+ },
+ row: {
+ height: 30,
+ }
+});
+
+module.exports = JSResponderTestApp;
diff --git a/android/ReactAndroid/src/androidTest/js/LayoutEventsTestApp.js b/android/ReactAndroid/src/androidTest/js/LayoutEventsTestApp.js
new file mode 100644
index 00000000000000..d9a0dcfa290d2a
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/js/LayoutEventsTestApp.js
@@ -0,0 +1,35 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule LayoutEventsTestApp
+ */
+
+'use strict';
+
+var React = require('React');
+var View = require('View');
+
+var RecordingModule = require('NativeModules').Recording;
+
+var LayoutEventsTestApp = React.createClass({
+ handleOnLayout: function(e) {
+ var layout = e.nativeEvent.layout;
+ RecordingModule.record(layout.x + ',' + layout.y + '-' + layout.width + 'x' + layout.height);
+ },
+
+ render: function() {
+ return (
+
+ );
+ },
+});
+
+module.exports = LayoutEventsTestApp;
diff --git a/android/ReactAndroid/src/androidTest/js/MeasureLayoutTestModule.js b/android/ReactAndroid/src/androidTest/js/MeasureLayoutTestModule.js
new file mode 100644
index 00000000000000..a768668ad25565
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/js/MeasureLayoutTestModule.js
@@ -0,0 +1,205 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule MeasureLayoutTestModule
+ */
+
+'use strict';
+
+var BatchedBridge = require('BatchedBridge');
+var React = require('React');
+var ReactNative = require('react/lib/ReactNative');
+var View = require('View');
+var StyleSheet = require('StyleSheet');
+var UIManager = require('UIManager');
+
+var assertEquals = require('Asserts').assertEquals;
+
+var styles = StyleSheet.create({
+ A: {
+ "width": 500,
+ "height": 500,
+ },
+ B: {
+ backgroundColor: "rgb(255, 0, 0)",
+ "left": 50,
+ "top": 80,
+ "width": 200,
+ "height": 300,
+ },
+ C: {
+ backgroundColor: "rgb(0, 255, 0)",
+ "left": 100,
+ "top": 70,
+ "width": 50,
+ "height": 150,
+ },
+ D: {
+ backgroundColor: "rgb(0, 0, 255)",
+ "left": 400,
+ "top": 100,
+ "width": 50,
+ "height": 200,
+ },
+});
+
+var A, B, C, D;
+
+var MeasureLayoutTestApp = React.createClass({
+ componentDidMount: function() {
+ A = ReactNative.findNodeHandle(this.refs.A);
+ B = ReactNative.findNodeHandle(this.refs.B);
+ C = ReactNative.findNodeHandle(this.refs.C);
+ D = ReactNative.findNodeHandle(this.refs.D);
+ },
+ render: function() {
+ return (
+
+
+
+
+
+
+ );
+ },
+});
+
+function shouldNotCallThisCallback() {
+ assertEquals(false, true);
+}
+
+var MeasureLayoutTestModule = {
+ MeasureLayoutTestApp: MeasureLayoutTestApp,
+ verifyMeasureOnViewA: function() {
+ UIManager.measure(A, function(a, b, width, height, x, y) {
+ assertEquals(500, width);
+ assertEquals(500, height);
+ assertEquals(0, x);
+ assertEquals(0, y);
+ });
+ },
+ verifyMeasureOnViewC: function() {
+ UIManager.measure(C, function(a, b, width, height, x, y) {
+ assertEquals(50, width);
+ assertEquals(150, height);
+ assertEquals(150, x);
+ assertEquals(150, y);
+ });
+ },
+ verifyMeasureLayoutCRelativeToA: function() {
+ UIManager.measureLayout(
+ C,
+ A,
+ shouldNotCallThisCallback,
+ function (x, y, width, height) {
+ assertEquals(50, width);
+ assertEquals(150, height);
+ assertEquals(150, x);
+ assertEquals(150, y);
+ });
+ },
+ verifyMeasureLayoutCRelativeToB: function() {
+ UIManager.measureLayout(
+ C,
+ B,
+ shouldNotCallThisCallback,
+ function (x, y, width, height) {
+ assertEquals(50, width);
+ assertEquals(150, height);
+ assertEquals(100, x);
+ assertEquals(70, y);
+ });
+ },
+ verifyMeasureLayoutCRelativeToSelf: function() {
+ UIManager.measureLayout(
+ C,
+ C,
+ shouldNotCallThisCallback,
+ function (x, y, width, height) {
+ assertEquals(50, width);
+ assertEquals(150, height);
+ assertEquals(0, x);
+ assertEquals(0, y);
+ });
+ },
+ verifyMeasureLayoutRelativeToParentOnViewA: function() {
+ UIManager.measureLayoutRelativeToParent(
+ A,
+ shouldNotCallThisCallback,
+ function (x, y, width, height) {
+ assertEquals(500, width);
+ assertEquals(500, height);
+ assertEquals(0, x);
+ assertEquals(0, y);
+ });
+ },
+ verifyMeasureLayoutRelativeToParentOnViewB: function() {
+ UIManager.measureLayoutRelativeToParent(
+ B,
+ shouldNotCallThisCallback,
+ function (x, y, width, height) {
+ assertEquals(200, width);
+ assertEquals(300, height);
+ assertEquals(50, x);
+ assertEquals(80, y);
+ });
+ },
+ verifyMeasureLayoutRelativeToParentOnViewC: function() {
+ UIManager.measureLayoutRelativeToParent(
+ C,
+ shouldNotCallThisCallback,
+ function (x, y, width, height) {
+ assertEquals(50, width);
+ assertEquals(150, height);
+ assertEquals(100, x);
+ assertEquals(70, y);
+ });
+ },
+ verifyMeasureLayoutDRelativeToB: function() {
+ UIManager.measureLayout(
+ D,
+ B,
+ function () {
+ assertEquals(true, true);
+ },
+ shouldNotCallThisCallback);
+ },
+ verifyMeasureLayoutNonExistentTag: function() {
+ UIManager.measureLayout(
+ 192,
+ A,
+ function () {
+ assertEquals(true, true);
+ },
+ shouldNotCallThisCallback);
+ },
+ verifyMeasureLayoutNonExistentAncestor: function() {
+ UIManager.measureLayout(
+ B,
+ 192,
+ function () {
+ assertEquals(true, true);
+ },
+ shouldNotCallThisCallback);
+ },
+ verifyMeasureLayoutRelativeToParentNonExistentTag: function() {
+ UIManager.measureLayoutRelativeToParent(
+ 192,
+ function () {
+ assertEquals(true, true);
+ },
+ shouldNotCallThisCallback);
+ },
+};
+
+BatchedBridge.registerCallableModule(
+ 'MeasureLayoutTestModule',
+ MeasureLayoutTestModule
+);
+
+module.exports = MeasureLayoutTestModule;
diff --git a/android/ReactAndroid/src/androidTest/js/MultitouchHandlingTestAppModule.js b/android/ReactAndroid/src/androidTest/js/MultitouchHandlingTestAppModule.js
new file mode 100644
index 00000000000000..7c51afbee37c4c
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/js/MultitouchHandlingTestAppModule.js
@@ -0,0 +1,64 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule MultitouchHandlingTestAppModule
+ */
+
+'use strict';
+
+var React = require('React');
+var Recording = require('NativeModules').Recording;
+var StyleSheet = require('StyleSheet');
+var TouchEventUtils = require('fbjs/lib/TouchEventUtils');
+var View = require('View');
+
+var TouchTestApp = React.createClass({
+ handleStartShouldSetResponder: function(e) {
+ return true;
+ },
+ handleOnResponderMove: function(e) {
+ e = TouchEventUtils.extractSingleTouch(e.nativeEvent);
+ Recording.record('move;' + e.touches.length);
+ },
+ handleResponderStart: function(e) {
+ e = TouchEventUtils.extractSingleTouch(e.nativeEvent);
+ if (e.touches) {
+ Recording.record('start;' + e.touches.length);
+ } else {
+ Recording.record('start;ExtraPointer');
+ }
+ },
+ handleResponderEnd: function(e) {
+ e = TouchEventUtils.extractSingleTouch(e.nativeEvent);
+ if (e.touches) {
+ Recording.record('end;' + e.touches.length);
+ } else {
+ Recording.record('end;ExtraPointer');
+ }
+ },
+ render: function() {
+ return (
+
+ );
+ },
+});
+
+var styles = StyleSheet.create({
+ container: {
+ flex: 1,
+ },
+});
+
+module.exports = TouchTestApp;
diff --git a/android/ReactAndroid/src/androidTest/js/PickerAndroidTestModule.js b/android/ReactAndroid/src/androidTest/js/PickerAndroidTestModule.js
new file mode 100644
index 00000000000000..e354d8fae81493
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/js/PickerAndroidTestModule.js
@@ -0,0 +1,90 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule PickerAndroidTestModule
+ */
+
+'use strict';
+
+var BatchedBridge = require('BatchedBridge');
+var React = require('React');
+var RecordingModule = require('NativeModules').PickerAndroidRecordingModule;
+var Picker = require('Picker');
+var View = require('View');
+
+var Item = Picker.Item;
+
+var appInstance;
+var PickerAndroidTestApp = React.createClass({
+ componentWillMount: function() {
+ appInstance = this;
+ },
+ getInitialState: function() {
+ return {
+ selected: 1,
+ mode: 'dropdown',
+ style: {},
+ };
+ },
+ render: function() {
+ return (
+
+
+ |
);
+ }
+ return (
+ RecordingModule.onRefresh()}
+ />
+ }>
+ {rows}
+
+ );
+ },
+});
+
+var SwipeRefreshLayoutTestModule = {
+ SwipeRefreshLayoutTestApp,
+ setRows: function(rows) {
+ if (app != null) {
+ app.setState({rows});
+ }
+ }
+};
+
+BatchedBridge.registerCallableModule(
+ 'SwipeRefreshLayoutTestModule',
+ SwipeRefreshLayoutTestModule
+);
+
+module.exports = SwipeRefreshLayoutTestModule;
diff --git a/android/ReactAndroid/src/androidTest/js/TestBundle.js b/android/ReactAndroid/src/androidTest/js/TestBundle.js
new file mode 100644
index 00000000000000..960c485a371f6c
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/js/TestBundle.js
@@ -0,0 +1,106 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ */
+'use strict';
+
+// Disable YellowBox so we do not have to mock its dependencies
+console.disableYellowBox = true;
+
+// Include callable JS modules first, in case one of the other ones below throws
+require('ProgressBarTestModule');
+require('ViewRenderingTestModule');
+require('TestJavaToJSArgumentsModule');
+require('TestJSLocaleModule');
+require('TestJSToJavaParametersModule');
+require('UIManagerTestModule');
+
+require('CatalystRootViewTestModule');
+require('DatePickerDialogTestModule');
+require('MeasureLayoutTestModule');
+require('PickerAndroidTestModule');
+require('ScrollViewTestModule');
+require('SwipeRefreshLayoutTestModule');
+require('TextInputTestModule');
+require('TimePickerDialogTestModule');
+
+
+// Define catalyst test apps used in integration tests
+var AppRegistry = require('AppRegistry');
+
+var apps = [
+{
+ appKey: 'CatalystRootViewTestApp',
+ component: () => require('CatalystRootViewTestModule').CatalystRootViewTestApp
+},
+{
+ appKey: 'DatePickerDialogTestApp',
+ component: () => require('DatePickerDialogTestModule').DatePickerDialogTestApp
+},
+{
+ appKey: 'JSResponderTestApp',
+ component: () => require('JSResponderTestApp'),
+},
+{
+ appKey: 'HorizontalScrollViewTestApp',
+ component: () => require('ScrollViewTestModule').HorizontalScrollViewTestApp,
+},
+{
+ appKey: 'InitialPropsTestApp',
+ component: () => require('InitialPropsTestApp'),
+},
+{
+ appKey: 'LayoutEventsTestApp',
+ component: () => require('LayoutEventsTestApp'),
+},
+{
+ appKey: 'MeasureLayoutTestApp',
+ component: () => require('MeasureLayoutTestModule').MeasureLayoutTestApp
+},
+{
+ appKey: 'MultitouchHandlingTestAppModule',
+ component: () => require('MultitouchHandlingTestAppModule')
+},
+{
+ appKey: 'PickerAndroidTestApp',
+ component: () => require('PickerAndroidTestModule').PickerAndroidTestApp,
+},
+{
+ appKey: 'ScrollViewTestApp',
+ component: () => require('ScrollViewTestModule').ScrollViewTestApp,
+},
+{
+ appKey: 'SubviewsClippingTestApp',
+ component: () => require('SubviewsClippingTestModule').App,
+},
+{
+ appKey: 'SwipeRefreshLayoutTestApp',
+ component: () => require('SwipeRefreshLayoutTestModule').SwipeRefreshLayoutTestApp
+},
+{
+ appKey: 'TextInputTestApp',
+ component: () => require('TextInputTestModule').TextInputTestApp
+},
+{
+ appKey: 'TestIdTestApp',
+ component: () => require('TestIdTestModule').TestIdTestApp
+},
+{
+ appKey: 'TimePickerDialogTestApp',
+ component: () => require('TimePickerDialogTestModule').TimePickerDialogTestApp
+},
+{
+ appKey: 'TouchBubblingTestAppModule',
+ component: () => require('TouchBubblingTestAppModule')
+},
+
+];
+
+
+module.exports = apps;
+AppRegistry.registerConfig(apps);
diff --git a/android/ReactAndroid/src/androidTest/js/TestIdTestModule.js b/android/ReactAndroid/src/androidTest/js/TestIdTestModule.js
new file mode 100644
index 00000000000000..6f11c1574fab20
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/js/TestIdTestModule.js
@@ -0,0 +1,139 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule TestIdTestModule
+ */
+
+'use strict';
+
+var Image = require('Image');
+var ProgressBarAndroid = require('ProgressBarAndroid');
+var React = require('React');
+var ScrollView = require('ScrollView');
+var Picker = require('Picker');
+var StyleSheet = require('StyleSheet');
+var SwitchAndroid = require('SwitchAndroid');
+var Text = require('Text');
+var TextInput = require('TextInput');
+var ToolbarAndroid = require('ToolbarAndroid');
+var TouchableBounce = require('TouchableBounce');
+var TouchableHighlight = require('TouchableHighlight');
+var TouchableOpacity = require('TouchableOpacity');
+var TouchableWithoutFeedback = require('TouchableWithoutFeedback');
+var View = require('View');
+var WebView = require('WebView');
+
+/**
+ * All the views implemented on Android, each with the testID property set.
+ * We test that:
+ * - The app renders fine
+ * - The testID property is passed to the native views
+ */
+var TestIdTestApp = React.createClass({
+ render: function() {
+ return (
+
+
+
+
+
+
+
+ Item 1
+ Item 2
+
+
+
+ Item 1
+ Item 2
+
+
+
+
+
+
+
+
+
+
+
+
+ text
+
+
+
+
+
+
+ TouchableBounce
+
+
+
+ TouchableHighlight
+
+
+
+ TouchableOpacity
+
+
+
+
+ TouchableWithoutFeedback
+
+
+
+
+
+ {/*
+ Webview gets tests crashing or stalling occasionally
+ e.g. https://circleci.com/gh/facebook/react-native/7054
+ TODO t11449130
+ }
+ style={styles.base}
+ />*/}
+
+
+ );
+ },
+});
+
+var styles = StyleSheet.create({
+ base: {
+ width: 150,
+ height: 50,
+ },
+});
+
+module.exports = {
+ TestIdTestApp: TestIdTestApp,
+};
diff --git a/android/ReactAndroid/src/androidTest/js/TestJSLocaleModule.js b/android/ReactAndroid/src/androidTest/js/TestJSLocaleModule.js
new file mode 100644
index 00000000000000..eff35902c901ad
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/js/TestJSLocaleModule.js
@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule TestJSLocaleModule
+ */
+
+'use strict';
+
+var BatchedBridge = require('BatchedBridge');
+var Recording = require('NativeModules').Recording;
+
+var TestJSLocaleModule = {
+ toUpper: function(s) {
+ Recording.record(s.toUpperCase());
+ },
+ toLower: function(s) {
+ Recording.record(s.toLowerCase());
+ },
+};
+
+BatchedBridge.registerCallableModule(
+ 'TestJSLocaleModule',
+ TestJSLocaleModule
+);
+
+module.exports = TestJSLocaleModule;
diff --git a/android/ReactAndroid/src/androidTest/js/TestJSToJavaParametersModule.js b/android/ReactAndroid/src/androidTest/js/TestJSToJavaParametersModule.js
new file mode 100644
index 00000000000000..57380f3bcba5d7
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/js/TestJSToJavaParametersModule.js
@@ -0,0 +1,117 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule TestJSToJavaParametersModule
+ */
+
+'use strict';
+
+var BatchedBridge = require('BatchedBridge');
+var Recording = require('NativeModules').Recording;
+
+var TestJSToJavaParametersModule = {
+ returnBasicTypes: function() {
+ Recording.receiveBasicTypes('foo', 3.14, true, null);
+ },
+ returnArrayWithBasicTypes: function() {
+ Recording.receiveArray(['foo', 3.14, -111, true, null]);
+ },
+ returnNestedArray: function() {
+ Recording.receiveArray(['we', ['have', ['to', ['go', ['deeper']]]]]);
+ },
+ returnArrayWithMaps: function() {
+ Recording.receiveArray([{m1k1: 'm1v1', m1k2: 'm1v2'}, {m2k1: 'm2v1'}]);
+ },
+ returnMapWithBasicTypes: function() {
+ Recording.receiveMap({
+ stringKey: 'stringValue',
+ doubleKey: 3.14,
+ intKey: -11,
+ booleanKey: true,
+ nullKey: null,
+ });
+ },
+ returnNestedMap: function() {
+ Recording.receiveMap({
+ weHaveToGoDeeper: {
+ inception: true,
+ },
+ });
+ },
+ returnMapWithArrays: function() {
+ Recording.receiveMap({
+ 'empty': [],
+ 'ints': [43, 44],
+ 'mixed': [77, 'string', ['another', 'array']],
+ });
+ },
+ returnArrayWithStringDoubleIntMapArrayBooleanNull: function() {
+ Recording.receiveArray(['string', 3.14, 555, {}, [], true, null]);
+ },
+ returnMapWithStringDoubleIntMapArrayBooleanNull: function() {
+ Recording.receiveMap({
+ string: 'string',
+ double: 3,
+ map: {},
+ int: -55,
+ array: [],
+ boolean: true,
+ null: null
+ });
+ },
+ returnArrayWithLargeInts: function() {
+ Recording.receiveArray([2147483648, -5555555555]);
+ },
+ returnMapWithLargeInts: function() {
+ Recording.receiveMap({first: -2147483649, second: 5551231231});
+ },
+ returnMapForMerge1: function() {
+ Recording.receiveMap({
+ a: 1,
+ b: 41,
+ c: 'string',
+ d: 'other string',
+ e: [1,'foo','bar'],
+ f: null,
+ });
+ },
+ returnMapForMerge2: function() {
+ Recording.receiveMap({
+ a: 'overwrite',
+ d: 77,
+ e: null,
+ f: ['array', 'with', 'stuff'],
+ newkey: 'newvalue',
+ });
+ },
+ returnMapWithMultibyteUTF8CharacterString: function() {
+ Recording.receiveMap({
+ 'one-byte': 'a',
+ 'two-bytes': '\u00A2',
+ 'three-bytes': '\u20AC',
+ 'four-bytes': '\uD83D\uDE1C',
+ 'mixed': '\u017C\u00F3\u0142\u0107 g\u0119\u015Bl\u0105 \u6211 \uD83D\uDE0E ja\u017A\u0107'
+ });
+ },
+ returnArrayWithMultibyteUTF8CharacterString: function() {
+ Recording.receiveArray([
+ 'a',
+ '\u00A2',
+ '\u20AC',
+ '\uD83D\uDE1C',
+ '\u017C\u00F3\u0142\u0107 g\u0119\u015Bl\u0105 \u6211 \uD83D\uDE0E ja\u017A\u0107'
+ ]);
+ },
+};
+
+BatchedBridge.registerCallableModule(
+ 'TestJSToJavaParametersModule',
+ TestJSToJavaParametersModule
+);
+
+module.exports = TestJSToJavaParametersModule;
diff --git a/android/ReactAndroid/src/androidTest/js/TestJavaToJSArgumentsModule.js b/android/ReactAndroid/src/androidTest/js/TestJavaToJSArgumentsModule.js
new file mode 100644
index 00000000000000..4073d4d6a3fd09
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/js/TestJavaToJSArgumentsModule.js
@@ -0,0 +1,116 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule TestJavaToJSArgumentsModule
+ */
+
+'use strict';
+
+var BatchedBridge = require('BatchedBridge');
+var {assertEquals, assertTrue} = require('Asserts');
+
+function strictStringCompare(a, b) {
+ if (typeof a !== 'string' || typeof b !== 'string' || a.length !== b.length) {
+ return false;
+ }
+ for (var i = 0; i < a.length; i++) {
+ if (a.charCodeAt(i) !== b.charCodeAt(i)) {
+ return false;
+ }
+ }
+ return true;
+}
+
+function assertStrictStringEquals(a, b) {
+ assertTrue(
+ strictStringCompare(a,b),
+ 'Expected: ' + a + ', received: ' + b);
+}
+
+var TestJavaToJSArgumentsModule = {
+ receiveBasicTypes: function(str, dbl, bool, null_arg) {
+ assertEquals("foo", str);
+ assertEquals(3.14, dbl);
+ assertEquals(true, bool);
+ assertEquals(null, null_arg);
+ },
+ receiveArrayWithBasicTypes: function(arr) {
+ assertEquals(4, arr.length);
+ assertEquals("red panda", arr[0]);
+ assertEquals(1.19, arr[1]);
+ assertEquals(true, arr[2]);
+ assertEquals(null, arr[3]);
+ },
+ receiveNestedArray: function(arr) {
+ assertEquals(2, arr.length);
+ assertEquals("level1", arr[0]);
+ var arr2 = arr[1];
+ assertEquals("level2", arr2[0]);
+ var arr3 = arr2[1];
+ assertEquals("level3", arr3[0]);
+ },
+ receiveArrayWithMaps: function(arr) {
+ assertEquals(2, arr.length);
+ var m1 = arr[0];
+ var m2 = arr[1];
+ assertEquals("m1v1", m1["m1k1"]);
+ assertEquals("m1v2", m1["m1k2"]);
+ assertEquals("m2v1", m2["m2k1"]);
+ },
+ receiveMapWithBasicTypes: function(map) {
+ assertEquals("stringValue", map["stringKey"]);
+ assertEquals(3.14, map["doubleKey"]);
+ assertEquals(true, map["booleanKey"]);
+ assertEquals(null, map["nullKey"]);
+ },
+ receiveNestedMap: function(map) {
+ var nestedMap = map["nestedMap"];
+ assertEquals("foxes", nestedMap["animals"]);
+ },
+ receiveMapWithArrays: function(map) {
+ var a1 = map["array1"];
+ var a2 = map["array2"];
+ assertEquals(3, a1.length);
+ assertEquals(2, a2.length);
+ assertEquals(3, a1[0]);
+ assertEquals(9, a2[1]);
+ },
+ receiveMapAndArrayWithNullValues: function(map, array) {
+ assertEquals(null, map.string);
+ assertEquals(null, map.array);
+ assertEquals(null, map.map);
+
+ assertEquals(null, array[0]);
+ assertEquals(null, array[1]);
+ assertEquals(null, array[2]);
+ },
+ receiveMapWithMultibyteUTF8CharacterString: function(map) {
+ assertStrictStringEquals('\u00A2', map['two-bytes']);
+ assertStrictStringEquals('\u20AC', map['three-bytes']);
+ assertStrictStringEquals('\uD83D\uDE1C', map['four-bytes']);
+ assertStrictStringEquals(
+ '\u017C\u00F3\u0142\u0107 g\u0119\u015Bl\u0105 \u6211 \uD83D\uDE0E ja\u017A\u0107',
+ map.mixed);
+ },
+ receiveArrayWithMultibyteUTF8CharacterString: function(array) {
+ assertTrue(true);
+ assertStrictStringEquals('\u00A2', array[0]);
+ assertStrictStringEquals('\u20AC', array[1]);
+ assertStrictStringEquals('\uD83D\uDE1C', array[2]);
+ assertStrictStringEquals(
+ '\u017C\u00F3\u0142\u0107 g\u0119\u015Bl\u0105 \u6211 \uD83D\uDE0E ja\u017A\u0107',
+ array[3]);
+ },
+};
+
+BatchedBridge.registerCallableModule(
+ 'TestJavaToJSArgumentsModule',
+ TestJavaToJSArgumentsModule
+);
+
+module.exports = TestJavaToJSArgumentsModule;
diff --git a/android/ReactAndroid/src/androidTest/js/TextInputTestModule.js b/android/ReactAndroid/src/androidTest/js/TextInputTestModule.js
new file mode 100644
index 00000000000000..9ce28448674f45
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/js/TextInputTestModule.js
@@ -0,0 +1,170 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule TextInputTestModule
+ */
+
+"use strict";
+
+var BatchedBridge = require('BatchedBridge');
+var React = require('React');
+var StyleSheet = require('StyleSheet');
+var Text = require('Text');
+var TextInput = require('TextInput');
+var View = require('View');
+
+var app;
+
+class TokenizedTextExample extends React.Component {
+ constructor(props) {
+ super(props);
+ this.state = {text: ''};
+ }
+ render() {
+
+ //define delimiter
+ let delimiter = /\s+/;
+
+ //split string
+ let _text = this.state.text;
+ let token, index, parts = [];
+ while (_text) {
+ delimiter.lastIndex = 0;
+ token = delimiter.exec(_text);
+ if (token === null) {
+ break;
+ }
+ index = token.index;
+ if (token[0].length === 0) {
+ index = 1;
+ }
+ parts.push(_text.substr(0, index));
+ parts.push(token[0]);
+ index = index + token[0].length;
+ _text = _text.slice(index);
+ }
+ parts.push(_text);
+
+ //highlight hashtags
+ parts = parts.map((text) => {
+ if (/^#/.test(text)) {
+ return {text};
+ } else {
+ return text;
+ }
+ });
+
+ return (
+
+ {
+ this.setState({text});
+ }}>
+ {parts}
+
+
+ );
+ }
+}
+
+var TextInputTestApp = React.createClass({
+ componentDidMount: function() {
+ app = this;
+ },
+
+ render: function() {
+ return (
+
+
+
+
+
+
+
+
+
+ );
+ },
+});
+
+var styles = StyleSheet.create({
+ container: {
+ padding: 5,
+ margin: 10,
+ },
+ textInputHeight: {
+ fontSize: 21,
+ height: 30,
+ },
+ textInput: {
+ fontSize: 21,
+ padding: 0,
+ },
+ hashtag: {
+ color: 'blue',
+ fontWeight: 'bold',
+ },
+});
+
+var TextInputTestModule = {
+ TextInputTestApp,
+ setValueRef: function(ref, value) {
+ app.refs[ref].setNativeProps({
+ text: value,
+ });
+ },
+};
+
+BatchedBridge.registerCallableModule(
+ 'TextInputTestModule',
+ TextInputTestModule
+);
+
+module.exports = TextInputTestModule;
diff --git a/android/ReactAndroid/src/androidTest/js/TimePickerDialogTestModule.js b/android/ReactAndroid/src/androidTest/js/TimePickerDialogTestModule.js
new file mode 100644
index 00000000000000..4f1f16672798f2
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/js/TimePickerDialogTestModule.js
@@ -0,0 +1,47 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule TimePickerDialogTestModule
+ */
+
+'use strict';
+
+var BatchedBridge = require('BatchedBridge');
+var TimePickerAndroid = require('TimePickerAndroid');
+var React = require('React');
+var RecordingModule = require('NativeModules').TimePickerDialogRecordingModule;
+var View = require('View');
+
+var TimePickerDialogTestApp = React.createClass({
+ render: function() {
+ return ;
+ },
+});
+
+var TimePickerDialogTestModule = {
+ TimePickerDialogTestApp: TimePickerDialogTestApp,
+ showTimePickerDialog: function(options) {
+ TimePickerAndroid.open(options).then(
+ ({action, hour, minute}) => {
+ if (action === TimePickerAndroid.timeSetAction) {
+ RecordingModule.recordTime(hour, minute);
+ } else if (action === TimePickerAndroid.dismissedAction) {
+ RecordingModule.recordDismissed();
+ }
+ },
+ ({code, message}) => RecordingModule.recordError()
+ );
+ },
+};
+
+BatchedBridge.registerCallableModule(
+ 'TimePickerDialogTestModule',
+ TimePickerDialogTestModule
+);
+
+module.exports = TimePickerDialogTestModule;
diff --git a/android/ReactAndroid/src/androidTest/js/TouchBubblingTestAppModule.js b/android/ReactAndroid/src/androidTest/js/TouchBubblingTestAppModule.js
new file mode 100644
index 00000000000000..e792d2d73b8214
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/js/TouchBubblingTestAppModule.js
@@ -0,0 +1,76 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule TouchBubblingTestAppModule
+ */
+
+'use strict';
+
+var Recording = require('NativeModules').Recording;
+
+var React = require('React');
+var StyleSheet = require('StyleSheet');
+var View = require('View');
+var TouchableWithoutFeedback = require('TouchableWithoutFeedback');
+
+var TouchBubblingTestApp = React.createClass({
+ handlePress: function(record) {
+ Recording.record(record);
+ },
+ render: function() {
+ return (
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ );
+ },
+});
+
+var styles = StyleSheet.create({
+ container: {
+ flexDirection: 'column',
+ backgroundColor: '#ccdd44',
+ },
+ element: {
+ backgroundColor: '#ff0000',
+ height: 100,
+ margin: 30,
+ },
+ outer: {
+ backgroundColor: '#00ff00',
+ height: 100,
+ margin: 30,
+ flexDirection: 'row',
+ justifyContent: 'space-between',
+ },
+ inner: {
+ backgroundColor: '#0000ff',
+ height: 50,
+ width: 50,
+ margin: 10,
+ },
+ superinner: {
+ backgroundColor: '#eeeeee',
+ height: 20,
+ width: 20,
+ }
+});
+
+module.exports = TouchBubblingTestApp;
diff --git a/android/ReactAndroid/src/androidTest/js/UIManagerTestModule.js b/android/ReactAndroid/src/androidTest/js/UIManagerTestModule.js
new file mode 100644
index 00000000000000..f8896a12c76bb7
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/js/UIManagerTestModule.js
@@ -0,0 +1,202 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule UIManagerTestModule
+ */
+
+'use strict';
+
+var BatchedBridge = require('BatchedBridge');
+var React = require('React');
+var StyleSheet = require('StyleSheet');
+var View = require('View');
+var Text = require('Text');
+
+var renderApplication = require('renderApplication');
+
+var FlexTestApp = React.createClass({
+ _styles: StyleSheet.create({
+ container: {
+ width: 200,
+ height: 200,
+ flexDirection: 'row',
+ },
+ child: {
+ flex: 1,
+ },
+ absolute: {
+ position: 'absolute',
+ top: 15,
+ left: 10,
+ width: 50,
+ height: 60,
+ }
+ }),
+ render: function() {
+ return (
+
+
+
+
+ );
+ }
+});
+
+var FlexWithText = React.createClass({
+ _styles: StyleSheet.create({
+ container: {
+ flexDirection: 'column',
+ margin: 20,
+ },
+ row: {
+ flexDirection: 'row',
+ alignItems: 'flex-end',
+ height: 300,
+ },
+ inner: {
+ flex: 1,
+ margin: 10,
+ },
+ }),
+ render: function() {
+ return (
+
+
+ Hello
+ World
+
+
+ );
+ }
+});
+
+var AbsolutePositionTestApp = React.createClass({
+ _styles: StyleSheet.create({
+ absolute: {
+ position: 'absolute',
+ top: 15,
+ left: 10,
+ width: 50,
+ height: 60,
+ }
+ }),
+ render: function() {
+ return ;
+ }
+});
+
+var AbsolutePositionBottomRightTestApp = React.createClass({
+ _styles: StyleSheet.create({
+ container: {
+ width: 100,
+ height: 100,
+ },
+ absolute: {
+ position: 'absolute',
+ bottom: 15,
+ right: 10,
+ width: 50,
+ height: 60,
+ }
+ }),
+ render: function() {
+ return (
+
+
+
+ );
+ }
+});
+
+var CenteredTextView = React.createClass({
+ _styles: StyleSheet.create({
+ parent: {
+ width: 200,
+ height: 100,
+ backgroundColor: '#aa3311',
+ flex: 1,
+ justifyContent: 'center',
+ alignItems: 'center',
+ },
+ text: {
+ fontSize: 15,
+ color: '#672831',
+ },
+ }),
+ render: function() {
+ return (
+
+
+ {this.props.text}
+
+
+ );
+ }
+});
+
+var flushUpdatePositionInList = null;
+var UpdatePositionInListTestApp = React.createClass({
+ _styles: StyleSheet.create({
+ element: {
+ height: 10,
+ },
+ active: {
+ height: 50,
+ }
+ }),
+ getInitialState: function() {
+ flushUpdatePositionInList = () => this.setState({ active: true });
+ return { active: false };
+ },
+ render: function() {
+ return (
+
+
+
+
+
+ );
+ }
+});
+
+var UIManagerTestModule = {
+ renderFlexTestApplication: function(rootTag) {
+ renderApplication(FlexTestApp, {}, rootTag);
+ },
+ renderFlexWithTextApplication: function(rootTag) {
+ renderApplication(FlexWithText, {}, rootTag);
+ },
+ renderAbsolutePositionBottomRightTestApplication: function(rootTag) {
+ renderApplication(AbsolutePositionBottomRightTestApp, {}, rootTag);
+ },
+ renderAbsolutePositionTestApplication: function(rootTag) {
+ renderApplication(AbsolutePositionTestApp, {}, rootTag);
+ },
+ renderCenteredTextViewTestApplication: function(rootTag, text) {
+ renderApplication(CenteredTextView, {text: text}, rootTag);
+ },
+ renderUpdatePositionInListTestApplication: function(rootTag) {
+ renderApplication(UpdatePositionInListTestApp, {}, rootTag);
+ },
+ flushUpdatePositionInList: function() {
+ flushUpdatePositionInList();
+ }
+};
+
+BatchedBridge.registerCallableModule(
+ 'UIManagerTestModule',
+ UIManagerTestModule
+);
+
+module.exports = UIManagerTestModule;
diff --git a/android/ReactAndroid/src/androidTest/js/ViewRenderingTestModule.js b/android/ReactAndroid/src/androidTest/js/ViewRenderingTestModule.js
new file mode 100644
index 00000000000000..03c093df7a9455
--- /dev/null
+++ b/android/ReactAndroid/src/androidTest/js/ViewRenderingTestModule.js
@@ -0,0 +1,102 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule ViewRenderingTestModule
+ */
+
+"use strict";
+
+var BatchedBridge = require('BatchedBridge');
+var React = require('React');
+var View = require('View');
+var StyleSheet = require('StyleSheet');
+
+var renderApplication = require('renderApplication');
+
+var styles = StyleSheet.create({
+ view: {
+ opacity: 0.75,
+ backgroundColor: "rgb(255, 0, 0)",
+ },
+});
+
+var ViewSampleApp = React.createClass({
+ render: function() {
+ return (
+
+ );
+ },
+ getInitialState: function() {
+ return {};
+ },
+});
+
+var updateMargins;
+var MarginSampleApp = React.createClass({
+ getInitialState: function() {
+ return {margin: 10};
+ },
+ render: function() {
+ updateMargins = this.setState.bind(this, {margin: 15});
+ return (
+
+ )
+ },
+});
+
+var BorderSampleApp = React.createClass({
+ render: function() {
+ return (
+
+
+
+ );
+ }
+});
+
+var TransformSampleApp = React.createClass({
+ render: function() {
+ var style = {
+ transform: [
+ {translateX: 20},
+ {translateY: 25},
+ {rotate: '15deg'},
+ {scaleX: 5},
+ {scaleY: 10},
+ ]
+ };
+ return (
+
+ );
+ }
+});
+
+var ViewRenderingTestModule = {
+ renderViewApplication: function(rootTag) {
+ renderApplication(ViewSampleApp, {}, rootTag);
+ },
+ renderMarginApplication: function(rootTag) {
+ renderApplication(MarginSampleApp, {}, rootTag);
+ },
+ renderBorderApplication: function(rootTag) {
+ renderApplication(BorderSampleApp, {}, rootTag);
+ },
+ renderTransformApplication: function(rootTag) {
+ renderApplication(TransformSampleApp, {}, rootTag);
+ },
+ updateMargins: function() {
+ updateMargins();
+ },
+};
+
+BatchedBridge.registerCallableModule(
+ 'ViewRenderingTestModule',
+ ViewRenderingTestModule
+);
+
+module.exports = ViewRenderingTestModule;
diff --git a/android/ReactAndroid/src/main/AndroidManifest.xml b/android/ReactAndroid/src/main/AndroidManifest.xml
new file mode 100644
index 00000000000000..900169cc7c5012
--- /dev/null
+++ b/android/ReactAndroid/src/main/AndroidManifest.xml
@@ -0,0 +1,7 @@
+
+
+
+
+
+
+
diff --git a/android/ReactAndroid/src/main/android_res/android/support/v7/appcompat-orig/BUCK b/android/ReactAndroid/src/main/android_res/android/support/v7/appcompat-orig/BUCK
new file mode 100644
index 00000000000000..8dd771536fa144
--- /dev/null
+++ b/android/ReactAndroid/src/main/android_res/android/support/v7/appcompat-orig/BUCK
@@ -0,0 +1,10 @@
+include_defs('//ReactAndroid/DEFS')
+
+# used by ReactToolbarManager because of Gradle
+# TODO t10182713 will be replaced with res-for-appcompat when we stop using Gradle
+android_resource(
+ name = 'res-for-react-native',
+ res = react_native_dep('third-party/android/support/v7/appcompat-orig:res-unpacker-cmd'),
+ package = 'com.facebook.react',
+ visibility = ['//ReactAndroid/...',],
+)
diff --git a/android/ReactAndroid/src/main/java/com/facebook/csslayout/BUCK b/android/ReactAndroid/src/main/java/com/facebook/csslayout/BUCK
new file mode 100644
index 00000000000000..da7888de929826
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/csslayout/BUCK
@@ -0,0 +1,15 @@
+include_defs('//ReactAndroid/DEFS')
+
+android_library(
+ name = 'csslayout',
+ srcs = glob(['**/*.java']),
+ deps = [
+ react_native_dep('third-party/java/infer-annotations:infer-annotations'),
+ react_native_dep('third-party/java/jsr-305:jsr-305'),
+ ],
+ visibility = ['PUBLIC'],
+)
+
+project_config(
+ src_target = ':csslayout',
+)
diff --git a/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSAlign.java b/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSAlign.java
new file mode 100644
index 00000000000000..3e3cb0e9893557
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSAlign.java
@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.csslayout;
+
+public enum CSSAlign {
+ AUTO,
+ FLEX_START,
+ CENTER,
+ FLEX_END,
+ STRETCH,
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSCachedMeasurement.java b/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSCachedMeasurement.java
new file mode 100644
index 00000000000000..deb1de6a5e62c6
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSCachedMeasurement.java
@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.csslayout;
+
+public class CSSCachedMeasurement {
+ public float availableWidth;
+ public float availableHeight;
+ public CSSMeasureMode widthMeasureMode = null;
+ public CSSMeasureMode heightMeasureMode = null;
+
+ public float computedWidth;
+ public float computedHeight;
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSConstants.java b/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSConstants.java
new file mode 100644
index 00000000000000..01a0d597d0debb
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSConstants.java
@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.csslayout;
+
+public class CSSConstants {
+
+ public static final float UNDEFINED = Float.NaN;
+
+ public static boolean isUndefined(float value) {
+ return Float.compare(value, UNDEFINED) == 0;
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSDirection.java b/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSDirection.java
new file mode 100644
index 00000000000000..0c27a929537ce0
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSDirection.java
@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.csslayout;
+
+public enum CSSDirection {
+ INHERIT,
+ LTR,
+ RTL,
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSFlexDirection.java b/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSFlexDirection.java
new file mode 100644
index 00000000000000..30f92bd04c861b
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSFlexDirection.java
@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.csslayout;
+
+public enum CSSFlexDirection {
+ COLUMN,
+ COLUMN_REVERSE,
+ ROW,
+ ROW_REVERSE
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSJustify.java b/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSJustify.java
new file mode 100644
index 00000000000000..dfcc1cd2ede323
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSJustify.java
@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.csslayout;
+
+public enum CSSJustify {
+ FLEX_START,
+ CENTER,
+ FLEX_END,
+ SPACE_BETWEEN,
+ SPACE_AROUND,
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSLayout.java b/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSLayout.java
new file mode 100644
index 00000000000000..ed2b8249490316
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSLayout.java
@@ -0,0 +1,77 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.csslayout;
+
+import java.util.Arrays;
+
+/**
+ * Where the output of {@link LayoutEngine#layoutNode(CSSNode, float)} will go in the CSSNode.
+ */
+public class CSSLayout {
+ // This value was chosen based on empiracle data. Even the most complicated
+ // layouts should not require more than 16 entries to fit within the cache.
+ public static final int MAX_CACHED_RESULT_COUNT = 16;
+
+ public static final int POSITION_LEFT = 0;
+ public static final int POSITION_TOP = 1;
+ public static final int POSITION_RIGHT = 2;
+ public static final int POSITION_BOTTOM = 3;
+
+ public static final int DIMENSION_WIDTH = 0;
+ public static final int DIMENSION_HEIGHT = 1;
+
+ public float[] position = new float[4];
+ public float[] dimensions = new float[2];
+ public CSSDirection direction = CSSDirection.LTR;
+
+ public float flexBasis;
+
+ public int generationCount;
+ public CSSDirection lastParentDirection;
+
+ public int nextCachedMeasurementsIndex;
+ public CSSCachedMeasurement[] cachedMeasurements = new CSSCachedMeasurement[MAX_CACHED_RESULT_COUNT];
+ public float[] measuredDimensions = new float[2];
+
+ public CSSCachedMeasurement cachedLayout = new CSSCachedMeasurement();
+
+ CSSLayout() {
+ resetResult();
+ }
+
+ public void resetResult() {
+ Arrays.fill(position, 0);
+ Arrays.fill(dimensions, CSSConstants.UNDEFINED);
+ direction = CSSDirection.LTR;
+
+ flexBasis = 0;
+
+ generationCount = 0;
+ lastParentDirection = null;
+
+ nextCachedMeasurementsIndex = 0;
+ measuredDimensions[DIMENSION_WIDTH] = CSSConstants.UNDEFINED;
+ measuredDimensions[DIMENSION_HEIGHT] = CSSConstants.UNDEFINED;
+
+ cachedLayout.widthMeasureMode = null;
+ cachedLayout.heightMeasureMode = null;
+ }
+
+ @Override
+ public String toString() {
+ return "layout: {" +
+ "left: " + position[POSITION_LEFT] + ", " +
+ "top: " + position[POSITION_TOP] + ", " +
+ "width: " + dimensions[DIMENSION_WIDTH] + ", " +
+ "height: " + dimensions[DIMENSION_HEIGHT] + ", " +
+ "direction: " + direction +
+ "}";
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSLayoutContext.java b/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSLayoutContext.java
new file mode 100644
index 00000000000000..70a9c8869ef7e3
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSLayoutContext.java
@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.csslayout;
+
+/**
+ * A context for holding values local to a given instance of layout computation.
+ *
+ * This is necessary for making layout thread-safe. A separate instance should
+ * be used when {@link CSSNode#calculateLayout} is called concurrently on
+ * different node hierarchies.
+ */
+public class CSSLayoutContext {
+ /*package*/ final MeasureOutput measureOutput = new MeasureOutput();
+ int currentGenerationCount;
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSMeasureMode.java b/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSMeasureMode.java
new file mode 100644
index 00000000000000..e8ebb34f078f48
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSMeasureMode.java
@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.csslayout;
+
+public enum CSSMeasureMode {
+ UNDEFINED,
+ EXACTLY,
+ AT_MOST,
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSNode.java b/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSNode.java
new file mode 100644
index 00000000000000..6bb7cf663a59a5
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSNode.java
@@ -0,0 +1,573 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.csslayout;
+
+import javax.annotation.Nullable;
+
+import java.util.ArrayList;
+
+import com.facebook.infer.annotation.Assertions;
+
+import static com.facebook.csslayout.CSSLayout.DIMENSION_HEIGHT;
+import static com.facebook.csslayout.CSSLayout.DIMENSION_WIDTH;
+import static com.facebook.csslayout.CSSLayout.POSITION_BOTTOM;
+import static com.facebook.csslayout.CSSLayout.POSITION_LEFT;
+import static com.facebook.csslayout.CSSLayout.POSITION_RIGHT;
+import static com.facebook.csslayout.CSSLayout.POSITION_TOP;
+
+/**
+ * A CSS Node. It has a style object you can manipulate at {@link #style}. After calling
+ * {@link #calculateLayout()}, {@link #layout} will be filled with the results of the layout.
+ */
+public class CSSNode {
+
+ private static enum LayoutState {
+ /**
+ * Some property of this node or its children has changes and the current values in
+ * {@link #layout} are not valid.
+ */
+ DIRTY,
+
+ /**
+ * This node has a new layout relative to the last time {@link #markLayoutSeen()} was called.
+ */
+ HAS_NEW_LAYOUT,
+
+ /**
+ * {@link #layout} is valid for the node's properties and this layout has been marked as
+ * having been seen.
+ */
+ UP_TO_DATE,
+ }
+
+ public static interface MeasureFunction {
+
+ /**
+ * Should measure the given node and put the result in the given MeasureOutput.
+ *
+ * NB: measure is NOT guaranteed to be threadsafe/re-entrant safe!
+ */
+ public void measure(CSSNode node, float width, CSSMeasureMode widthMode, float height, CSSMeasureMode heightMode, MeasureOutput measureOutput);
+ }
+
+ // VisibleForTesting
+ /*package*/ final CSSStyle style = new CSSStyle();
+ /*package*/ final CSSLayout layout = new CSSLayout();
+ /*package*/ final CachedCSSLayout lastLayout = new CachedCSSLayout();
+
+ public int lineIndex = 0;
+
+ /*package*/ CSSNode nextChild;
+
+ private @Nullable ArrayList mChildren;
+ private @Nullable CSSNode mParent;
+ private @Nullable MeasureFunction mMeasureFunction = null;
+ private LayoutState mLayoutState = LayoutState.DIRTY;
+ private boolean mIsTextNode = false;
+
+ public int getChildCount() {
+ return mChildren == null ? 0 : mChildren.size();
+ }
+
+ public CSSNode getChildAt(int i) {
+ Assertions.assertNotNull(mChildren);
+ return mChildren.get(i);
+ }
+
+ public void addChildAt(CSSNode child, int i) {
+ if (child.mParent != null) {
+ throw new IllegalStateException("Child already has a parent, it must be removed first.");
+ }
+ if (mChildren == null) {
+ // 4 is kinda arbitrary, but the default of 10 seems really high for an average View.
+ mChildren = new ArrayList<>(4);
+ }
+
+ mChildren.add(i, child);
+ child.mParent = this;
+ dirty();
+ }
+
+ public CSSNode removeChildAt(int i) {
+ Assertions.assertNotNull(mChildren);
+ CSSNode removed = mChildren.remove(i);
+ removed.mParent = null;
+ dirty();
+ return removed;
+ }
+
+ public @Nullable CSSNode getParent() {
+ return mParent;
+ }
+
+ /**
+ * @return the index of the given child, or -1 if the child doesn't exist in this node.
+ */
+ public int indexOf(CSSNode child) {
+ Assertions.assertNotNull(mChildren);
+ return mChildren.indexOf(child);
+ }
+
+ public void setMeasureFunction(MeasureFunction measureFunction) {
+ if (mMeasureFunction != measureFunction) {
+ mMeasureFunction = measureFunction;
+ dirty();
+ }
+ }
+
+ public boolean isMeasureDefined() {
+ return mMeasureFunction != null;
+ }
+
+ public void setIsTextNode(boolean isTextNode) {
+ mIsTextNode = isTextNode;
+ }
+
+ public boolean isTextNode() {
+ return mIsTextNode;
+ }
+
+ /*package*/ MeasureOutput measure(MeasureOutput measureOutput, float width, CSSMeasureMode widthMode, float height, CSSMeasureMode heightMode) {
+ if (!isMeasureDefined()) {
+ throw new RuntimeException("Measure function isn't defined!");
+ }
+ measureOutput.height = CSSConstants.UNDEFINED;
+ measureOutput.width = CSSConstants.UNDEFINED;
+ Assertions.assertNotNull(mMeasureFunction).measure(this, width, widthMode, height, heightMode, measureOutput);
+ return measureOutput;
+ }
+
+ /**
+ * Performs the actual layout and saves the results in {@link #layout}
+ */
+ public void calculateLayout(CSSLayoutContext layoutContext) {
+ LayoutEngine.layoutNode(layoutContext, this, CSSConstants.UNDEFINED, CSSConstants.UNDEFINED, null);
+ }
+
+ /**
+ * See {@link LayoutState#DIRTY}.
+ */
+ protected boolean isDirty() {
+ return mLayoutState == LayoutState.DIRTY;
+ }
+
+ /**
+ * See {@link LayoutState#HAS_NEW_LAYOUT}.
+ */
+ public boolean hasNewLayout() {
+ return mLayoutState == LayoutState.HAS_NEW_LAYOUT;
+ }
+
+ protected void dirty() {
+ if (mLayoutState == LayoutState.DIRTY) {
+ return;
+ } else if (mLayoutState == LayoutState.HAS_NEW_LAYOUT) {
+ throw new IllegalStateException("Previous layout was ignored! markLayoutSeen() never called");
+ }
+
+ mLayoutState = LayoutState.DIRTY;
+
+ if (mParent != null) {
+ mParent.dirty();
+ }
+ }
+
+ /*package*/ void markHasNewLayout() {
+ mLayoutState = LayoutState.HAS_NEW_LAYOUT;
+ }
+
+ /**
+ * Tells the node that the current values in {@link #layout} have been seen. Subsequent calls
+ * to {@link #hasNewLayout()} will return false until this node is laid out with new parameters.
+ * You must call this each time the layout is generated if the node has a new layout.
+ */
+ public void markLayoutSeen() {
+ if (!hasNewLayout()) {
+ throw new IllegalStateException("Expected node to have a new layout to be seen!");
+ }
+
+ mLayoutState = LayoutState.UP_TO_DATE;
+ }
+
+ private void toStringWithIndentation(StringBuilder result, int level) {
+ // Spaces and tabs are dropped by IntelliJ logcat integration, so rely on __ instead.
+ StringBuilder indentation = new StringBuilder();
+ for (int i = 0; i < level; ++i) {
+ indentation.append("__");
+ }
+
+ result.append(indentation.toString());
+ result.append(layout.toString());
+
+ if (getChildCount() == 0) {
+ return;
+ }
+
+ result.append(", children: [\n");
+ for (int i = 0; i < getChildCount(); i++) {
+ getChildAt(i).toStringWithIndentation(result, level + 1);
+ result.append("\n");
+ }
+ result.append(indentation + "]");
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder();
+ this.toStringWithIndentation(sb, 0);
+ return sb.toString();
+ }
+
+ protected boolean valuesEqual(float f1, float f2) {
+ return FloatUtil.floatsEqual(f1, f2);
+ }
+
+ /**
+ * Get this node's direction, as defined in the style.
+ */
+ public CSSDirection getStyleDirection() {
+ return style.direction;
+ }
+
+ public void setDirection(CSSDirection direction) {
+ if (style.direction != direction) {
+ style.direction = direction;
+ dirty();
+ }
+ }
+
+ /**
+ * Get this node's flex direction, as defined by style.
+ */
+ public CSSFlexDirection getFlexDirection() {
+ return style.flexDirection;
+ }
+
+ public void setFlexDirection(CSSFlexDirection flexDirection) {
+ if (style.flexDirection != flexDirection) {
+ style.flexDirection = flexDirection;
+ dirty();
+ }
+ }
+
+ /**
+ * Get this node's justify content, as defined by style.
+ */
+ public CSSJustify getJustifyContent() {
+ return style.justifyContent;
+ }
+
+ public void setJustifyContent(CSSJustify justifyContent) {
+ if (style.justifyContent != justifyContent) {
+ style.justifyContent = justifyContent;
+ dirty();
+ }
+ }
+
+ /**
+ * Get this node's align items, as defined by style.
+ */
+ public CSSAlign getAlignItems() {
+ return style.alignItems;
+ }
+
+ public void setAlignItems(CSSAlign alignItems) {
+ if (style.alignItems != alignItems) {
+ style.alignItems = alignItems;
+ dirty();
+ }
+ }
+
+ /**
+ * Get this node's align items, as defined by style.
+ */
+ public CSSAlign getAlignSelf() {
+ return style.alignSelf;
+ }
+
+ public void setAlignSelf(CSSAlign alignSelf) {
+ if (style.alignSelf != alignSelf) {
+ style.alignSelf = alignSelf;
+ dirty();
+ }
+ }
+
+ /**
+ * Get this node's position type, as defined by style.
+ */
+ public CSSPositionType getPositionType() {
+ return style.positionType;
+ }
+
+ public void setPositionType(CSSPositionType positionType) {
+ if (style.positionType != positionType) {
+ style.positionType = positionType;
+ dirty();
+ }
+ }
+
+ public void setWrap(CSSWrap flexWrap) {
+ if (style.flexWrap != flexWrap) {
+ style.flexWrap = flexWrap;
+ dirty();
+ }
+ }
+
+ /**
+ * Get this node's flex, as defined by style.
+ */
+ public float getFlex() {
+ return style.flex;
+ }
+
+ public void setFlex(float flex) {
+ if (!valuesEqual(style.flex, flex)) {
+ style.flex = flex;
+ dirty();
+ }
+ }
+
+ /**
+ * Get this node's margin, as defined by style + default margin.
+ */
+ public Spacing getMargin() {
+ return style.margin;
+ }
+
+ public void setMargin(int spacingType, float margin) {
+ if (style.margin.set(spacingType, margin)) {
+ dirty();
+ }
+ }
+
+ /**
+ * Get this node's padding, as defined by style + default padding.
+ */
+ public Spacing getPadding() {
+ return style.padding;
+ }
+
+ public void setPadding(int spacingType, float padding) {
+ if (style.padding.set(spacingType, padding)) {
+ dirty();
+ }
+ }
+
+ /**
+ * Get this node's border, as defined by style.
+ */
+ public Spacing getBorder() {
+ return style.border;
+ }
+
+ public void setBorder(int spacingType, float border) {
+ if (style.border.set(spacingType, border)) {
+ dirty();
+ }
+ }
+
+ /**
+ * Get this node's position top, as defined by style.
+ */
+ public float getPositionTop() {
+ return style.position[POSITION_TOP];
+ }
+
+ public void setPositionTop(float positionTop) {
+ if (!valuesEqual(style.position[POSITION_TOP], positionTop)) {
+ style.position[POSITION_TOP] = positionTop;
+ dirty();
+ }
+ }
+
+ /**
+ * Get this node's position bottom, as defined by style.
+ */
+ public float getPositionBottom() {
+ return style.position[POSITION_BOTTOM];
+ }
+
+ public void setPositionBottom(float positionBottom) {
+ if (!valuesEqual(style.position[POSITION_BOTTOM], positionBottom)) {
+ style.position[POSITION_BOTTOM] = positionBottom;
+ dirty();
+ }
+ }
+
+ /**
+ * Get this node's position left, as defined by style.
+ */
+ public float getPositionLeft() {
+ return style.position[POSITION_LEFT];
+ }
+
+ public void setPositionLeft(float positionLeft) {
+ if (!valuesEqual(style.position[POSITION_LEFT], positionLeft)) {
+ style.position[POSITION_LEFT] = positionLeft;
+ dirty();
+ }
+ }
+
+ /**
+ * Get this node's position right, as defined by style.
+ */
+ public float getPositionRight() {
+ return style.position[POSITION_RIGHT];
+ }
+
+ public void setPositionRight(float positionRight) {
+ if (!valuesEqual(style.position[POSITION_RIGHT], positionRight)) {
+ style.position[POSITION_RIGHT] = positionRight;
+ dirty();
+ }
+ }
+
+ /**
+ * Get this node's width, as defined in the style.
+ */
+ public float getStyleWidth() {
+ return style.dimensions[DIMENSION_WIDTH];
+ }
+
+ public void setStyleWidth(float width) {
+ if (!valuesEqual(style.dimensions[DIMENSION_WIDTH], width)) {
+ style.dimensions[DIMENSION_WIDTH] = width;
+ dirty();
+ }
+ }
+
+ /**
+ * Get this node's height, as defined in the style.
+ */
+ public float getStyleHeight() {
+ return style.dimensions[DIMENSION_HEIGHT];
+ }
+
+ public void setStyleHeight(float height) {
+ if (!valuesEqual(style.dimensions[DIMENSION_HEIGHT], height)) {
+ style.dimensions[DIMENSION_HEIGHT] = height;
+ dirty();
+ }
+ }
+
+ /**
+ * Get this node's max width, as defined in the style
+ */
+ public float getStyleMaxWidth() {
+ return style.maxWidth;
+ }
+
+ public void setStyleMaxWidth(float maxWidth) {
+ if (!valuesEqual(style.maxWidth, maxWidth)) {
+ style.maxWidth = maxWidth;
+ dirty();
+ }
+ }
+
+ /**
+ * Get this node's min width, as defined in the style
+ */
+ public float getStyleMinWidth() {
+ return style.minWidth;
+ }
+
+ public void setStyleMinWidth(float minWidth) {
+ if (!valuesEqual(style.minWidth, minWidth)) {
+ style.minWidth = minWidth;
+ dirty();
+ }
+ }
+
+ /**
+ * Get this node's max height, as defined in the style
+ */
+ public float getStyleMaxHeight() {
+ return style.maxHeight;
+ }
+
+ public void setStyleMaxHeight(float maxHeight) {
+ if (!valuesEqual(style.maxHeight, maxHeight)) {
+ style.maxHeight = maxHeight;
+ dirty();
+ }
+ }
+
+ /**
+ * Get this node's min height, as defined in the style
+ */
+ public float getStyleMinHeight() {
+ return style.minHeight;
+ }
+
+ public void setStyleMinHeight(float minHeight) {
+ if (!valuesEqual(style.minHeight, minHeight)) {
+ style.minHeight = minHeight;
+ dirty();
+ }
+ }
+
+ public float getLayoutX() {
+ return layout.position[POSITION_LEFT];
+ }
+
+ public float getLayoutY() {
+ return layout.position[POSITION_TOP];
+ }
+
+ public float getLayoutWidth() {
+ return layout.dimensions[DIMENSION_WIDTH];
+ }
+
+ public float getLayoutHeight() {
+ return layout.dimensions[DIMENSION_HEIGHT];
+ }
+
+ public CSSDirection getLayoutDirection() {
+ return layout.direction;
+ }
+
+ /**
+ * Set a default padding (left/top/right/bottom) for this node.
+ */
+ public void setDefaultPadding(int spacingType, float padding) {
+ if (style.padding.setDefault(spacingType, padding)) {
+ dirty();
+ }
+ }
+
+ /**
+ * Get this node's overflow property, as defined in the style
+ */
+ public CSSOverflow getOverflow() {
+ return style.overflow;
+ }
+
+ public void setOverflow(CSSOverflow overflow) {
+ if (style.overflow != overflow) {
+ style.overflow = overflow;
+ dirty();
+ }
+ }
+
+ /**
+ * Resets this instance to its default state. This method is meant to be used when
+ * recycling {@link CSSNode} instances.
+ */
+ public void reset() {
+ if (mParent != null || (mChildren != null && mChildren.size() > 0)) {
+ throw new IllegalStateException("You should not reset an attached CSSNode");
+ }
+
+ style.reset();
+ layout.resetResult();
+ lineIndex = 0;
+ mLayoutState = LayoutState.DIRTY;
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSOverflow.java b/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSOverflow.java
new file mode 100644
index 00000000000000..29957a9a7b840c
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSOverflow.java
@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.csslayout;
+
+public enum CSSOverflow {
+ VISIBLE,
+ HIDDEN,
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSPositionType.java b/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSPositionType.java
new file mode 100644
index 00000000000000..19e27dd45b4214
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSPositionType.java
@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.csslayout;
+
+public enum CSSPositionType {
+ RELATIVE,
+ ABSOLUTE,
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSStyle.java b/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSStyle.java
new file mode 100644
index 00000000000000..8c86149edc05f2
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSStyle.java
@@ -0,0 +1,72 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.csslayout;
+
+import java.util.Arrays;
+
+/**
+ * The CSS style definition for a {@link CSSNode}.
+ */
+public class CSSStyle {
+
+ public CSSDirection direction;
+ public CSSFlexDirection flexDirection;
+ public CSSJustify justifyContent;
+ public CSSAlign alignContent;
+ public CSSAlign alignItems;
+ public CSSAlign alignSelf;
+ public CSSPositionType positionType;
+ public CSSWrap flexWrap;
+ public CSSOverflow overflow;
+ public float flex;
+
+ public Spacing margin = new Spacing();
+ public Spacing padding = new Spacing();
+ public Spacing border = new Spacing();
+
+ public float[] position = new float[4];
+ public float[] dimensions = new float[2];
+
+ public float minWidth = CSSConstants.UNDEFINED;
+ public float minHeight = CSSConstants.UNDEFINED;
+
+ public float maxWidth = CSSConstants.UNDEFINED;
+ public float maxHeight = CSSConstants.UNDEFINED;
+
+ CSSStyle() {
+ reset();
+ }
+
+ void reset() {
+ direction = CSSDirection.INHERIT;
+ flexDirection = CSSFlexDirection.COLUMN;
+ justifyContent = CSSJustify.FLEX_START;
+ alignContent = CSSAlign.FLEX_START;
+ alignItems = CSSAlign.STRETCH;
+ alignSelf = CSSAlign.AUTO;
+ positionType = CSSPositionType.RELATIVE;
+ flexWrap = CSSWrap.NOWRAP;
+ overflow = CSSOverflow.VISIBLE;
+ flex = 0f;
+
+ margin.reset();;
+ padding.reset();
+ border.reset();
+
+ Arrays.fill(position, CSSConstants.UNDEFINED);
+ Arrays.fill(dimensions, CSSConstants.UNDEFINED);
+
+ minWidth = CSSConstants.UNDEFINED;
+ minHeight = CSSConstants.UNDEFINED;
+
+ maxWidth = CSSConstants.UNDEFINED;
+ maxHeight = CSSConstants.UNDEFINED;
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSWrap.java b/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSWrap.java
new file mode 100644
index 00000000000000..895bb5d5536959
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/csslayout/CSSWrap.java
@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.csslayout;
+
+public enum CSSWrap {
+ NOWRAP,
+ WRAP,
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/csslayout/CachedCSSLayout.java b/android/ReactAndroid/src/main/java/com/facebook/csslayout/CachedCSSLayout.java
new file mode 100644
index 00000000000000..a012a5ba8d1cac
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/csslayout/CachedCSSLayout.java
@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.csslayout;
+
+/**
+ * CSSLayout with additional information about the conditions under which it was generated.
+ * {@link #requestedWidth} and {@link #requestedHeight} are the width and height the parent set on
+ * this node before calling layout visited us.
+ */
+public class CachedCSSLayout extends CSSLayout {
+
+ public float requestedWidth = CSSConstants.UNDEFINED;
+ public float requestedHeight = CSSConstants.UNDEFINED;
+ public float parentMaxWidth = CSSConstants.UNDEFINED;
+ public float parentMaxHeight = CSSConstants.UNDEFINED;
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/csslayout/FloatUtil.java b/android/ReactAndroid/src/main/java/com/facebook/csslayout/FloatUtil.java
new file mode 100644
index 00000000000000..8b211e8de587ca
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/csslayout/FloatUtil.java
@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.csslayout;
+
+public class FloatUtil {
+
+ private static final float EPSILON = .00001f;
+
+ public static boolean floatsEqual(float f1, float f2) {
+ if (Float.isNaN(f1) || Float.isNaN(f2)) {
+ return Float.isNaN(f1) && Float.isNaN(f2);
+ }
+ return Math.abs(f2 - f1) < EPSILON;
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/csslayout/LayoutEngine.java b/android/ReactAndroid/src/main/java/com/facebook/csslayout/LayoutEngine.java
new file mode 100644
index 00000000000000..bb8e90b67208c5
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/csslayout/LayoutEngine.java
@@ -0,0 +1,1411 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.csslayout;
+
+import com.facebook.infer.annotation.Assertions;
+
+import static com.facebook.csslayout.CSSLayout.DIMENSION_HEIGHT;
+import static com.facebook.csslayout.CSSLayout.DIMENSION_WIDTH;
+import static com.facebook.csslayout.CSSLayout.POSITION_BOTTOM;
+import static com.facebook.csslayout.CSSLayout.POSITION_LEFT;
+import static com.facebook.csslayout.CSSLayout.POSITION_RIGHT;
+import static com.facebook.csslayout.CSSLayout.POSITION_TOP;
+
+/**
+ * Calculates layouts based on CSS style. See {@link #layoutNode(CSSNode, float, float)}.
+ */
+public class LayoutEngine {
+
+ private static final boolean POSITIVE_FLEX_IS_AUTO = false;
+
+ private static final int CSS_FLEX_DIRECTION_COLUMN =
+ CSSFlexDirection.COLUMN.ordinal();
+ private static final int CSS_FLEX_DIRECTION_COLUMN_REVERSE =
+ CSSFlexDirection.COLUMN_REVERSE.ordinal();
+ private static final int CSS_FLEX_DIRECTION_ROW =
+ CSSFlexDirection.ROW.ordinal();
+ private static final int CSS_FLEX_DIRECTION_ROW_REVERSE =
+ CSSFlexDirection.ROW_REVERSE.ordinal();
+
+ private static final int CSS_POSITION_RELATIVE = CSSPositionType.RELATIVE.ordinal();
+ private static final int CSS_POSITION_ABSOLUTE = CSSPositionType.ABSOLUTE.ordinal();
+
+ private static final int[] leading = {
+ POSITION_TOP,
+ POSITION_BOTTOM,
+ POSITION_LEFT,
+ POSITION_RIGHT,
+ };
+
+ private static final int[] trailing = {
+ POSITION_BOTTOM,
+ POSITION_TOP,
+ POSITION_RIGHT,
+ POSITION_LEFT,
+ };
+
+ private static final int[] pos = {
+ POSITION_TOP,
+ POSITION_BOTTOM,
+ POSITION_LEFT,
+ POSITION_RIGHT,
+ };
+
+ private static final int[] dim = {
+ DIMENSION_HEIGHT,
+ DIMENSION_HEIGHT,
+ DIMENSION_WIDTH,
+ DIMENSION_WIDTH,
+ };
+
+ private static final int[] leadingSpacing = {
+ Spacing.TOP,
+ Spacing.BOTTOM,
+ Spacing.START,
+ Spacing.START
+ };
+
+ private static final int[] trailingSpacing = {
+ Spacing.BOTTOM,
+ Spacing.TOP,
+ Spacing.END,
+ Spacing.END
+ };
+
+ private static boolean isFlexBasisAuto(CSSNode node) {
+ if (POSITIVE_FLEX_IS_AUTO) {
+ // All flex values are auto.
+ return true;
+ } else {
+ // A flex value > 0 implies a basis of zero.
+ return node.style.flex <= 0;
+ }
+ }
+
+ private static float getFlexGrowFactor(CSSNode node) {
+ // Flex grow is implied by positive values for flex.
+ if (node.style.flex > 0) {
+ return node.style.flex;
+ }
+ return 0;
+ }
+
+ private static float getFlexShrinkFactor(CSSNode node) {
+ if (POSITIVE_FLEX_IS_AUTO) {
+ // A flex shrink factor of 1 is implied by non-zero values for flex.
+ if (node.style.flex != 0) {
+ return 1;
+ }
+ } else {
+ // A flex shrink factor of 1 is implied by negative values for flex.
+ if (node.style.flex < 0) {
+ return 1;
+ }
+ }
+ return 0;
+ }
+
+
+ private static float boundAxisWithinMinAndMax(CSSNode node, int axis, float value) {
+ float min = CSSConstants.UNDEFINED;
+ float max = CSSConstants.UNDEFINED;
+
+ if (axis == CSS_FLEX_DIRECTION_COLUMN ||
+ axis == CSS_FLEX_DIRECTION_COLUMN_REVERSE) {
+ min = node.style.minHeight;
+ max = node.style.maxHeight;
+ } else if (axis == CSS_FLEX_DIRECTION_ROW ||
+ axis == CSS_FLEX_DIRECTION_ROW_REVERSE) {
+ min = node.style.minWidth;
+ max = node.style.maxWidth;
+ }
+
+ float boundValue = value;
+
+ if (!Float.isNaN(max) && max >= 0.0 && boundValue > max) {
+ boundValue = max;
+ }
+ if (!Float.isNaN(min) && min >= 0.0 && boundValue < min) {
+ boundValue = min;
+ }
+
+ return boundValue;
+ }
+
+ private static float boundAxis(CSSNode node, int axis, float value) {
+ float paddingAndBorderAxis =
+ node.style.padding.getWithFallback(leadingSpacing[axis], leading[axis]) +
+ node.style.border.getWithFallback(leadingSpacing[axis], leading[axis]) +
+ node.style.padding.getWithFallback(trailingSpacing[axis], trailing[axis]) +
+ node.style.border.getWithFallback(trailingSpacing[axis], trailing[axis]);
+ return Math.max(boundAxisWithinMinAndMax(node, axis, value), paddingAndBorderAxis);
+ }
+
+ private static float getRelativePosition(CSSNode node, int axis) {
+ float lead = node.style.position[leading[axis]];
+ if (!Float.isNaN(lead)) {
+ return lead;
+ }
+
+ float trailingPos = node.style.position[trailing[axis]];
+ return Float.isNaN(trailingPos) ? 0 : -trailingPos;
+ }
+
+ private static void setPosition(CSSNode node, CSSDirection direction) {
+ int mainAxis = resolveAxis(getFlexDirection(node), direction);
+ int crossAxis = getCrossFlexDirection(mainAxis, direction);
+
+ node.layout.position[leading[mainAxis]] = node.style.margin.getWithFallback(leadingSpacing[mainAxis], leading[mainAxis]) +
+ getRelativePosition(node, mainAxis);
+ node.layout.position[trailing[mainAxis]] = node.style.margin.getWithFallback(trailingSpacing[mainAxis], trailing[mainAxis]) +
+ getRelativePosition(node, mainAxis);
+ node.layout.position[leading[crossAxis]] = node.style.margin.getWithFallback(leadingSpacing[crossAxis], leading[crossAxis]) +
+ getRelativePosition(node, crossAxis);
+ node.layout.position[trailing[crossAxis]] = node.style.margin.getWithFallback(trailingSpacing[crossAxis], trailing[crossAxis]) +
+ getRelativePosition(node, crossAxis);
+ }
+
+ private static int resolveAxis(
+ int axis,
+ CSSDirection direction) {
+ if (direction == CSSDirection.RTL) {
+ if (axis == CSS_FLEX_DIRECTION_ROW) {
+ return CSS_FLEX_DIRECTION_ROW_REVERSE;
+ } else if (axis == CSS_FLEX_DIRECTION_ROW_REVERSE) {
+ return CSS_FLEX_DIRECTION_ROW;
+ }
+ }
+
+ return axis;
+ }
+
+ private static CSSDirection resolveDirection(CSSNode node, CSSDirection parentDirection) {
+ CSSDirection direction = node.style.direction;
+ if (direction == CSSDirection.INHERIT) {
+ direction = (parentDirection == null ? CSSDirection.LTR : parentDirection);
+ }
+
+ return direction;
+ }
+
+ private static int getFlexDirection(CSSNode node) {
+ return node.style.flexDirection.ordinal();
+ }
+
+ private static int getCrossFlexDirection(
+ int axis,
+ CSSDirection direction) {
+ if (axis == CSS_FLEX_DIRECTION_COLUMN ||
+ axis == CSS_FLEX_DIRECTION_COLUMN_REVERSE) {
+ return resolveAxis(CSS_FLEX_DIRECTION_ROW, direction);
+ } else {
+ return CSS_FLEX_DIRECTION_COLUMN;
+ }
+ }
+
+ private static CSSAlign getAlignItem(CSSNode node, CSSNode child) {
+ if (child.style.alignSelf != CSSAlign.AUTO) {
+ return child.style.alignSelf;
+ }
+ return node.style.alignItems;
+ }
+
+ private static boolean isMeasureDefined(CSSNode node) {
+ return node.isMeasureDefined();
+ }
+
+ /*package*/ static void layoutNode(
+ CSSLayoutContext layoutContext,
+ CSSNode node,
+ float availableWidth,
+ float availableHeight,
+ CSSDirection parentDirection) {
+ // Increment the generation count. This will force the recursive routine to visit
+ // all dirty nodes at least once. Subsequent visits will be skipped if the input
+ // parameters don't change.
+ layoutContext.currentGenerationCount++;
+
+ CSSMeasureMode widthMeasureMode = CSSMeasureMode.UNDEFINED;
+ CSSMeasureMode heightMeasureMode = CSSMeasureMode.UNDEFINED;
+
+ if (!Float.isNaN(availableWidth)) {
+ widthMeasureMode = CSSMeasureMode.EXACTLY;
+ } else if (node.style.dimensions[DIMENSION_WIDTH] >= 0.0) {
+ float marginAxisRow = (node.style.margin.getWithFallback(leadingSpacing[CSS_FLEX_DIRECTION_ROW], leading[CSS_FLEX_DIRECTION_ROW]) + node.style.margin.getWithFallback(trailingSpacing[CSS_FLEX_DIRECTION_ROW], trailing[CSS_FLEX_DIRECTION_ROW]));
+ availableWidth = node.style.dimensions[DIMENSION_WIDTH] + marginAxisRow;
+ widthMeasureMode = CSSMeasureMode.EXACTLY;
+ } else if (node.style.maxWidth >= 0.0) {
+ availableWidth = node.style.maxWidth;
+ widthMeasureMode = CSSMeasureMode.AT_MOST;
+ }
+
+ if (!Float.isNaN(availableHeight)) {
+ heightMeasureMode = CSSMeasureMode.EXACTLY;
+ } else if (node.style.dimensions[DIMENSION_HEIGHT] >= 0.0) {
+ float marginAxisColumn = (node.style.margin.getWithFallback(leadingSpacing[CSS_FLEX_DIRECTION_COLUMN], leading[CSS_FLEX_DIRECTION_COLUMN]) + node.style.margin.getWithFallback(trailingSpacing[CSS_FLEX_DIRECTION_COLUMN], trailing[CSS_FLEX_DIRECTION_COLUMN]));
+ availableHeight = node.style.dimensions[DIMENSION_HEIGHT] + marginAxisColumn;
+ heightMeasureMode = CSSMeasureMode.EXACTLY;
+ } else if (node.style.maxHeight >= 0.0) {
+ availableHeight = node.style.maxHeight;
+ heightMeasureMode = CSSMeasureMode.AT_MOST;
+ }
+
+ if (layoutNodeInternal(layoutContext, node, availableWidth, availableHeight, parentDirection, widthMeasureMode, heightMeasureMode, true, "initial")) {
+ setPosition(node, node.layout.direction);
+ }
+ }
+
+ /*package*/ static boolean canUseCachedMeasurement(
+ boolean isTextNode,
+ float availableWidth,
+ float availableHeight,
+ float marginRow,
+ float marginColumn,
+ CSSMeasureMode widthMeasureMode,
+ CSSMeasureMode heightMeasureMode,
+ CSSCachedMeasurement cachedLayout) {
+
+ boolean isHeightSame =
+ (cachedLayout.heightMeasureMode == CSSMeasureMode.UNDEFINED && heightMeasureMode == CSSMeasureMode.UNDEFINED) ||
+ (cachedLayout.heightMeasureMode == heightMeasureMode && FloatUtil.floatsEqual(cachedLayout.availableHeight, availableHeight));
+
+ boolean isWidthSame =
+ (cachedLayout.widthMeasureMode == CSSMeasureMode.UNDEFINED && widthMeasureMode == CSSMeasureMode.UNDEFINED) ||
+ (cachedLayout.widthMeasureMode == widthMeasureMode && FloatUtil.floatsEqual(cachedLayout.availableWidth, availableWidth));
+
+ if (isHeightSame && isWidthSame) {
+ return true;
+ }
+
+ boolean isHeightValid =
+ (cachedLayout.heightMeasureMode == CSSMeasureMode.UNDEFINED && heightMeasureMode == CSSMeasureMode.AT_MOST && cachedLayout.computedHeight <= (availableHeight - marginColumn)) ||
+ (heightMeasureMode == CSSMeasureMode.EXACTLY && FloatUtil.floatsEqual(cachedLayout.computedHeight, availableHeight - marginColumn));
+
+ if (isWidthSame && isHeightValid) {
+ return true;
+ }
+
+ boolean isWidthValid =
+ (cachedLayout.widthMeasureMode == CSSMeasureMode.UNDEFINED && widthMeasureMode == CSSMeasureMode.AT_MOST && cachedLayout.computedWidth <= (availableWidth - marginRow)) ||
+ (widthMeasureMode == CSSMeasureMode.EXACTLY && FloatUtil.floatsEqual(cachedLayout.computedWidth, availableWidth - marginRow));
+
+ if (isHeightSame && isWidthValid) {
+ return true;
+ }
+
+ if (isHeightValid && isWidthValid) {
+ return true;
+ }
+
+ // We know this to be text so we can apply some more specialized heuristics.
+ if (isTextNode) {
+ if (isWidthSame) {
+ if (heightMeasureMode == CSSMeasureMode.UNDEFINED) {
+ // Width is the same and height is not restricted. Re-use cahced value.
+ return true;
+ }
+
+ if (heightMeasureMode == CSSMeasureMode.AT_MOST &&
+ cachedLayout.computedHeight < (availableHeight - marginColumn)) {
+ // Width is the same and height restriction is greater than the cached height. Re-use cached value.
+ return true;
+ }
+
+ // Width is the same but height restriction imposes smaller height than previously measured.
+ // Update the cached value to respect the new height restriction.
+ cachedLayout.computedHeight = availableHeight - marginColumn;
+ return true;
+ }
+
+ if (cachedLayout.widthMeasureMode == CSSMeasureMode.UNDEFINED) {
+ if (widthMeasureMode == CSSMeasureMode.UNDEFINED ||
+ (widthMeasureMode == CSSMeasureMode.AT_MOST &&
+ cachedLayout.computedWidth <= (availableWidth - marginRow))) {
+ // Previsouly this text was measured with no width restriction, if width is now restricted
+ // but to a larger value than the previsouly measured width we can re-use the measurement
+ // as we know it will fit.
+ return true;
+ }
+ }
+ }
+
+ return false;
+ }
+
+ //
+ // This is a wrapper around the layoutNodeImpl function. It determines
+ // whether the layout request is redundant and can be skipped.
+ //
+ // Parameters:
+ // Input parameters are the same as layoutNodeImpl (see below)
+ // Return parameter is true if layout was performed, false if skipped
+ //
+ private static boolean layoutNodeInternal(
+ CSSLayoutContext layoutContext,
+ CSSNode node,
+ float availableWidth,
+ float availableHeight,
+ CSSDirection parentDirection,
+ CSSMeasureMode widthMeasureMode,
+ CSSMeasureMode heightMeasureMode,
+ boolean performLayout,
+ String reason) {
+ CSSLayout layout = node.layout;
+
+ boolean needToVisitNode = (node.isDirty() && layout.generationCount != layoutContext.currentGenerationCount) ||
+ layout.lastParentDirection != parentDirection;
+
+ if (needToVisitNode) {
+ // Invalidate the cached results.
+ layout.nextCachedMeasurementsIndex = 0;
+ layout.cachedLayout.widthMeasureMode = null;
+ layout.cachedLayout.heightMeasureMode = null;
+ }
+
+ CSSCachedMeasurement cachedResults = null;
+
+ // Determine whether the results are already cached. We maintain a separate
+ // cache for layouts and measurements. A layout operation modifies the positions
+ // and dimensions for nodes in the subtree. The algorithm assumes that each node
+ // gets layed out a maximum of one time per tree layout, but multiple measurements
+ // may be required to resolve all of the flex dimensions.
+ // We handle nodes with measure functions specially here because they are the most
+ // expensive to measure, so it's worth avoiding redundant measurements if at all possible.
+ if (isMeasureDefined(node)) {
+ float marginAxisRow =
+ node.style.margin.getWithFallback(leadingSpacing[CSS_FLEX_DIRECTION_ROW], leading[CSS_FLEX_DIRECTION_ROW]) +
+ node.style.margin.getWithFallback(trailingSpacing[CSS_FLEX_DIRECTION_ROW], trailing[CSS_FLEX_DIRECTION_ROW]);
+ float marginAxisColumn =
+ node.style.margin.getWithFallback(leadingSpacing[CSS_FLEX_DIRECTION_COLUMN], leading[CSS_FLEX_DIRECTION_COLUMN]) +
+ node.style.margin.getWithFallback(trailingSpacing[CSS_FLEX_DIRECTION_COLUMN], trailing[CSS_FLEX_DIRECTION_COLUMN]);
+
+ // First, try to use the layout cache.
+ if (canUseCachedMeasurement(node.isTextNode(), availableWidth, availableHeight, marginAxisRow, marginAxisColumn,
+ widthMeasureMode, heightMeasureMode, layout.cachedLayout)) {
+ cachedResults = layout.cachedLayout;
+ } else {
+ // Try to use the measurement cache.
+ for (int i = 0; i < layout.nextCachedMeasurementsIndex; i++) {
+ if (canUseCachedMeasurement(node.isTextNode(), availableWidth, availableHeight, marginAxisRow, marginAxisColumn,
+ widthMeasureMode, heightMeasureMode, layout.cachedMeasurements[i])) {
+ cachedResults = layout.cachedMeasurements[i];
+ break;
+ }
+ }
+ }
+ } else if (performLayout) {
+ if (FloatUtil.floatsEqual(layout.cachedLayout.availableWidth, availableWidth) &&
+ FloatUtil.floatsEqual(layout.cachedLayout.availableHeight, availableHeight) &&
+ layout.cachedLayout.widthMeasureMode == widthMeasureMode &&
+ layout.cachedLayout.heightMeasureMode == heightMeasureMode) {
+
+ cachedResults = layout.cachedLayout;
+ }
+ } else {
+ for (int i = 0; i < layout.nextCachedMeasurementsIndex; i++) {
+ if (FloatUtil.floatsEqual(layout.cachedMeasurements[i].availableWidth, availableWidth) &&
+ FloatUtil.floatsEqual(layout.cachedMeasurements[i].availableHeight, availableHeight) &&
+ layout.cachedMeasurements[i].widthMeasureMode == widthMeasureMode &&
+ layout.cachedMeasurements[i].heightMeasureMode == heightMeasureMode) {
+
+ cachedResults = layout.cachedMeasurements[i];
+ break;
+ }
+ }
+ }
+
+ if (!needToVisitNode && cachedResults != null) {
+ layout.measuredDimensions[DIMENSION_WIDTH] = cachedResults.computedWidth;
+ layout.measuredDimensions[DIMENSION_HEIGHT] = cachedResults.computedHeight;
+ } else {
+ layoutNodeImpl(layoutContext, node, availableWidth, availableHeight, parentDirection, widthMeasureMode, heightMeasureMode, performLayout);
+
+ layout.lastParentDirection = parentDirection;
+
+ if (cachedResults == null) {
+ if (layout.nextCachedMeasurementsIndex == CSSLayout.MAX_CACHED_RESULT_COUNT) {
+ layout.nextCachedMeasurementsIndex = 0;
+ }
+
+ CSSCachedMeasurement newCacheEntry = null;
+ if (performLayout) {
+ // Use the single layout cache entry.
+ newCacheEntry = layout.cachedLayout;
+ } else {
+ // Allocate a new measurement cache entry.
+ newCacheEntry = layout.cachedMeasurements[layout.nextCachedMeasurementsIndex];
+ if (newCacheEntry == null) {
+ newCacheEntry = new CSSCachedMeasurement();
+ layout.cachedMeasurements[layout.nextCachedMeasurementsIndex] = newCacheEntry;
+ }
+ layout.nextCachedMeasurementsIndex++;
+ }
+
+ newCacheEntry.availableWidth = availableWidth;
+ newCacheEntry.availableHeight = availableHeight;
+ newCacheEntry.widthMeasureMode = widthMeasureMode;
+ newCacheEntry.heightMeasureMode = heightMeasureMode;
+ newCacheEntry.computedWidth = layout.measuredDimensions[DIMENSION_WIDTH];
+ newCacheEntry.computedHeight = layout.measuredDimensions[DIMENSION_HEIGHT];
+ }
+ }
+
+ if (performLayout) {
+ node.layout.dimensions[DIMENSION_WIDTH] = node.layout.measuredDimensions[DIMENSION_WIDTH];
+ node.layout.dimensions[DIMENSION_HEIGHT] = node.layout.measuredDimensions[DIMENSION_HEIGHT];
+ node.markHasNewLayout();
+ }
+
+ layout.generationCount = layoutContext.currentGenerationCount;
+ return (needToVisitNode || cachedResults == null);
+ }
+
+
+ //
+ // This is the main routine that implements a subset of the flexbox layout algorithm
+ // described in the W3C CSS documentation: https://www.w3.org/TR/css3-flexbox/.
+ //
+ // Limitations of this algorithm, compared to the full standard:
+ // * Display property is always assumed to be 'flex' except for Text nodes, which
+ // are assumed to be 'inline-flex'.
+ // * The 'zIndex' property (or any form of z ordering) is not supported. Nodes are
+ // stacked in document order.
+ // * The 'order' property is not supported. The order of flex items is always defined
+ // by document order.
+ // * The 'visibility' property is always assumed to be 'visible'. Values of 'collapse'
+ // and 'hidden' are not supported.
+ // * The 'wrap' property supports only 'nowrap' (which is the default) or 'wrap'. The
+ // rarely-used 'wrap-reverse' is not supported.
+ // * Rather than allowing arbitrary combinations of flexGrow, flexShrink and
+ // flexBasis, this algorithm supports only the three most common combinations:
+ // flex: 0 is equiavlent to flex: 0 0 auto
+ // flex: n (where n is a positive value) is equivalent to flex: n 1 auto
+ // If POSITIVE_FLEX_IS_AUTO is 0, then it is equivalent to flex: n 0 0
+ // This is faster because the content doesn't need to be measured, but it's
+ // less flexible because the basis is always 0 and can't be overriden with
+ // the width/height attributes.
+ // flex: -1 (or any negative value) is equivalent to flex: 0 1 auto
+ // * Margins cannot be specified as 'auto'. They must be specified in terms of pixel
+ // values, and the default value is 0.
+ // * The 'baseline' value is not supported for alignItems and alignSelf properties.
+ // * Values of width, maxWidth, minWidth, height, maxHeight and minHeight must be
+ // specified as pixel values, not as percentages.
+ // * There is no support for calculation of dimensions based on intrinsic aspect ratios
+ // (e.g. images).
+ // * There is no support for forced breaks.
+ // * It does not support vertical inline directions (top-to-bottom or bottom-to-top text).
+ //
+ // Deviations from standard:
+ // * Section 4.5 of the spec indicates that all flex items have a default minimum
+ // main size. For text blocks, for example, this is the width of the widest word.
+ // Calculating the minimum width is expensive, so we forego it and assume a default
+ // minimum main size of 0.
+ // * Min/Max sizes in the main axis are not honored when resolving flexible lengths.
+ // * The spec indicates that the default value for 'flexDirection' is 'row', but
+ // the algorithm below assumes a default of 'column'.
+ //
+ // Input parameters:
+ // - node: current node to be sized and layed out
+ // - availableWidth & availableHeight: available size to be used for sizing the node
+ // or CSS_UNDEFINED if the size is not available; interpretation depends on layout
+ // flags
+ // - parentDirection: the inline (text) direction within the parent (left-to-right or
+ // right-to-left)
+ // - widthMeasureMode: indicates the sizing rules for the width (see below for explanation)
+ // - heightMeasureMode: indicates the sizing rules for the height (see below for explanation)
+ // - performLayout: specifies whether the caller is interested in just the dimensions
+ // of the node or it requires the entire node and its subtree to be layed out
+ // (with final positions)
+ //
+ // Details:
+ // This routine is called recursively to lay out subtrees of flexbox elements. It uses the
+ // information in node.style, which is treated as a read-only input. It is responsible for
+ // setting the layout.direction and layout.measured_dimensions fields for the input node as well
+ // as the layout.position and layout.line_index fields for its child nodes. The
+ // layout.measured_dimensions field includes any border or padding for the node but does
+ // not include margins.
+ //
+ // The spec describes four different layout modes: "fill available", "max content", "min content",
+ // and "fit content". Of these, we don't use "min content" because we don't support default
+ // minimum main sizes (see above for details). Each of our measure modes maps to a layout mode
+ // from the spec (https://www.w3.org/TR/css3-sizing/#terms):
+ // - CSS_MEASURE_MODE_UNDEFINED: max content
+ // - CSS_MEASURE_MODE_EXACTLY: fill available
+ // - CSS_MEASURE_MODE_AT_MOST: fit content
+ //
+ // When calling layoutNodeImpl and layoutNodeInternal, if the caller passes an available size of
+ // undefined then it must also pass a measure mode of CSS_MEASURE_MODE_UNDEFINED in that dimension.
+ //
+ private static void layoutNodeImpl(
+ CSSLayoutContext layoutContext,
+ CSSNode node,
+ float availableWidth,
+ float availableHeight,
+ CSSDirection parentDirection,
+ CSSMeasureMode widthMeasureMode,
+ CSSMeasureMode heightMeasureMode,
+ boolean performLayout) {
+
+ Assertions.assertCondition(Float.isNaN(availableWidth) ? widthMeasureMode == CSSMeasureMode.UNDEFINED : true, "availableWidth is indefinite so widthMeasureMode must be CSSMeasureMode.UNDEFINED");
+ Assertions.assertCondition(Float.isNaN(availableHeight) ? heightMeasureMode == CSSMeasureMode.UNDEFINED : true, "availableHeight is indefinite so heightMeasureMode must be CSSMeasureMode.UNDEFINED");
+
+ float paddingAndBorderAxisRow = ((node.style.padding.getWithFallback(leadingSpacing[CSS_FLEX_DIRECTION_ROW], leading[CSS_FLEX_DIRECTION_ROW]) + node.style.border.getWithFallback(leadingSpacing[CSS_FLEX_DIRECTION_ROW], leading[CSS_FLEX_DIRECTION_ROW])) + (node.style.padding.getWithFallback(trailingSpacing[CSS_FLEX_DIRECTION_ROW], trailing[CSS_FLEX_DIRECTION_ROW]) + node.style.border.getWithFallback(trailingSpacing[CSS_FLEX_DIRECTION_ROW], trailing[CSS_FLEX_DIRECTION_ROW])));
+ float paddingAndBorderAxisColumn = ((node.style.padding.getWithFallback(leadingSpacing[CSS_FLEX_DIRECTION_COLUMN], leading[CSS_FLEX_DIRECTION_COLUMN]) + node.style.border.getWithFallback(leadingSpacing[CSS_FLEX_DIRECTION_COLUMN], leading[CSS_FLEX_DIRECTION_COLUMN])) + (node.style.padding.getWithFallback(trailingSpacing[CSS_FLEX_DIRECTION_COLUMN], trailing[CSS_FLEX_DIRECTION_COLUMN]) + node.style.border.getWithFallback(trailingSpacing[CSS_FLEX_DIRECTION_COLUMN], trailing[CSS_FLEX_DIRECTION_COLUMN])));
+ float marginAxisRow = (node.style.margin.getWithFallback(leadingSpacing[CSS_FLEX_DIRECTION_ROW], leading[CSS_FLEX_DIRECTION_ROW]) + node.style.margin.getWithFallback(trailingSpacing[CSS_FLEX_DIRECTION_ROW], trailing[CSS_FLEX_DIRECTION_ROW]));
+ float marginAxisColumn = (node.style.margin.getWithFallback(leadingSpacing[CSS_FLEX_DIRECTION_COLUMN], leading[CSS_FLEX_DIRECTION_COLUMN]) + node.style.margin.getWithFallback(trailingSpacing[CSS_FLEX_DIRECTION_COLUMN], trailing[CSS_FLEX_DIRECTION_COLUMN]));
+
+ // Set the resolved resolution in the node's layout.
+ CSSDirection direction = resolveDirection(node, parentDirection);
+ node.layout.direction = direction;
+
+ // For content (text) nodes, determine the dimensions based on the text contents.
+ if (isMeasureDefined(node)) {
+ float innerWidth = availableWidth - marginAxisRow - paddingAndBorderAxisRow;
+ float innerHeight = availableHeight - marginAxisColumn - paddingAndBorderAxisColumn;
+
+ if (widthMeasureMode == CSSMeasureMode.EXACTLY && heightMeasureMode == CSSMeasureMode.EXACTLY) {
+
+ // Don't bother sizing the text if both dimensions are already defined.
+ node.layout.measuredDimensions[DIMENSION_WIDTH] = boundAxis(node, CSS_FLEX_DIRECTION_ROW, availableWidth - marginAxisRow);
+ node.layout.measuredDimensions[DIMENSION_HEIGHT] = boundAxis(node, CSS_FLEX_DIRECTION_COLUMN, availableHeight - marginAxisColumn);
+ } else if (innerWidth <= 0 || innerHeight <= 0) {
+
+ // Don't bother sizing the text if there's no horizontal or vertical space.
+ node.layout.measuredDimensions[DIMENSION_WIDTH] = boundAxis(node, CSS_FLEX_DIRECTION_ROW, 0);
+ node.layout.measuredDimensions[DIMENSION_HEIGHT] = boundAxis(node, CSS_FLEX_DIRECTION_COLUMN, 0);
+ } else {
+
+ // Measure the text under the current constraints.
+ MeasureOutput measureDim = node.measure(
+
+ layoutContext.measureOutput,
+ innerWidth,
+ widthMeasureMode,
+ innerHeight,
+ heightMeasureMode
+ );
+
+ node.layout.measuredDimensions[DIMENSION_WIDTH] = boundAxis(node, CSS_FLEX_DIRECTION_ROW,
+ (widthMeasureMode == CSSMeasureMode.UNDEFINED || widthMeasureMode == CSSMeasureMode.AT_MOST) ?
+ measureDim.width + paddingAndBorderAxisRow :
+ availableWidth - marginAxisRow);
+ node.layout.measuredDimensions[DIMENSION_HEIGHT] = boundAxis(node, CSS_FLEX_DIRECTION_COLUMN,
+ (heightMeasureMode == CSSMeasureMode.UNDEFINED || heightMeasureMode == CSSMeasureMode.AT_MOST) ?
+ measureDim.height + paddingAndBorderAxisColumn :
+ availableHeight - marginAxisColumn);
+ }
+
+ return;
+ }
+
+ // For nodes with no children, use the available values if they were provided, or
+ // the minimum size as indicated by the padding and border sizes.
+ int childCount = node.getChildCount();
+ if (childCount == 0) {
+ node.layout.measuredDimensions[DIMENSION_WIDTH] = boundAxis(node, CSS_FLEX_DIRECTION_ROW,
+ (widthMeasureMode == CSSMeasureMode.UNDEFINED || widthMeasureMode == CSSMeasureMode.AT_MOST) ?
+ paddingAndBorderAxisRow :
+ availableWidth - marginAxisRow);
+ node.layout.measuredDimensions[DIMENSION_HEIGHT] = boundAxis(node, CSS_FLEX_DIRECTION_COLUMN,
+ (heightMeasureMode == CSSMeasureMode.UNDEFINED || heightMeasureMode == CSSMeasureMode.AT_MOST) ?
+ paddingAndBorderAxisColumn :
+ availableHeight - marginAxisColumn);
+ return;
+ }
+
+ // If we're not being asked to perform a full layout, we can handle a number of common
+ // cases here without incurring the cost of the remaining function.
+ if (!performLayout) {
+ // If we're being asked to size the content with an at most constraint but there is no available width,
+ // the measurement will always be zero.
+ if (widthMeasureMode == CSSMeasureMode.AT_MOST && availableWidth <= 0 &&
+ heightMeasureMode == CSSMeasureMode.AT_MOST && availableHeight <= 0) {
+ node.layout.measuredDimensions[DIMENSION_WIDTH] = boundAxis(node, CSS_FLEX_DIRECTION_ROW, 0);
+ node.layout.measuredDimensions[DIMENSION_HEIGHT] = boundAxis(node, CSS_FLEX_DIRECTION_COLUMN, 0);
+ return;
+ }
+
+ if (widthMeasureMode == CSSMeasureMode.AT_MOST && availableWidth <= 0) {
+ node.layout.measuredDimensions[DIMENSION_WIDTH] = boundAxis(node, CSS_FLEX_DIRECTION_ROW, 0);
+ node.layout.measuredDimensions[DIMENSION_HEIGHT] = boundAxis(node, CSS_FLEX_DIRECTION_COLUMN, Float.isNaN(availableHeight) ? 0 : (availableHeight - marginAxisColumn));
+ return;
+ }
+
+ if (heightMeasureMode == CSSMeasureMode.AT_MOST && availableHeight <= 0) {
+ node.layout.measuredDimensions[DIMENSION_WIDTH] = boundAxis(node, CSS_FLEX_DIRECTION_ROW, Float.isNaN(availableWidth) ? 0 : (availableWidth - marginAxisRow));
+ node.layout.measuredDimensions[DIMENSION_HEIGHT] = boundAxis(node, CSS_FLEX_DIRECTION_COLUMN, 0);
+ return;
+ }
+
+ // If we're being asked to use an exact width/height, there's no need to measure the children.
+ if (widthMeasureMode == CSSMeasureMode.EXACTLY && heightMeasureMode == CSSMeasureMode.EXACTLY) {
+ node.layout.measuredDimensions[DIMENSION_WIDTH] = boundAxis(node, CSS_FLEX_DIRECTION_ROW, availableWidth - marginAxisRow);
+ node.layout.measuredDimensions[DIMENSION_HEIGHT] = boundAxis(node, CSS_FLEX_DIRECTION_COLUMN, availableHeight - marginAxisColumn);
+ return;
+ }
+ }
+
+ // STEP 1: CALCULATE VALUES FOR REMAINDER OF ALGORITHM
+ int mainAxis = resolveAxis(getFlexDirection(node), direction);
+ int crossAxis = getCrossFlexDirection(mainAxis, direction);
+ boolean isMainAxisRow = (mainAxis == CSS_FLEX_DIRECTION_ROW || mainAxis == CSS_FLEX_DIRECTION_ROW_REVERSE);
+ CSSJustify justifyContent = node.style.justifyContent;
+ boolean isNodeFlexWrap = (node.style.flexWrap == CSSWrap.WRAP);
+
+ CSSNode firstAbsoluteChild = null;
+ CSSNode currentAbsoluteChild = null;
+
+ float leadingPaddingAndBorderMain = (node.style.padding.getWithFallback(leadingSpacing[mainAxis], leading[mainAxis]) + node.style.border.getWithFallback(leadingSpacing[mainAxis], leading[mainAxis]));
+ float trailingPaddingAndBorderMain = (node.style.padding.getWithFallback(trailingSpacing[mainAxis], trailing[mainAxis]) + node.style.border.getWithFallback(trailingSpacing[mainAxis], trailing[mainAxis]));
+ float leadingPaddingAndBorderCross = (node.style.padding.getWithFallback(leadingSpacing[crossAxis], leading[crossAxis]) + node.style.border.getWithFallback(leadingSpacing[crossAxis], leading[crossAxis]));
+ float paddingAndBorderAxisMain = ((node.style.padding.getWithFallback(leadingSpacing[mainAxis], leading[mainAxis]) + node.style.border.getWithFallback(leadingSpacing[mainAxis], leading[mainAxis])) + (node.style.padding.getWithFallback(trailingSpacing[mainAxis], trailing[mainAxis]) + node.style.border.getWithFallback(trailingSpacing[mainAxis], trailing[mainAxis])));
+ float paddingAndBorderAxisCross = ((node.style.padding.getWithFallback(leadingSpacing[crossAxis], leading[crossAxis]) + node.style.border.getWithFallback(leadingSpacing[crossAxis], leading[crossAxis])) + (node.style.padding.getWithFallback(trailingSpacing[crossAxis], trailing[crossAxis]) + node.style.border.getWithFallback(trailingSpacing[crossAxis], trailing[crossAxis])));
+
+ CSSMeasureMode measureModeMainDim = isMainAxisRow ? widthMeasureMode : heightMeasureMode;
+ CSSMeasureMode measureModeCrossDim = isMainAxisRow ? heightMeasureMode : widthMeasureMode;
+
+ // STEP 2: DETERMINE AVAILABLE SIZE IN MAIN AND CROSS DIRECTIONS
+ float availableInnerWidth = availableWidth - marginAxisRow - paddingAndBorderAxisRow;
+ float availableInnerHeight = availableHeight - marginAxisColumn - paddingAndBorderAxisColumn;
+ float availableInnerMainDim = isMainAxisRow ? availableInnerWidth : availableInnerHeight;
+ float availableInnerCrossDim = isMainAxisRow ? availableInnerHeight : availableInnerWidth;
+
+ // STEP 3: DETERMINE FLEX BASIS FOR EACH ITEM
+ CSSNode child;
+ int i;
+ float childWidth;
+ float childHeight;
+ CSSMeasureMode childWidthMeasureMode;
+ CSSMeasureMode childHeightMeasureMode;
+ for (i = 0; i < childCount; i++) {
+ child = node.getChildAt(i);
+
+ if (performLayout) {
+ // Set the initial position (relative to the parent).
+ CSSDirection childDirection = resolveDirection(child, direction);
+ setPosition(child, childDirection);
+ }
+
+ // Absolute-positioned children don't participate in flex layout. Add them
+ // to a list that we can process later.
+ if (child.style.positionType == CSSPositionType.ABSOLUTE) {
+
+ // Store a private linked list of absolutely positioned children
+ // so that we can efficiently traverse them later.
+ if (firstAbsoluteChild == null) {
+ firstAbsoluteChild = child;
+ }
+ if (currentAbsoluteChild != null) {
+ currentAbsoluteChild.nextChild = child;
+ }
+ currentAbsoluteChild = child;
+ child.nextChild = null;
+ } else {
+
+ if (isMainAxisRow && (child.style.dimensions[dim[CSS_FLEX_DIRECTION_ROW]] >= 0.0)) {
+
+ // The width is definite, so use that as the flex basis.
+ child.layout.flexBasis = Math.max(child.style.dimensions[DIMENSION_WIDTH], ((child.style.padding.getWithFallback(leadingSpacing[CSS_FLEX_DIRECTION_ROW], leading[CSS_FLEX_DIRECTION_ROW]) + child.style.border.getWithFallback(leadingSpacing[CSS_FLEX_DIRECTION_ROW], leading[CSS_FLEX_DIRECTION_ROW])) + (child.style.padding.getWithFallback(trailingSpacing[CSS_FLEX_DIRECTION_ROW], trailing[CSS_FLEX_DIRECTION_ROW]) + child.style.border.getWithFallback(trailingSpacing[CSS_FLEX_DIRECTION_ROW], trailing[CSS_FLEX_DIRECTION_ROW]))));
+ } else if (!isMainAxisRow && (child.style.dimensions[dim[CSS_FLEX_DIRECTION_COLUMN]] >= 0.0)) {
+
+ // The height is definite, so use that as the flex basis.
+ child.layout.flexBasis = Math.max(child.style.dimensions[DIMENSION_HEIGHT], ((child.style.padding.getWithFallback(leadingSpacing[CSS_FLEX_DIRECTION_COLUMN], leading[CSS_FLEX_DIRECTION_COLUMN]) + child.style.border.getWithFallback(leadingSpacing[CSS_FLEX_DIRECTION_COLUMN], leading[CSS_FLEX_DIRECTION_COLUMN])) + (child.style.padding.getWithFallback(trailingSpacing[CSS_FLEX_DIRECTION_COLUMN], trailing[CSS_FLEX_DIRECTION_COLUMN]) + child.style.border.getWithFallback(trailingSpacing[CSS_FLEX_DIRECTION_COLUMN], trailing[CSS_FLEX_DIRECTION_COLUMN]))));
+ } else if (!isFlexBasisAuto(child) && !Float.isNaN(availableInnerMainDim)) {
+
+ // If the basis isn't 'auto', it is assumed to be zero.
+ child.layout.flexBasis = Math.max(0, ((child.style.padding.getWithFallback(leadingSpacing[mainAxis], leading[mainAxis]) + child.style.border.getWithFallback(leadingSpacing[mainAxis], leading[mainAxis])) + (child.style.padding.getWithFallback(trailingSpacing[mainAxis], trailing[mainAxis]) + child.style.border.getWithFallback(trailingSpacing[mainAxis], trailing[mainAxis]))));
+ } else {
+
+ // Compute the flex basis and hypothetical main size (i.e. the clamped flex basis).
+ childWidth = CSSConstants.UNDEFINED;
+ childHeight = CSSConstants.UNDEFINED;
+ childWidthMeasureMode = CSSMeasureMode.UNDEFINED;
+ childHeightMeasureMode = CSSMeasureMode.UNDEFINED;
+
+ if ((child.style.dimensions[dim[CSS_FLEX_DIRECTION_ROW]] >= 0.0)) {
+ childWidth = child.style.dimensions[DIMENSION_WIDTH] + (child.style.margin.getWithFallback(leadingSpacing[CSS_FLEX_DIRECTION_ROW], leading[CSS_FLEX_DIRECTION_ROW]) + child.style.margin.getWithFallback(trailingSpacing[CSS_FLEX_DIRECTION_ROW], trailing[CSS_FLEX_DIRECTION_ROW]));
+ childWidthMeasureMode = CSSMeasureMode.EXACTLY;
+ }
+ if ((child.style.dimensions[dim[CSS_FLEX_DIRECTION_COLUMN]] >= 0.0)) {
+ childHeight = child.style.dimensions[DIMENSION_HEIGHT] + (child.style.margin.getWithFallback(leadingSpacing[CSS_FLEX_DIRECTION_COLUMN], leading[CSS_FLEX_DIRECTION_COLUMN]) + child.style.margin.getWithFallback(trailingSpacing[CSS_FLEX_DIRECTION_COLUMN], trailing[CSS_FLEX_DIRECTION_COLUMN]));
+ childHeightMeasureMode = CSSMeasureMode.EXACTLY;
+ }
+
+ // According to the spec, if the main size is not definite and the
+ // child's inline axis is parallel to the main axis (i.e. it's
+ // horizontal), the child should be sized using "UNDEFINED" in
+ // the main size. Otherwise use "AT_MOST" in the cross axis.
+ if (!isMainAxisRow && Float.isNaN(childWidth) && !Float.isNaN(availableInnerWidth)) {
+ childWidth = availableInnerWidth;
+ childWidthMeasureMode = CSSMeasureMode.AT_MOST;
+ }
+
+ // The W3C spec doesn't say anything about the 'overflow' property,
+ // but all major browsers appear to implement the following logic.
+ if (node.style.overflow == CSSOverflow.HIDDEN) {
+ if (isMainAxisRow && Float.isNaN(childHeight) && !Float.isNaN(availableInnerHeight)) {
+ childHeight = availableInnerHeight;
+ childHeightMeasureMode = CSSMeasureMode.AT_MOST;
+ }
+ }
+
+ // If child has no defined size in the cross axis and is set to stretch, set the cross
+ // axis to be measured exactly with the available inner width
+ if (!isMainAxisRow &&
+ !Float.isNaN(availableInnerWidth) &&
+ !(child.style.dimensions[dim[CSS_FLEX_DIRECTION_ROW]] >= 0.0) &&
+ widthMeasureMode == CSSMeasureMode.EXACTLY &&
+ getAlignItem(node, child) == CSSAlign.STRETCH) {
+ childWidth = availableInnerWidth;
+ childWidthMeasureMode = CSSMeasureMode.EXACTLY;
+ }
+ if (isMainAxisRow &&
+ !Float.isNaN(availableInnerHeight) &&
+ !(child.style.dimensions[dim[CSS_FLEX_DIRECTION_COLUMN]] >= 0.0) &&
+ heightMeasureMode == CSSMeasureMode.EXACTLY &&
+ getAlignItem(node, child) == CSSAlign.STRETCH) {
+ childHeight = availableInnerHeight;
+ childHeightMeasureMode = CSSMeasureMode.EXACTLY;
+ }
+
+ // Measure the child
+ layoutNodeInternal(layoutContext, child, childWidth, childHeight, direction, childWidthMeasureMode, childHeightMeasureMode, false, "measure");
+
+ child.layout.flexBasis = Math.max(isMainAxisRow ? child.layout.measuredDimensions[DIMENSION_WIDTH] : child.layout.measuredDimensions[DIMENSION_HEIGHT], ((child.style.padding.getWithFallback(leadingSpacing[mainAxis], leading[mainAxis]) + child.style.border.getWithFallback(leadingSpacing[mainAxis], leading[mainAxis])) + (child.style.padding.getWithFallback(trailingSpacing[mainAxis], trailing[mainAxis]) + child.style.border.getWithFallback(trailingSpacing[mainAxis], trailing[mainAxis]))));
+ }
+ }
+ }
+
+ // STEP 4: COLLECT FLEX ITEMS INTO FLEX LINES
+
+ // Indexes of children that represent the first and last items in the line.
+ int startOfLineIndex = 0;
+ int endOfLineIndex = 0;
+
+ // Number of lines.
+ int lineCount = 0;
+
+ // Accumulated cross dimensions of all lines so far.
+ float totalLineCrossDim = 0;
+
+ // Max main dimension of all the lines.
+ float maxLineMainDim = 0;
+
+ while (endOfLineIndex < childCount) {
+
+ // Number of items on the currently line. May be different than the difference
+ // between start and end indicates because we skip over absolute-positioned items.
+ int itemsOnLine = 0;
+
+ // sizeConsumedOnCurrentLine is accumulation of the dimensions and margin
+ // of all the children on the current line. This will be used in order to
+ // either set the dimensions of the node if none already exist or to compute
+ // the remaining space left for the flexible children.
+ float sizeConsumedOnCurrentLine = 0;
+
+ float totalFlexGrowFactors = 0;
+ float totalFlexShrinkScaledFactors = 0;
+
+ i = startOfLineIndex;
+
+ // Maintain a linked list of the child nodes that can shrink and/or grow.
+ CSSNode firstRelativeChild = null;
+ CSSNode currentRelativeChild = null;
+
+ // Add items to the current line until it's full or we run out of items.
+ while (i < childCount) {
+ child = node.getChildAt(i);
+ child.lineIndex = lineCount;
+
+ if (child.style.positionType != CSSPositionType.ABSOLUTE) {
+ float outerFlexBasis = child.layout.flexBasis + (child.style.margin.getWithFallback(leadingSpacing[mainAxis], leading[mainAxis]) + child.style.margin.getWithFallback(trailingSpacing[mainAxis], trailing[mainAxis]));
+
+ // If this is a multi-line flow and this item pushes us over the available size, we've
+ // hit the end of the current line. Break out of the loop and lay out the current line.
+ if (sizeConsumedOnCurrentLine + outerFlexBasis > availableInnerMainDim && isNodeFlexWrap && itemsOnLine > 0) {
+ break;
+ }
+
+ sizeConsumedOnCurrentLine += outerFlexBasis;
+ itemsOnLine++;
+
+ if ((child.style.positionType == CSSPositionType.RELATIVE && child.style.flex != 0)) {
+ totalFlexGrowFactors += getFlexGrowFactor(child);
+
+ // Unlike the grow factor, the shrink factor is scaled relative to the child
+ // dimension.
+ totalFlexShrinkScaledFactors += getFlexShrinkFactor(child) * child.layout.flexBasis;
+ }
+
+ // Store a private linked list of children that need to be layed out.
+ if (firstRelativeChild == null) {
+ firstRelativeChild = child;
+ }
+ if (currentRelativeChild != null) {
+ currentRelativeChild.nextChild = child;
+ }
+ currentRelativeChild = child;
+ child.nextChild = null;
+ }
+
+ i++;
+ endOfLineIndex++;
+ }
+
+ // If we don't need to measure the cross axis, we can skip the entire flex step.
+ boolean canSkipFlex = !performLayout && measureModeCrossDim == CSSMeasureMode.EXACTLY;
+
+ // In order to position the elements in the main axis, we have two
+ // controls. The space between the beginning and the first element
+ // and the space between each two elements.
+ float leadingMainDim = 0;
+ float betweenMainDim = 0;
+
+ // STEP 5: RESOLVING FLEXIBLE LENGTHS ON MAIN AXIS
+ // Calculate the remaining available space that needs to be allocated.
+ // If the main dimension size isn't known, it is computed based on
+ // the line length, so there's no more space left to distribute.
+ float remainingFreeSpace = 0;
+ if (!Float.isNaN(availableInnerMainDim)) {
+ remainingFreeSpace = availableInnerMainDim - sizeConsumedOnCurrentLine;
+ } else if (sizeConsumedOnCurrentLine < 0) {
+ // availableInnerMainDim is indefinite which means the node is being sized based on its content.
+ // sizeConsumedOnCurrentLine is negative which means the node will allocate 0 pixels for
+ // its content. Consequently, remainingFreeSpace is 0 - sizeConsumedOnCurrentLine.
+ remainingFreeSpace = -sizeConsumedOnCurrentLine;
+ }
+
+ float originalRemainingFreeSpace = remainingFreeSpace;
+ float deltaFreeSpace = 0;
+
+ if (!canSkipFlex) {
+ float childFlexBasis;
+ float flexShrinkScaledFactor;
+ float flexGrowFactor;
+ float baseMainSize;
+ float boundMainSize;
+
+ // Do two passes over the flex items to figure out how to distribute the remaining space.
+ // The first pass finds the items whose min/max constraints trigger, freezes them at those
+ // sizes, and excludes those sizes from the remaining space. The second pass sets the size
+ // of each flexible item. It distributes the remaining space amongst the items whose min/max
+ // constraints didn't trigger in pass 1. For the other items, it sets their sizes by forcing
+ // their min/max constraints to trigger again.
+ //
+ // This two pass approach for resolving min/max constraints deviates from the spec. The
+ // spec (https://www.w3.org/TR/css-flexbox-1/#resolve-flexible-lengths) describes a process
+ // that needs to be repeated a variable number of times. The algorithm implemented here
+ // won't handle all cases but it was simpler to implement and it mitigates performance
+ // concerns because we know exactly how many passes it'll do.
+
+ // First pass: detect the flex items whose min/max constraints trigger
+ float deltaFlexShrinkScaledFactors = 0;
+ float deltaFlexGrowFactors = 0;
+ currentRelativeChild = firstRelativeChild;
+ while (currentRelativeChild != null) {
+ childFlexBasis = currentRelativeChild.layout.flexBasis;
+
+ if (remainingFreeSpace < 0) {
+ flexShrinkScaledFactor = getFlexShrinkFactor(currentRelativeChild) * childFlexBasis;
+
+ // Is this child able to shrink?
+ if (flexShrinkScaledFactor != 0) {
+ baseMainSize = childFlexBasis +
+ remainingFreeSpace / totalFlexShrinkScaledFactors * flexShrinkScaledFactor;
+ boundMainSize = boundAxis(currentRelativeChild, mainAxis, baseMainSize);
+ if (baseMainSize != boundMainSize) {
+ // By excluding this item's size and flex factor from remaining, this item's
+ // min/max constraints should also trigger in the second pass resulting in the
+ // item's size calculation being identical in the first and second passes.
+ deltaFreeSpace -= boundMainSize - childFlexBasis;
+ deltaFlexShrinkScaledFactors -= flexShrinkScaledFactor;
+ }
+ }
+ } else if (remainingFreeSpace > 0) {
+ flexGrowFactor = getFlexGrowFactor(currentRelativeChild);
+
+ // Is this child able to grow?
+ if (flexGrowFactor != 0) {
+ baseMainSize = childFlexBasis +
+ remainingFreeSpace / totalFlexGrowFactors * flexGrowFactor;
+ boundMainSize = boundAxis(currentRelativeChild, mainAxis, baseMainSize);
+ if (baseMainSize != boundMainSize) {
+ // By excluding this item's size and flex factor from remaining, this item's
+ // min/max constraints should also trigger in the second pass resulting in the
+ // item's size calculation being identical in the first and second passes.
+ deltaFreeSpace -= boundMainSize - childFlexBasis;
+ deltaFlexGrowFactors -= flexGrowFactor;
+ }
+ }
+ }
+
+ currentRelativeChild = currentRelativeChild.nextChild;
+ }
+
+ totalFlexShrinkScaledFactors += deltaFlexShrinkScaledFactors;
+ totalFlexGrowFactors += deltaFlexGrowFactors;
+ remainingFreeSpace += deltaFreeSpace;
+
+ // Second pass: resolve the sizes of the flexible items
+ deltaFreeSpace = 0;
+ currentRelativeChild = firstRelativeChild;
+ while (currentRelativeChild != null) {
+ childFlexBasis = currentRelativeChild.layout.flexBasis;
+ float updatedMainSize = childFlexBasis;
+
+ if (remainingFreeSpace < 0) {
+ flexShrinkScaledFactor = getFlexShrinkFactor(currentRelativeChild) * childFlexBasis;
+
+ // Is this child able to shrink?
+ if (flexShrinkScaledFactor != 0) {
+ updatedMainSize = boundAxis(currentRelativeChild, mainAxis, childFlexBasis +
+ remainingFreeSpace / totalFlexShrinkScaledFactors * flexShrinkScaledFactor);
+ }
+ } else if (remainingFreeSpace > 0) {
+ flexGrowFactor = getFlexGrowFactor(currentRelativeChild);
+
+ // Is this child able to grow?
+ if (flexGrowFactor != 0) {
+ updatedMainSize = boundAxis(currentRelativeChild, mainAxis, childFlexBasis +
+ remainingFreeSpace / totalFlexGrowFactors * flexGrowFactor);
+ }
+ }
+
+ deltaFreeSpace -= updatedMainSize - childFlexBasis;
+
+ if (isMainAxisRow) {
+ childWidth = updatedMainSize + (currentRelativeChild.style.margin.getWithFallback(leadingSpacing[CSS_FLEX_DIRECTION_ROW], leading[CSS_FLEX_DIRECTION_ROW]) + currentRelativeChild.style.margin.getWithFallback(trailingSpacing[CSS_FLEX_DIRECTION_ROW], trailing[CSS_FLEX_DIRECTION_ROW]));
+ childWidthMeasureMode = CSSMeasureMode.EXACTLY;
+
+ if (!Float.isNaN(availableInnerCrossDim) &&
+ !(currentRelativeChild.style.dimensions[dim[CSS_FLEX_DIRECTION_COLUMN]] >= 0.0) &&
+ heightMeasureMode == CSSMeasureMode.EXACTLY &&
+ getAlignItem(node, currentRelativeChild) == CSSAlign.STRETCH) {
+ childHeight = availableInnerCrossDim;
+ childHeightMeasureMode = CSSMeasureMode.EXACTLY;
+ } else if (!(currentRelativeChild.style.dimensions[dim[CSS_FLEX_DIRECTION_COLUMN]] >= 0.0)) {
+ childHeight = availableInnerCrossDim;
+ childHeightMeasureMode = Float.isNaN(childHeight) ? CSSMeasureMode.UNDEFINED : CSSMeasureMode.AT_MOST;
+ } else {
+ childHeight = currentRelativeChild.style.dimensions[DIMENSION_HEIGHT] + (currentRelativeChild.style.margin.getWithFallback(leadingSpacing[CSS_FLEX_DIRECTION_COLUMN], leading[CSS_FLEX_DIRECTION_COLUMN]) + currentRelativeChild.style.margin.getWithFallback(trailingSpacing[CSS_FLEX_DIRECTION_COLUMN], trailing[CSS_FLEX_DIRECTION_COLUMN]));
+ childHeightMeasureMode = CSSMeasureMode.EXACTLY;
+ }
+ } else {
+ childHeight = updatedMainSize + (currentRelativeChild.style.margin.getWithFallback(leadingSpacing[CSS_FLEX_DIRECTION_COLUMN], leading[CSS_FLEX_DIRECTION_COLUMN]) + currentRelativeChild.style.margin.getWithFallback(trailingSpacing[CSS_FLEX_DIRECTION_COLUMN], trailing[CSS_FLEX_DIRECTION_COLUMN]));
+ childHeightMeasureMode = CSSMeasureMode.EXACTLY;
+
+ if (!Float.isNaN(availableInnerCrossDim) &&
+ !(currentRelativeChild.style.dimensions[dim[CSS_FLEX_DIRECTION_ROW]] >= 0.0) &&
+ widthMeasureMode == CSSMeasureMode.EXACTLY &&
+ getAlignItem(node, currentRelativeChild) == CSSAlign.STRETCH) {
+ childWidth = availableInnerCrossDim;
+ childWidthMeasureMode = CSSMeasureMode.EXACTLY;
+ } else if (!(currentRelativeChild.style.dimensions[dim[CSS_FLEX_DIRECTION_ROW]] >= 0.0)) {
+ childWidth = availableInnerCrossDim;
+ childWidthMeasureMode = Float.isNaN(childWidth) ? CSSMeasureMode.UNDEFINED : CSSMeasureMode.AT_MOST;
+ } else {
+ childWidth = currentRelativeChild.style.dimensions[DIMENSION_WIDTH] + (currentRelativeChild.style.margin.getWithFallback(leadingSpacing[CSS_FLEX_DIRECTION_ROW], leading[CSS_FLEX_DIRECTION_ROW]) + currentRelativeChild.style.margin.getWithFallback(trailingSpacing[CSS_FLEX_DIRECTION_ROW], trailing[CSS_FLEX_DIRECTION_ROW]));
+ childWidthMeasureMode = CSSMeasureMode.EXACTLY;
+ }
+ }
+
+ boolean requiresStretchLayout = !(currentRelativeChild.style.dimensions[dim[crossAxis]] >= 0.0) &&
+ getAlignItem(node, currentRelativeChild) == CSSAlign.STRETCH;
+
+ // Recursively call the layout algorithm for this child with the updated main size.
+ layoutNodeInternal(layoutContext, currentRelativeChild, childWidth, childHeight, direction, childWidthMeasureMode, childHeightMeasureMode, performLayout && !requiresStretchLayout, "flex");
+
+ currentRelativeChild = currentRelativeChild.nextChild;
+ }
+ }
+
+ remainingFreeSpace = originalRemainingFreeSpace + deltaFreeSpace;
+
+ // STEP 6: MAIN-AXIS JUSTIFICATION & CROSS-AXIS SIZE DETERMINATION
+
+ // At this point, all the children have their dimensions set in the main axis.
+ // Their dimensions are also set in the cross axis with the exception of items
+ // that are aligned "stretch". We need to compute these stretch values and
+ // set the final positions.
+
+ // If we are using "at most" rules in the main axis, we won't distribute
+ // any remaining space at this point.
+ if (measureModeMainDim == CSSMeasureMode.AT_MOST) {
+ remainingFreeSpace = 0;
+ }
+
+ // Use justifyContent to figure out how to allocate the remaining space
+ // available in the main axis.
+ if (justifyContent != CSSJustify.FLEX_START) {
+ if (justifyContent == CSSJustify.CENTER) {
+ leadingMainDim = remainingFreeSpace / 2;
+ } else if (justifyContent == CSSJustify.FLEX_END) {
+ leadingMainDim = remainingFreeSpace;
+ } else if (justifyContent == CSSJustify.SPACE_BETWEEN) {
+ remainingFreeSpace = Math.max(remainingFreeSpace, 0);
+ if (itemsOnLine > 1) {
+ betweenMainDim = remainingFreeSpace / (itemsOnLine - 1);
+ } else {
+ betweenMainDim = 0;
+ }
+ } else if (justifyContent == CSSJustify.SPACE_AROUND) {
+ // Space on the edges is half of the space between elements
+ betweenMainDim = remainingFreeSpace / itemsOnLine;
+ leadingMainDim = betweenMainDim / 2;
+ }
+ }
+
+ float mainDim = leadingPaddingAndBorderMain + leadingMainDim;
+ float crossDim = 0;
+
+ for (i = startOfLineIndex; i < endOfLineIndex; ++i) {
+ child = node.getChildAt(i);
+
+ if (child.style.positionType == CSSPositionType.ABSOLUTE &&
+ !Float.isNaN(child.style.position[leading[mainAxis]])) {
+ if (performLayout) {
+ // In case the child is position absolute and has left/top being
+ // defined, we override the position to whatever the user said
+ // (and margin/border).
+ child.layout.position[pos[mainAxis]] = (Float.isNaN(child.style.position[leading[mainAxis]]) ? 0 : child.style.position[leading[mainAxis]]) +
+ node.style.border.getWithFallback(leadingSpacing[mainAxis], leading[mainAxis]) +
+ child.style.margin.getWithFallback(leadingSpacing[mainAxis], leading[mainAxis]);
+ }
+ } else {
+ if (performLayout) {
+ // If the child is position absolute (without top/left) or relative,
+ // we put it at the current accumulated offset.
+ child.layout.position[pos[mainAxis]] += mainDim;
+ }
+
+ // Now that we placed the element, we need to update the variables.
+ // We need to do that only for relative elements. Absolute elements
+ // do not take part in that phase.
+ if (child.style.positionType == CSSPositionType.RELATIVE) {
+ if (canSkipFlex) {
+ // If we skipped the flex step, then we can't rely on the measuredDims because
+ // they weren't computed. This means we can't call getDimWithMargin.
+ mainDim += betweenMainDim + (child.style.margin.getWithFallback(leadingSpacing[mainAxis], leading[mainAxis]) + child.style.margin.getWithFallback(trailingSpacing[mainAxis], trailing[mainAxis])) + child.layout.flexBasis;
+ crossDim = availableInnerCrossDim;
+ } else {
+ // The main dimension is the sum of all the elements dimension plus
+ // the spacing.
+ mainDim += betweenMainDim + (child.layout.measuredDimensions[dim[mainAxis]] + child.style.margin.getWithFallback(leadingSpacing[mainAxis], leading[mainAxis]) + child.style.margin.getWithFallback(trailingSpacing[mainAxis], trailing[mainAxis]));
+
+ // The cross dimension is the max of the elements dimension since there
+ // can only be one element in that cross dimension.
+ crossDim = Math.max(crossDim, (child.layout.measuredDimensions[dim[crossAxis]] + child.style.margin.getWithFallback(leadingSpacing[crossAxis], leading[crossAxis]) + child.style.margin.getWithFallback(trailingSpacing[crossAxis], trailing[crossAxis])));
+ }
+ }
+ }
+ }
+
+ mainDim += trailingPaddingAndBorderMain;
+
+ float containerCrossAxis = availableInnerCrossDim;
+ if (measureModeCrossDim == CSSMeasureMode.UNDEFINED || measureModeCrossDim == CSSMeasureMode.AT_MOST) {
+ // Compute the cross axis from the max cross dimension of the children.
+ containerCrossAxis = boundAxis(node, crossAxis, crossDim + paddingAndBorderAxisCross) - paddingAndBorderAxisCross;
+
+ if (measureModeCrossDim == CSSMeasureMode.AT_MOST) {
+ containerCrossAxis = Math.min(containerCrossAxis, availableInnerCrossDim);
+ }
+ }
+
+ // If there's no flex wrap, the cross dimension is defined by the container.
+ if (!isNodeFlexWrap && measureModeCrossDim == CSSMeasureMode.EXACTLY) {
+ crossDim = availableInnerCrossDim;
+ }
+
+ // Clamp to the min/max size specified on the container.
+ crossDim = boundAxis(node, crossAxis, crossDim + paddingAndBorderAxisCross) - paddingAndBorderAxisCross;
+
+ // STEP 7: CROSS-AXIS ALIGNMENT
+ // We can skip child alignment if we're just measuring the container.
+ if (performLayout) {
+ for (i = startOfLineIndex; i < endOfLineIndex; ++i) {
+ child = node.getChildAt(i);
+
+ if (child.style.positionType == CSSPositionType.ABSOLUTE) {
+ // If the child is absolutely positioned and has a top/left/bottom/right
+ // set, override all the previously computed positions to set it correctly.
+ if (!Float.isNaN(child.style.position[leading[crossAxis]])) {
+ child.layout.position[pos[crossAxis]] = (Float.isNaN(child.style.position[leading[crossAxis]]) ? 0 : child.style.position[leading[crossAxis]]) +
+ node.style.border.getWithFallback(leadingSpacing[crossAxis], leading[crossAxis]) +
+ child.style.margin.getWithFallback(leadingSpacing[crossAxis], leading[crossAxis]);
+ } else {
+ child.layout.position[pos[crossAxis]] = leadingPaddingAndBorderCross +
+ child.style.margin.getWithFallback(leadingSpacing[crossAxis], leading[crossAxis]);
+ }
+ } else {
+ float leadingCrossDim = leadingPaddingAndBorderCross;
+
+ // For a relative children, we're either using alignItems (parent) or
+ // alignSelf (child) in order to determine the position in the cross axis
+ CSSAlign alignItem = getAlignItem(node, child);
+
+ // If the child uses align stretch, we need to lay it out one more time, this time
+ // forcing the cross-axis size to be the computed cross size for the current line.
+ if (alignItem == CSSAlign.STRETCH) {
+ childWidth = child.layout.measuredDimensions[DIMENSION_WIDTH] + (child.style.margin.getWithFallback(leadingSpacing[CSS_FLEX_DIRECTION_ROW], leading[CSS_FLEX_DIRECTION_ROW]) + child.style.margin.getWithFallback(trailingSpacing[CSS_FLEX_DIRECTION_ROW], trailing[CSS_FLEX_DIRECTION_ROW]));
+ childHeight = child.layout.measuredDimensions[DIMENSION_HEIGHT] + (child.style.margin.getWithFallback(leadingSpacing[CSS_FLEX_DIRECTION_COLUMN], leading[CSS_FLEX_DIRECTION_COLUMN]) + child.style.margin.getWithFallback(trailingSpacing[CSS_FLEX_DIRECTION_COLUMN], trailing[CSS_FLEX_DIRECTION_COLUMN]));
+ boolean isCrossSizeDefinite = false;
+
+ if (isMainAxisRow) {
+ isCrossSizeDefinite = (child.style.dimensions[dim[CSS_FLEX_DIRECTION_COLUMN]] >= 0.0);
+ childHeight = crossDim;
+ } else {
+ isCrossSizeDefinite = (child.style.dimensions[dim[CSS_FLEX_DIRECTION_ROW]] >= 0.0);
+ childWidth = crossDim;
+ }
+
+ // If the child defines a definite size for its cross axis, there's no need to stretch.
+ if (!isCrossSizeDefinite) {
+ childWidthMeasureMode = Float.isNaN(childWidth) ? CSSMeasureMode.UNDEFINED : CSSMeasureMode.EXACTLY;
+ childHeightMeasureMode = Float.isNaN(childHeight) ? CSSMeasureMode.UNDEFINED : CSSMeasureMode.EXACTLY;
+ layoutNodeInternal(layoutContext, child, childWidth, childHeight, direction, childWidthMeasureMode, childHeightMeasureMode, true, "stretch");
+ }
+ } else if (alignItem != CSSAlign.FLEX_START) {
+ float remainingCrossDim = containerCrossAxis - (child.layout.measuredDimensions[dim[crossAxis]] + child.style.margin.getWithFallback(leadingSpacing[crossAxis], leading[crossAxis]) + child.style.margin.getWithFallback(trailingSpacing[crossAxis], trailing[crossAxis]));
+
+ if (alignItem == CSSAlign.CENTER) {
+ leadingCrossDim += remainingCrossDim / 2;
+ } else { // CSSAlign.FLEX_END
+ leadingCrossDim += remainingCrossDim;
+ }
+ }
+
+ // And we apply the position
+ child.layout.position[pos[crossAxis]] += totalLineCrossDim + leadingCrossDim;
+ }
+ }
+ }
+
+ totalLineCrossDim += crossDim;
+ maxLineMainDim = Math.max(maxLineMainDim, mainDim);
+
+ // Reset variables for new line.
+ lineCount++;
+ startOfLineIndex = endOfLineIndex;
+ endOfLineIndex = startOfLineIndex;
+ }
+
+ // STEP 8: MULTI-LINE CONTENT ALIGNMENT
+ if (lineCount > 1 && performLayout && !Float.isNaN(availableInnerCrossDim)) {
+ float remainingAlignContentDim = availableInnerCrossDim - totalLineCrossDim;
+
+ float crossDimLead = 0;
+ float currentLead = leadingPaddingAndBorderCross;
+
+ CSSAlign alignContent = node.style.alignContent;
+ if (alignContent == CSSAlign.FLEX_END) {
+ currentLead += remainingAlignContentDim;
+ } else if (alignContent == CSSAlign.CENTER) {
+ currentLead += remainingAlignContentDim / 2;
+ } else if (alignContent == CSSAlign.STRETCH) {
+ if (availableInnerCrossDim > totalLineCrossDim) {
+ crossDimLead = (remainingAlignContentDim / lineCount);
+ }
+ }
+
+ int endIndex = 0;
+ for (i = 0; i < lineCount; ++i) {
+ int startIndex = endIndex;
+ int j;
+
+ // compute the line's height and find the endIndex
+ float lineHeight = 0;
+ for (j = startIndex; j < childCount; ++j) {
+ child = node.getChildAt(j);
+ if (child.style.positionType != CSSPositionType.RELATIVE) {
+ continue;
+ }
+ if (child.lineIndex != i) {
+ break;
+ }
+ if ((child.layout.measuredDimensions[dim[crossAxis]] >= 0.0)) {
+ lineHeight = Math.max(lineHeight,
+ child.layout.measuredDimensions[dim[crossAxis]] + (child.style.margin.getWithFallback(leadingSpacing[crossAxis], leading[crossAxis]) + child.style.margin.getWithFallback(trailingSpacing[crossAxis], trailing[crossAxis])));
+ }
+ }
+ endIndex = j;
+ lineHeight += crossDimLead;
+
+ if (performLayout) {
+ for (j = startIndex; j < endIndex; ++j) {
+ child = node.getChildAt(j);
+ if (child.style.positionType != CSSPositionType.RELATIVE) {
+ continue;
+ }
+
+ CSSAlign alignContentAlignItem = getAlignItem(node, child);
+ if (alignContentAlignItem == CSSAlign.FLEX_START) {
+ child.layout.position[pos[crossAxis]] = currentLead + child.style.margin.getWithFallback(leadingSpacing[crossAxis], leading[crossAxis]);
+ } else if (alignContentAlignItem == CSSAlign.FLEX_END) {
+ child.layout.position[pos[crossAxis]] = currentLead + lineHeight - child.style.margin.getWithFallback(trailingSpacing[crossAxis], trailing[crossAxis]) - child.layout.measuredDimensions[dim[crossAxis]];
+ } else if (alignContentAlignItem == CSSAlign.CENTER) {
+ childHeight = child.layout.measuredDimensions[dim[crossAxis]];
+ child.layout.position[pos[crossAxis]] = currentLead + (lineHeight - childHeight) / 2;
+ } else if (alignContentAlignItem == CSSAlign.STRETCH) {
+ child.layout.position[pos[crossAxis]] = currentLead + child.style.margin.getWithFallback(leadingSpacing[crossAxis], leading[crossAxis]);
+ // TODO(prenaux): Correctly set the height of items with indefinite
+ // (auto) crossAxis dimension.
+ }
+ }
+ }
+
+ currentLead += lineHeight;
+ }
+ }
+
+ // STEP 9: COMPUTING FINAL DIMENSIONS
+ node.layout.measuredDimensions[DIMENSION_WIDTH] = boundAxis(node, CSS_FLEX_DIRECTION_ROW, availableWidth - marginAxisRow);
+ node.layout.measuredDimensions[DIMENSION_HEIGHT] = boundAxis(node, CSS_FLEX_DIRECTION_COLUMN, availableHeight - marginAxisColumn);
+
+ // If the user didn't specify a width or height for the node, set the
+ // dimensions based on the children.
+ if (measureModeMainDim == CSSMeasureMode.UNDEFINED) {
+ // Clamp the size to the min/max size, if specified, and make sure it
+ // doesn't go below the padding and border amount.
+ node.layout.measuredDimensions[dim[mainAxis]] = boundAxis(node, mainAxis, maxLineMainDim);
+ } else if (measureModeMainDim == CSSMeasureMode.AT_MOST) {
+ node.layout.measuredDimensions[dim[mainAxis]] = Math.max(
+ Math.min(availableInnerMainDim + paddingAndBorderAxisMain,
+ boundAxisWithinMinAndMax(node, mainAxis, maxLineMainDim)),
+ paddingAndBorderAxisMain);
+ }
+
+ if (measureModeCrossDim == CSSMeasureMode.UNDEFINED) {
+ // Clamp the size to the min/max size, if specified, and make sure it
+ // doesn't go below the padding and border amount.
+ node.layout.measuredDimensions[dim[crossAxis]] = boundAxis(node, crossAxis, totalLineCrossDim + paddingAndBorderAxisCross);
+ } else if (measureModeCrossDim == CSSMeasureMode.AT_MOST) {
+ node.layout.measuredDimensions[dim[crossAxis]] = Math.max(
+ Math.min(availableInnerCrossDim + paddingAndBorderAxisCross,
+ boundAxisWithinMinAndMax(node, crossAxis, totalLineCrossDim + paddingAndBorderAxisCross)),
+ paddingAndBorderAxisCross);
+ }
+
+ // STEP 10: SETTING TRAILING POSITIONS FOR CHILDREN
+ if (performLayout) {
+ boolean needsMainTrailingPos = false;
+ boolean needsCrossTrailingPos = false;
+
+ if (mainAxis == CSS_FLEX_DIRECTION_ROW_REVERSE ||
+ mainAxis == CSS_FLEX_DIRECTION_COLUMN_REVERSE) {
+ needsMainTrailingPos = true;
+ }
+
+ if (crossAxis == CSS_FLEX_DIRECTION_ROW_REVERSE ||
+ crossAxis == CSS_FLEX_DIRECTION_COLUMN_REVERSE) {
+ needsCrossTrailingPos = true;
+ }
+
+ // Set trailing position if necessary.
+ if (needsMainTrailingPos || needsCrossTrailingPos) {
+ for (i = 0; i < childCount; ++i) {
+ child = node.getChildAt(i);
+
+ if (needsMainTrailingPos) {
+ child.layout.position[trailing[mainAxis]] = node.layout.measuredDimensions[dim[mainAxis]] - (child.style.positionType == CSSPositionType.ABSOLUTE ? 0 : child.layout.measuredDimensions[dim[mainAxis]]) - child.layout.position[pos[mainAxis]];
+ }
+
+ if (needsCrossTrailingPos) {
+ child.layout.position[trailing[crossAxis]] = node.layout.measuredDimensions[dim[crossAxis]] - (child.style.positionType == CSSPositionType.ABSOLUTE ? 0 : child.layout.measuredDimensions[dim[crossAxis]]) - child.layout.position[pos[crossAxis]];
+ }
+ }
+ }
+ }
+
+ // STEP 11: SIZING AND POSITIONING ABSOLUTE CHILDREN
+ currentAbsoluteChild = firstAbsoluteChild;
+ while (currentAbsoluteChild != null) {
+ // Now that we know the bounds of the container, perform layout again on the
+ // absolutely-positioned children.
+ if (performLayout) {
+
+ childWidth = CSSConstants.UNDEFINED;
+ childHeight = CSSConstants.UNDEFINED;
+
+ if ((currentAbsoluteChild.style.dimensions[dim[CSS_FLEX_DIRECTION_ROW]] >= 0.0)) {
+ childWidth = currentAbsoluteChild.style.dimensions[DIMENSION_WIDTH] + (currentAbsoluteChild.style.margin.getWithFallback(leadingSpacing[CSS_FLEX_DIRECTION_ROW], leading[CSS_FLEX_DIRECTION_ROW]) + currentAbsoluteChild.style.margin.getWithFallback(trailingSpacing[CSS_FLEX_DIRECTION_ROW], trailing[CSS_FLEX_DIRECTION_ROW]));
+ } else {
+ // If the child doesn't have a specified width, compute the width based on the left/right offsets if they're defined.
+ if (!Float.isNaN(currentAbsoluteChild.style.position[POSITION_LEFT]) && !Float.isNaN(currentAbsoluteChild.style.position[POSITION_RIGHT])) {
+ childWidth = node.layout.measuredDimensions[DIMENSION_WIDTH] -
+ (node.style.border.getWithFallback(leadingSpacing[CSS_FLEX_DIRECTION_ROW], leading[CSS_FLEX_DIRECTION_ROW]) + node.style.border.getWithFallback(trailingSpacing[CSS_FLEX_DIRECTION_ROW], trailing[CSS_FLEX_DIRECTION_ROW])) -
+ (currentAbsoluteChild.style.position[POSITION_LEFT] + currentAbsoluteChild.style.position[POSITION_RIGHT]);
+ childWidth = boundAxis(currentAbsoluteChild, CSS_FLEX_DIRECTION_ROW, childWidth);
+ }
+ }
+
+ if ((currentAbsoluteChild.style.dimensions[dim[CSS_FLEX_DIRECTION_COLUMN]] >= 0.0)) {
+ childHeight = currentAbsoluteChild.style.dimensions[DIMENSION_HEIGHT] + (currentAbsoluteChild.style.margin.getWithFallback(leadingSpacing[CSS_FLEX_DIRECTION_COLUMN], leading[CSS_FLEX_DIRECTION_COLUMN]) + currentAbsoluteChild.style.margin.getWithFallback(trailingSpacing[CSS_FLEX_DIRECTION_COLUMN], trailing[CSS_FLEX_DIRECTION_COLUMN]));
+ } else {
+ // If the child doesn't have a specified height, compute the height based on the top/bottom offsets if they're defined.
+ if (!Float.isNaN(currentAbsoluteChild.style.position[POSITION_TOP]) && !Float.isNaN(currentAbsoluteChild.style.position[POSITION_BOTTOM])) {
+ childHeight = node.layout.measuredDimensions[DIMENSION_HEIGHT] -
+ (node.style.border.getWithFallback(leadingSpacing[CSS_FLEX_DIRECTION_COLUMN], leading[CSS_FLEX_DIRECTION_COLUMN]) + node.style.border.getWithFallback(trailingSpacing[CSS_FLEX_DIRECTION_COLUMN], trailing[CSS_FLEX_DIRECTION_COLUMN])) -
+ (currentAbsoluteChild.style.position[POSITION_TOP] + currentAbsoluteChild.style.position[POSITION_BOTTOM]);
+ childHeight = boundAxis(currentAbsoluteChild, CSS_FLEX_DIRECTION_COLUMN, childHeight);
+ }
+ }
+
+ // If we're still missing one or the other dimension, measure the content.
+ if (Float.isNaN(childWidth) || Float.isNaN(childHeight)) {
+ childWidthMeasureMode = Float.isNaN(childWidth) ? CSSMeasureMode.UNDEFINED : CSSMeasureMode.EXACTLY;
+ childHeightMeasureMode = Float.isNaN(childHeight) ? CSSMeasureMode.UNDEFINED : CSSMeasureMode.EXACTLY;
+
+ // According to the spec, if the main size is not definite and the
+ // child's inline axis is parallel to the main axis (i.e. it's
+ // horizontal), the child should be sized using "UNDEFINED" in
+ // the main size. Otherwise use "AT_MOST" in the cross axis.
+ if (!isMainAxisRow && Float.isNaN(childWidth) && !Float.isNaN(availableInnerWidth)) {
+ childWidth = availableInnerWidth;
+ childWidthMeasureMode = CSSMeasureMode.AT_MOST;
+ }
+
+ // The W3C spec doesn't say anything about the 'overflow' property,
+ // but all major browsers appear to implement the following logic.
+ if (node.style.overflow == CSSOverflow.HIDDEN) {
+ if (isMainAxisRow && Float.isNaN(childHeight) && !Float.isNaN(availableInnerHeight)) {
+ childHeight = availableInnerHeight;
+ childHeightMeasureMode = CSSMeasureMode.AT_MOST;
+ }
+ }
+
+ layoutNodeInternal(layoutContext, currentAbsoluteChild, childWidth, childHeight, direction, childWidthMeasureMode, childHeightMeasureMode, false, "abs-measure");
+ childWidth = currentAbsoluteChild.layout.measuredDimensions[DIMENSION_WIDTH] + (currentAbsoluteChild.style.margin.getWithFallback(leadingSpacing[CSS_FLEX_DIRECTION_ROW], leading[CSS_FLEX_DIRECTION_ROW]) + currentAbsoluteChild.style.margin.getWithFallback(trailingSpacing[CSS_FLEX_DIRECTION_ROW], trailing[CSS_FLEX_DIRECTION_ROW]));
+ childHeight = currentAbsoluteChild.layout.measuredDimensions[DIMENSION_HEIGHT] + (currentAbsoluteChild.style.margin.getWithFallback(leadingSpacing[CSS_FLEX_DIRECTION_COLUMN], leading[CSS_FLEX_DIRECTION_COLUMN]) + currentAbsoluteChild.style.margin.getWithFallback(trailingSpacing[CSS_FLEX_DIRECTION_COLUMN], trailing[CSS_FLEX_DIRECTION_COLUMN]));
+ }
+
+ layoutNodeInternal(layoutContext, currentAbsoluteChild, childWidth, childHeight, direction, CSSMeasureMode.EXACTLY, CSSMeasureMode.EXACTLY, true, "abs-layout");
+
+ if (!Float.isNaN(currentAbsoluteChild.style.position[trailing[CSS_FLEX_DIRECTION_ROW]]) &&
+ !!Float.isNaN(currentAbsoluteChild.style.position[leading[CSS_FLEX_DIRECTION_ROW]])) {
+ currentAbsoluteChild.layout.position[leading[CSS_FLEX_DIRECTION_ROW]] =
+ node.layout.measuredDimensions[dim[CSS_FLEX_DIRECTION_ROW]] -
+ currentAbsoluteChild.layout.measuredDimensions[dim[CSS_FLEX_DIRECTION_ROW]] -
+ (Float.isNaN(currentAbsoluteChild.style.position[trailing[CSS_FLEX_DIRECTION_ROW]]) ? 0 : currentAbsoluteChild.style.position[trailing[CSS_FLEX_DIRECTION_ROW]]);
+ }
+
+ if (!Float.isNaN(currentAbsoluteChild.style.position[trailing[CSS_FLEX_DIRECTION_COLUMN]]) &&
+ !!Float.isNaN(currentAbsoluteChild.style.position[leading[CSS_FLEX_DIRECTION_COLUMN]])) {
+ currentAbsoluteChild.layout.position[leading[CSS_FLEX_DIRECTION_COLUMN]] =
+ node.layout.measuredDimensions[dim[CSS_FLEX_DIRECTION_COLUMN]] -
+ currentAbsoluteChild.layout.measuredDimensions[dim[CSS_FLEX_DIRECTION_COLUMN]] -
+ (Float.isNaN(currentAbsoluteChild.style.position[trailing[CSS_FLEX_DIRECTION_COLUMN]]) ? 0 : currentAbsoluteChild.style.position[trailing[CSS_FLEX_DIRECTION_COLUMN]]);
+ }
+ }
+
+ currentAbsoluteChild = currentAbsoluteChild.nextChild;
+ }
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/csslayout/MeasureOutput.java b/android/ReactAndroid/src/main/java/com/facebook/csslayout/MeasureOutput.java
new file mode 100644
index 00000000000000..65adfdf1d95d94
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/csslayout/MeasureOutput.java
@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.csslayout;
+
+/**
+ * POJO to hold the output of the measure function.
+ */
+public class MeasureOutput {
+
+ public float width;
+ public float height;
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/csslayout/README b/android/ReactAndroid/src/main/java/com/facebook/csslayout/README
new file mode 100644
index 00000000000000..9d85b26ff7a12f
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/csslayout/README
@@ -0,0 +1,15 @@
+The source of truth for css-layout is: https://github.com/facebook/css-layout
+
+The code here should be kept in sync with GitHub.
+HEAD at the time this code was synced: https://github.com/facebook/css-layout/commit/a1f36b53f5464c8ee7abc311765dc3ecb1b879c6
+
+There is generated code in:
+ - README (this file)
+ - fbandroid/java/com/facebook/csslayout
+ - fbandroid/javatests/com/facebook/csslayout
+ - fbobjc/Libraries/FBReactKit/js/react-native-github/React/Layout
+
+The code was generated by running 'make' in the css-layout folder and running:
+
+ scripts/sync-css-layout.sh
+
diff --git a/android/ReactAndroid/src/main/java/com/facebook/csslayout/Spacing.java b/android/ReactAndroid/src/main/java/com/facebook/csslayout/Spacing.java
new file mode 100644
index 00000000000000..25a555fee46943
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/csslayout/Spacing.java
@@ -0,0 +1,221 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.csslayout;
+
+import javax.annotation.Nullable;
+
+import java.util.Arrays;
+
+/**
+ * Class representing CSS spacing (padding, margin, and borders). This is mostly necessary to
+ * properly implement interactions and updates for properties like margin, marginLeft, and
+ * marginHorizontal.
+ */
+public class Spacing {
+
+ /**
+ * Spacing type that represents the left direction. E.g. {@code marginLeft}.
+ */
+ public static final int LEFT = 0;
+ /**
+ * Spacing type that represents the top direction. E.g. {@code marginTop}.
+ */
+ public static final int TOP = 1;
+ /**
+ * Spacing type that represents the right direction. E.g. {@code marginRight}.
+ */
+ public static final int RIGHT = 2;
+ /**
+ * Spacing type that represents the bottom direction. E.g. {@code marginBottom}.
+ */
+ public static final int BOTTOM = 3;
+ /**
+ * Spacing type that represents vertical direction (top and bottom). E.g. {@code marginVertical}.
+ */
+ public static final int VERTICAL = 4;
+ /**
+ * Spacing type that represents horizontal direction (left and right). E.g.
+ * {@code marginHorizontal}.
+ */
+ public static final int HORIZONTAL = 5;
+ /**
+ * Spacing type that represents start direction e.g. left in left-to-right, right in right-to-left.
+ */
+ public static final int START = 6;
+ /**
+ * Spacing type that represents end direction e.g. right in left-to-right, left in right-to-left.
+ */
+ public static final int END = 7;
+ /**
+ * Spacing type that represents all directions (left, top, right, bottom). E.g. {@code margin}.
+ */
+ public static final int ALL = 8;
+
+ private static final int[] sFlagsMap = {
+ 1, /*LEFT*/
+ 2, /*TOP*/
+ 4, /*RIGHT*/
+ 8, /*BOTTOM*/
+ 16, /*VERTICAL*/
+ 32, /*HORIZONTAL*/
+ 64, /*START*/
+ 128, /*END*/
+ 256, /*ALL*/
+ };
+
+ private final float[] mSpacing = newFullSpacingArray();
+ @Nullable private float[] mDefaultSpacing = null;
+ private int mValueFlags = 0;
+ private boolean mHasAliasesSet;
+
+ /**
+ * Set a spacing value.
+ *
+ * @param spacingType one of {@link #LEFT}, {@link #TOP}, {@link #RIGHT}, {@link #BOTTOM},
+ * {@link #VERTICAL}, {@link #HORIZONTAL}, {@link #ALL}
+ * @param value the value for this direction
+ * @return {@code true} if the spacing has changed, or {@code false} if the same value was already
+ * set
+ */
+ public boolean set(int spacingType, float value) {
+ if (!FloatUtil.floatsEqual(mSpacing[spacingType], value)) {
+ mSpacing[spacingType] = value;
+
+ if (CSSConstants.isUndefined(value)) {
+ mValueFlags &= ~sFlagsMap[spacingType];
+ } else {
+ mValueFlags |= sFlagsMap[spacingType];
+ }
+
+ mHasAliasesSet =
+ (mValueFlags & sFlagsMap[ALL]) != 0 ||
+ (mValueFlags & sFlagsMap[VERTICAL]) != 0 ||
+ (mValueFlags & sFlagsMap[HORIZONTAL]) != 0;
+
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Set a default spacing value. This is used as a fallback when no spacing has been set for a
+ * particular direction.
+ *
+ * @param spacingType one of {@link #LEFT}, {@link #TOP}, {@link #RIGHT}, {@link #BOTTOM}
+ * @param value the default value for this direction
+ * @return
+ */
+ public boolean setDefault(int spacingType, float value) {
+ if (mDefaultSpacing == null) {
+ mDefaultSpacing = newSpacingResultArray();
+ }
+ if (!FloatUtil.floatsEqual(mDefaultSpacing[spacingType], value)) {
+ mDefaultSpacing[spacingType] = value;
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Get the spacing for a direction. This takes into account any default values that have been set.
+ *
+ * @param spacingType one of {@link #LEFT}, {@link #TOP}, {@link #RIGHT}, {@link #BOTTOM}
+ */
+ public float get(int spacingType) {
+ float defaultValue = (mDefaultSpacing != null)
+ ? mDefaultSpacing[spacingType]
+ : (spacingType == START || spacingType == END ? CSSConstants.UNDEFINED : 0);
+
+ if (mValueFlags == 0) {
+ return defaultValue;
+ }
+
+ if ((mValueFlags & sFlagsMap[spacingType]) != 0) {
+ return mSpacing[spacingType];
+ }
+
+ if (mHasAliasesSet) {
+ int secondType = spacingType == TOP || spacingType == BOTTOM ? VERTICAL : HORIZONTAL;
+ if ((mValueFlags & sFlagsMap[secondType]) != 0) {
+ return mSpacing[secondType];
+ } else if ((mValueFlags & sFlagsMap[ALL]) != 0) {
+ return mSpacing[ALL];
+ }
+ }
+
+ return defaultValue;
+ }
+
+ /**
+ * Get the raw value (that was set using {@link #set(int, float)}), without taking into account
+ * any default values.
+ *
+ * @param spacingType one of {@link #LEFT}, {@link #TOP}, {@link #RIGHT}, {@link #BOTTOM},
+ * {@link #VERTICAL}, {@link #HORIZONTAL}, {@link #ALL}
+ */
+ public float getRaw(int spacingType) {
+ return mSpacing[spacingType];
+ }
+
+ /**
+ * Resets the spacing instance to its default state. This method is meant to be used when
+ * recycling {@link Spacing} instances.
+ */
+ void reset() {
+ Arrays.fill(mSpacing, CSSConstants.UNDEFINED);
+ mDefaultSpacing = null;
+ mHasAliasesSet = false;
+ mValueFlags = 0;
+ }
+
+ /**
+ * Try to get start value and fallback to given type if not defined. This is used privately
+ * by the layout engine as a more efficient way to fetch direction-aware values by
+ * avoid extra method invocations.
+ */
+ float getWithFallback(int spacingType, int fallbackType) {
+ return
+ (mValueFlags & sFlagsMap[spacingType]) != 0
+ ? mSpacing[spacingType]
+ : get(fallbackType);
+ }
+
+ private static float[] newFullSpacingArray() {
+ return new float[] {
+ CSSConstants.UNDEFINED,
+ CSSConstants.UNDEFINED,
+ CSSConstants.UNDEFINED,
+ CSSConstants.UNDEFINED,
+ CSSConstants.UNDEFINED,
+ CSSConstants.UNDEFINED,
+ CSSConstants.UNDEFINED,
+ CSSConstants.UNDEFINED,
+ CSSConstants.UNDEFINED,
+ };
+ }
+
+ private static float[] newSpacingResultArray() {
+ return newSpacingResultArray(0);
+ }
+
+ private static float[] newSpacingResultArray(float defaultValue) {
+ return new float[] {
+ defaultValue,
+ defaultValue,
+ defaultValue,
+ defaultValue,
+ defaultValue,
+ defaultValue,
+ CSSConstants.UNDEFINED,
+ CSSConstants.UNDEFINED,
+ defaultValue,
+ };
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/jni/BUCK b/android/ReactAndroid/src/main/java/com/facebook/jni/BUCK
new file mode 100644
index 00000000000000..a5eb40afc3db91
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/jni/BUCK
@@ -0,0 +1,19 @@
+include_defs('//ReactAndroid/DEFS')
+
+android_library(
+ name = 'jni',
+ srcs = glob(['**/*.java']),
+ proguard_config = 'fbjni.pro',
+ deps = [
+ react_native_dep('java/com/facebook/proguard/annotations:annotations'),
+ react_native_dep('libraries/soloader/java/com/facebook/soloader:soloader'),
+ react_native_dep('third-party/java/jsr-305:jsr-305'),
+ ],
+ visibility = [
+ 'PUBLIC',
+ ]
+)
+
+project_config(
+ src_target = ':jni',
+)
diff --git a/android/ReactAndroid/src/main/java/com/facebook/jni/Countable.java b/android/ReactAndroid/src/main/java/com/facebook/jni/Countable.java
new file mode 100644
index 00000000000000..a319e187aac35f
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/jni/Countable.java
@@ -0,0 +1,35 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+package com.facebook.jni;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.soloader.SoLoader;
+
+/**
+ * A Java Object that has native memory allocated corresponding to this instance.
+ *
+ * NB: THREAD SAFETY (this comment also exists at Countable.cpp)
+ *
+ * {@link #dispose} deletes the corresponding native object on whatever thread the method is called
+ * on. In the common case when this is called by Countable#finalize(), this will be called on the
+ * system finalizer thread. If you manually call dispose on the Java object, the native object
+ * will be deleted synchronously on that thread.
+ */
+@DoNotStrip
+public class Countable {
+
+ static {
+ SoLoader.loadLibrary("fb");
+ }
+
+ // Private C++ instance
+ @DoNotStrip
+ private long mInstance = 0;
+
+ public native void dispose();
+
+ protected void finalize() throws Throwable {
+ dispose();
+ super.finalize();
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/jni/HybridData.java b/android/ReactAndroid/src/main/java/com/facebook/jni/HybridData.java
new file mode 100644
index 00000000000000..e0b864b08d1d38
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/jni/HybridData.java
@@ -0,0 +1,49 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+package com.facebook.jni;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.soloader.SoLoader;
+
+/**
+ * This object holds a native C++ member for hybrid Java/C++ objects.
+ *
+ * NB: THREAD SAFETY
+ *
+ * {@link #dispose} deletes the corresponding native object on whatever thread
+ * the method is called on. In the common case when this is called by
+ * HybridData#finalize(), this will be called on the system finalizer
+ * thread. If you manually call resetNative() on the Java object, the C++
+ * object will be deleted synchronously on that thread.
+ */
+@DoNotStrip
+public class HybridData {
+
+ static {
+ SoLoader.loadLibrary("fb");
+ }
+
+ // Private C++ instance
+ @DoNotStrip
+ private long mNativePointer = 0;
+
+ /**
+ * To explicitly delete the instance, call resetNative(). If the C++
+ * instance is referenced after this is called, a NullPointerException will
+ * be thrown. resetNative() may be called multiple times safely. Because
+ * {@link #finalize} calls resetNative, the instance will not leak if this is
+ * not called, but timing of deletion and the thread the C++ dtor is called
+ * on will be at the whim of the Java GC. If you want to control the thread
+ * and timing of the destructor, you should call resetNative() explicitly.
+ */
+ public native void resetNative();
+
+ protected void finalize() throws Throwable {
+ resetNative();
+ super.finalize();
+ }
+
+ public boolean isValid() {
+ return mNativePointer != 0;
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/jni/IteratorHelper.java b/android/ReactAndroid/src/main/java/com/facebook/jni/IteratorHelper.java
new file mode 100644
index 00000000000000..aca1cb50fb04e9
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/jni/IteratorHelper.java
@@ -0,0 +1,56 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.jni;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+
+import javax.annotation.Nullable;
+
+import java.util.Iterator;
+
+/**
+ * To iterate over an Iterator from C++ requires two calls per entry: hasNext()
+ * and next(). This helper reduces it to one call and one field get per entry.
+ * It does not use a generic argument, since in C++, the types will be erased,
+ * anyway. This is *not* a {@link java.util.Iterator}.
+ */
+@DoNotStrip
+public class IteratorHelper {
+ private final Iterator mIterator;
+
+ // This is private, but accessed via JNI.
+ @DoNotStrip
+ private @Nullable Object mElement;
+
+ @DoNotStrip
+ public IteratorHelper(Iterator iterator) {
+ mIterator = iterator;
+ }
+
+ @DoNotStrip
+ public IteratorHelper(Iterable iterable) {
+ mIterator = iterable.iterator();
+ }
+
+ /**
+ * Moves the helper to the next entry in the map, if any. Returns true iff
+ * there is an entry to read.
+ */
+ @DoNotStrip
+ boolean hasNext() {
+ if (mIterator.hasNext()) {
+ mElement = mIterator.next();
+ return true;
+ } else {
+ mElement = null;
+ return false;
+ }
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/jni/MapIteratorHelper.java b/android/ReactAndroid/src/main/java/com/facebook/jni/MapIteratorHelper.java
new file mode 100644
index 00000000000000..aa9283ed2f898a
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/jni/MapIteratorHelper.java
@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.jni;
+
+import javax.annotation.Nullable;
+
+import java.util.Iterator;
+import java.util.Map;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+
+/**
+ * To iterate over a Map from C++ requires four calls per entry: hasNext(),
+ * next(), getKey(), getValue(). This helper reduces it to one call and two
+ * field gets per entry. It does not use a generic argument, since in C++, the
+ * types will be erased, anyway. This is *not* a {@link java.util.Iterator}.
+ */
+@DoNotStrip
+public class MapIteratorHelper {
+ @DoNotStrip private final Iterator mIterator;
+ @DoNotStrip private @Nullable Object mKey;
+ @DoNotStrip private @Nullable Object mValue;
+
+ @DoNotStrip
+ public MapIteratorHelper(Map map) {
+ mIterator = map.entrySet().iterator();
+ }
+
+ /**
+ * Moves the helper to the next entry in the map, if any. Returns true iff
+ * there is an entry to read.
+ */
+ @DoNotStrip
+ boolean hasNext() {
+ if (mIterator.hasNext()) {
+ Map.Entry entry = mIterator.next();
+ mKey = entry.getKey();
+ mValue = entry.getValue();
+ return true;
+ } else {
+ mKey = null;
+ mValue = null;
+ return false;
+ }
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/jni/NativeRunnable.java b/android/ReactAndroid/src/main/java/com/facebook/jni/NativeRunnable.java
new file mode 100644
index 00000000000000..151cc8ad80f0a3
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/jni/NativeRunnable.java
@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.jni;
+
+import com.facebook.jni.HybridData;
+import com.facebook.proguard.annotations.DoNotStrip;
+
+/**
+ * A Runnable that has a native run implementation.
+ */
+@DoNotStrip
+public class NativeRunnable implements Runnable {
+
+ private final HybridData mHybridData;
+
+ private NativeRunnable(HybridData hybridData) {
+ mHybridData = hybridData;
+ }
+
+ public native void run();
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/jni/ThreadScopeSupport.java b/android/ReactAndroid/src/main/java/com/facebook/jni/ThreadScopeSupport.java
new file mode 100644
index 00000000000000..89610c43798d66
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/jni/ThreadScopeSupport.java
@@ -0,0 +1,22 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+package com.facebook.jni;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.soloader.SoLoader;
+
+@DoNotStrip
+public class ThreadScopeSupport {
+ static {
+ SoLoader.loadLibrary("fb");
+ }
+
+ // This is just used for ThreadScope::withClassLoader to have a java function
+ // in the stack so that jni has access to the correct classloader.
+ @DoNotStrip
+ private static void runStdFunction(long ptr) {
+ runStdFunctionImpl(ptr);
+ }
+
+ private static native void runStdFunctionImpl(long ptr);
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/jni/fbjni.pro b/android/ReactAndroid/src/main/java/com/facebook/jni/fbjni.pro
new file mode 100644
index 00000000000000..5b5b6454d32adf
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/jni/fbjni.pro
@@ -0,0 +1,11 @@
+# For common use cases for the hybrid pattern, keep symbols which may
+# be referenced only from C++.
+
+-keepclassmembers class * {
+ com.facebook.jni.HybridData *;
+ (com.facebook.jni.HybridData);
+}
+
+-keepclasseswithmembers class * {
+ com.facebook.jni.HybridData *;
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/perftest/BUCK b/android/ReactAndroid/src/main/java/com/facebook/perftest/BUCK
new file mode 100644
index 00000000000000..655817f6e11bda
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/perftest/BUCK
@@ -0,0 +1,11 @@
+android_library(
+ name = 'perftest',
+ srcs = glob(['*.java']),
+ visibility = [
+ 'PUBLIC',
+ ],
+)
+
+project_config(
+ src_target = ':perftest',
+)
diff --git a/android/ReactAndroid/src/main/java/com/facebook/perftest/PerfTestConfig.java b/android/ReactAndroid/src/main/java/com/facebook/perftest/PerfTestConfig.java
new file mode 100644
index 00000000000000..28336820266728
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/perftest/PerfTestConfig.java
@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.perftest;
+
+/**
+ * PerfTestConfig stub.
+ */
+public class PerfTestConfig {
+
+ public boolean isRunningInPerfTest() {
+ return false;
+ }
+
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/proguard/annotations/BUCK b/android/ReactAndroid/src/main/java/com/facebook/proguard/annotations/BUCK
new file mode 100644
index 00000000000000..27de0b88a9c7bc
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/proguard/annotations/BUCK
@@ -0,0 +1,14 @@
+android_library(
+ name = 'annotations',
+ srcs = glob(['*.java']),
+ proguard_config = 'proguard_annotations.pro',
+ deps = [
+ ],
+ visibility = [
+ 'PUBLIC',
+ ],
+)
+
+project_config(
+ src_target = ':annotations',
+)
diff --git a/android/ReactAndroid/src/main/java/com/facebook/proguard/annotations/DoNotStrip.java b/android/ReactAndroid/src/main/java/com/facebook/proguard/annotations/DoNotStrip.java
new file mode 100644
index 00000000000000..86a3f2c3fb6e2b
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/proguard/annotations/DoNotStrip.java
@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.proguard.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+import static java.lang.annotation.RetentionPolicy.CLASS;
+
+/**
+ * Add this annotation to a class, method, or field to instruct Proguard to not strip it out.
+ *
+ * This is useful for methods called via reflection that could appear as unused to Proguard.
+ */
+@Target({ ElementType.TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.CONSTRUCTOR })
+@Retention(CLASS)
+public @interface DoNotStrip {
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/proguard/annotations/KeepGettersAndSetters.java b/android/ReactAndroid/src/main/java/com/facebook/proguard/annotations/KeepGettersAndSetters.java
new file mode 100644
index 00000000000000..11f4f32b9878ac
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/proguard/annotations/KeepGettersAndSetters.java
@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.proguard.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+import static java.lang.annotation.RetentionPolicy.CLASS;
+
+/**
+ * Add this annotation to a class, to keep all "void set*(***)" and get* methods.
+ *
+ * This is useful for classes that are controlled by animator-like classes that control
+ * various properties with reflection.
+ *
+ *
NOTE: This is not needed for Views because their getters and setters
+ * are automatically kept by the default Android SDK ProGuard config.
+ */
+@Target({ElementType.TYPE})
+@Retention(CLASS)
+public @interface KeepGettersAndSetters {
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/proguard/annotations/proguard_annotations.pro b/android/ReactAndroid/src/main/java/com/facebook/proguard/annotations/proguard_annotations.pro
new file mode 100644
index 00000000000000..b1ef5f7ce94678
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/proguard/annotations/proguard_annotations.pro
@@ -0,0 +1,15 @@
+# Keep our interfaces so they can be used by other ProGuard rules.
+# See http://sourceforge.net/p/proguard/bugs/466/
+-keep,allowobfuscation @interface com.facebook.proguard.annotations.DoNotStrip
+-keep,allowobfuscation @interface com.facebook.proguard.annotations.KeepGettersAndSetters
+
+# Do not strip any method/class that is annotated with @DoNotStrip
+-keep @com.facebook.proguard.annotations.DoNotStrip class *
+-keepclassmembers class * {
+ @com.facebook.proguard.annotations.DoNotStrip *;
+}
+
+-keepclassmembers @com.facebook.proguard.annotations.KeepGettersAndSetters class * {
+ void set*(***);
+ *** get*();
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/quicklog/BUCK b/android/ReactAndroid/src/main/java/com/facebook/quicklog/BUCK
new file mode 100644
index 00000000000000..8bd1a243fa9667
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/quicklog/BUCK
@@ -0,0 +1,16 @@
+include_defs('//ReactAndroid/DEFS')
+
+android_library(
+ name = 'quicklog',
+ srcs = glob(['*.java']),
+ exported_deps = [
+ react_native_dep('java/com/facebook/quicklog/identifiers:identifiers'),
+ ],
+ visibility = [
+ 'PUBLIC',
+ ],
+)
+
+project_config(
+ src_target = ':quicklog',
+)
diff --git a/android/ReactAndroid/src/main/java/com/facebook/quicklog/QuickPerformanceLogger.java b/android/ReactAndroid/src/main/java/com/facebook/quicklog/QuickPerformanceLogger.java
new file mode 100644
index 00000000000000..9e3e0e32e1f764
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/quicklog/QuickPerformanceLogger.java
@@ -0,0 +1,93 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.quicklog;
+
+/**
+ * Stub implementation of QPL
+ */
+public class QuickPerformanceLogger {
+
+ public void markerStart(
+ int markerId) {
+ }
+
+ public void markerStart(
+ int markerId,
+ int instnaceKey) {
+ }
+
+ public void markerStart(
+ int markerId,
+ int instnaceKey,
+ long timestamp) {
+ }
+
+ public void markerEnd(
+ int markerId,
+ short actionId) {
+ }
+
+ public void markerEnd(
+ int markerId,
+ int instanceKey,
+ short actionId) {
+ }
+
+ public void markerEnd(
+ int markerId,
+ int instanceKey,
+ short actionId,
+ long timestamp) {
+ }
+
+ public void markerNote(
+ int markerId,
+ short actionId) {
+ }
+
+ public void markerNote(
+ int markerId,
+ int instanceKey,
+ short actionId) {
+ }
+
+ public void markerNote(
+ int markerId,
+ int instanceKey,
+ short actionId,
+ long timestamp) {
+ }
+
+ public void markerCancel(
+ int markerId) {
+ }
+
+ public void markerCancel(
+ int markerId,
+ int instanceKey) {
+ }
+
+ public void markerTag(
+ int markerId,
+ String tag) {
+ }
+
+ public void markerTag(
+ int markerId,
+ int instanceKey,
+ String tag) {
+ }
+
+ public long currentMonotonicTimestamp() {
+ return 0L;
+ }
+
+}
+
diff --git a/android/ReactAndroid/src/main/java/com/facebook/quicklog/QuickPerformanceLoggerProvider.java b/android/ReactAndroid/src/main/java/com/facebook/quicklog/QuickPerformanceLoggerProvider.java
new file mode 100644
index 00000000000000..903175bcf8c7fa
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/quicklog/QuickPerformanceLoggerProvider.java
@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.quicklog;
+
+/**
+ * Provides stub implementation of QPL
+ */
+public class QuickPerformanceLoggerProvider {
+
+ private static final QuickPerformanceLogger sQuickPerformanceLogger =
+ new QuickPerformanceLogger();
+
+ public static QuickPerformanceLogger getQPLInstance() {
+ return sQuickPerformanceLogger;
+ }
+}
+
diff --git a/android/ReactAndroid/src/main/java/com/facebook/quicklog/identifiers/ActionId.java b/android/ReactAndroid/src/main/java/com/facebook/quicklog/identifiers/ActionId.java
new file mode 100644
index 00000000000000..1a55fdb48529ac
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/quicklog/identifiers/ActionId.java
@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) 2015-present; Facebook; Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.quicklog.identifiers;
+
+/**
+ * Stub implementation of Action Identifiers.
+ * Use your own implementation with you own implementation of QuickPerformanceLogger
+ */
+public class ActionId {
+
+ /** Don't use this action identifier */
+ public static short UNDEFINED = 0;
+
+ /** This starts all markers */
+ public static short START = 0;
+
+ /** Successful termination of the marker */
+ public static short SUCCESS = 0;
+
+ /** Termination of marker due to some failure */
+ public static short FAIL = 0;
+
+ /** Termination of marker due to a cancellation */
+ public static short CANCEL = 0;
+
+ /** Some (general) drawing action has completed */
+ public static short DRAW_COMPLETE = 0;
+
+ /** General pause poshort */
+ public static short PAUSE = 0;
+
+ /** General resume poshort */
+ public static short RESUME = 0;
+
+ /** Insertion into a queue */
+ public static short QUEUED = 0;
+
+ /** Some error occurred */
+ public static short ERROR = 0;
+
+ /** Denoting a finally situation */
+ public static short FINALLY = 0;
+}
+
diff --git a/android/ReactAndroid/src/main/java/com/facebook/quicklog/identifiers/BUCK b/android/ReactAndroid/src/main/java/com/facebook/quicklog/identifiers/BUCK
new file mode 100644
index 00000000000000..38d3b1bfa8dcf0
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/quicklog/identifiers/BUCK
@@ -0,0 +1,11 @@
+android_library(
+ name = 'identifiers',
+ srcs = glob(['*.java']),
+ visibility = [
+ 'PUBLIC',
+ ],
+)
+
+project_config(
+ src_target = ':identifiers',
+)
diff --git a/android/ReactAndroid/src/main/java/com/facebook/quicklog/identifiers/ReactNativeBridge.java b/android/ReactAndroid/src/main/java/com/facebook/quicklog/identifiers/ReactNativeBridge.java
new file mode 100644
index 00000000000000..bd1b5b3d5d5363
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/quicklog/identifiers/ReactNativeBridge.java
@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.quicklog.identifiers;
+
+/**
+ * Stub definition of identifier needed in react native open source code.
+ * Use your own identifiers with your own QuickPerformanceLogger implementation
+ */
+public class ReactNativeBridge {
+
+ public static final int CALL_JAVA_MODULE_METHOD = 0;
+
+}
+
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/BUCK b/android/ReactAndroid/src/main/java/com/facebook/react/BUCK
new file mode 100644
index 00000000000000..cec9acd070b63a
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/BUCK
@@ -0,0 +1,32 @@
+include_defs('//ReactAndroid/DEFS')
+
+DEPS = [
+ react_native_target('java/com/facebook/react/cxxbridge:bridge'),
+ react_native_target('java/com/facebook/react/bridge:bridge'),
+ react_native_target('java/com/facebook/react/common:common'),
+ react_native_target('java/com/facebook/react/devsupport:devsupport'),
+ react_native_target('java/com/facebook/react/modules/core:core'),
+ react_native_target('java/com/facebook/react/modules/debug:debug'),
+ react_native_target('java/com/facebook/react/modules/systeminfo:systeminfo'),
+ react_native_target('java/com/facebook/react/modules/toast:toast'),
+ react_native_target('java/com/facebook/react/views/imagehelper:imagehelper'),
+ react_native_target('java/com/facebook/react/uimanager:uimanager'),
+ react_native_dep('java/com/facebook/systrace:systrace'),
+ react_native_dep('libraries/fbcore/src/main/java/com/facebook/common/logging:logging'),
+ react_native_dep('libraries/soloader/java/com/facebook/soloader:soloader'),
+ react_native_dep('third-party/java/infer-annotations:infer-annotations'),
+ react_native_dep('third-party/java/jsr-305:jsr-305'),
+]
+
+android_library(
+ name = 'react',
+ srcs = glob(['*.java']),
+ deps = DEPS,
+ visibility = [
+ 'PUBLIC',
+ ],
+)
+
+project_config(
+ src_target = ':react',
+)
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/CompositeReactPackage.java b/android/ReactAndroid/src/main/java/com/facebook/react/CompositeReactPackage.java
new file mode 100644
index 00000000000000..8f78569131ddc7
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/CompositeReactPackage.java
@@ -0,0 +1,88 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+/**
+ * {@code CompositeReactPackage} allows to create a single package composed of views and modules
+ * from several other packages.
+ */
+public class CompositeReactPackage implements ReactPackage {
+
+ private final List mChildReactPackages = new ArrayList<>();
+
+ /**
+ * The order in which packages are passed matters. It may happen that a NativeModule or
+ * or a ViewManager exists in two or more ReactPackages. In that case the latter will win
+ * i.e. the latter will overwrite the former. This re-occurrence is detected by
+ * comparing a name of a module.
+ */
+ public CompositeReactPackage(ReactPackage arg1, ReactPackage arg2, ReactPackage... args) {
+ mChildReactPackages.add(arg1);
+ mChildReactPackages.add(arg2);
+
+ for (ReactPackage reactPackage: args) {
+ mChildReactPackages.add(reactPackage);
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public List createNativeModules(ReactApplicationContext reactContext) {
+ final Map moduleMap = new HashMap<>();
+ for (ReactPackage reactPackage: mChildReactPackages) {
+ for (NativeModule nativeModule: reactPackage.createNativeModules(reactContext)) {
+ moduleMap.put(nativeModule.getName(), nativeModule);
+ }
+ }
+ return new ArrayList(moduleMap.values());
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public List> createJSModules() {
+ final Set> moduleSet = new HashSet<>();
+ for (ReactPackage reactPackage: mChildReactPackages) {
+ for (Class jsModule: reactPackage.createJSModules()) {
+ moduleSet.add(jsModule);
+ }
+ }
+ return new ArrayList(moduleSet);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public List createViewManagers(ReactApplicationContext reactContext) {
+ final Map viewManagerMap = new HashMap<>();
+ for (ReactPackage reactPackage: mChildReactPackages) {
+ for (ViewManager viewManager: reactPackage.createViewManagers(reactContext)) {
+ viewManagerMap.put(viewManager.getName(), viewManager);
+ }
+ }
+ return new ArrayList(viewManagerMap.values());
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/CoreModulesPackage.java b/android/ReactAndroid/src/main/java/com/facebook/react/CoreModulesPackage.java
new file mode 100644
index 00000000000000..389e48519f866b
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/CoreModulesPackage.java
@@ -0,0 +1,108 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.devsupport.JSCHeapCapture;
+import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.facebook.react.modules.core.ExceptionsManagerModule;
+import com.facebook.react.devsupport.HMRClient;
+import com.facebook.react.modules.core.JSTimersExecution;
+import com.facebook.react.modules.core.RCTNativeAppEventEmitter;
+import com.facebook.react.modules.core.Timing;
+import com.facebook.react.modules.debug.AnimationsDebugModule;
+import com.facebook.react.modules.debug.SourceCodeModule;
+import com.facebook.react.modules.systeminfo.AndroidInfoModule;
+import com.facebook.react.uimanager.AppRegistry;
+import com.facebook.react.uimanager.UIImplementationProvider;
+import com.facebook.react.uimanager.UIManagerModule;
+import com.facebook.react.uimanager.ViewManager;
+import com.facebook.react.uimanager.debug.DebugComponentOwnershipModule;
+import com.facebook.react.uimanager.events.RCTEventEmitter;
+import com.facebook.systrace.Systrace;
+
+/**
+ * Package defining core framework modules (e.g. UIManager). It should be used for modules that
+ * require special integration with other framework parts (e.g. with the list of packages to load
+ * view managers from).
+ */
+/* package */ class CoreModulesPackage implements ReactPackage {
+
+ private final ReactInstanceManager mReactInstanceManager;
+ private final DefaultHardwareBackBtnHandler mHardwareBackBtnHandler;
+ private final UIImplementationProvider mUIImplementationProvider;
+
+ CoreModulesPackage(
+ ReactInstanceManager reactInstanceManager,
+ DefaultHardwareBackBtnHandler hardwareBackBtnHandler,
+ UIImplementationProvider uiImplementationProvider) {
+ mReactInstanceManager = reactInstanceManager;
+ mHardwareBackBtnHandler = hardwareBackBtnHandler;
+ mUIImplementationProvider = uiImplementationProvider;
+ }
+
+ @Override
+ public List createNativeModules(
+ ReactApplicationContext catalystApplicationContext) {
+ Systrace.beginSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "createUIManagerModule");
+ UIManagerModule uiManagerModule;
+ try {
+ List viewManagersList = mReactInstanceManager.createAllViewManagers(
+ catalystApplicationContext);
+ uiManagerModule = new UIManagerModule(
+ catalystApplicationContext,
+ viewManagersList,
+ mUIImplementationProvider.createUIImplementation(
+ catalystApplicationContext,
+ viewManagersList));
+ } finally {
+ Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
+ }
+
+ return Arrays.asList(
+ new AnimationsDebugModule(
+ catalystApplicationContext,
+ mReactInstanceManager.getDevSupportManager().getDevSettings()),
+ new AndroidInfoModule(),
+ new DeviceEventManagerModule(catalystApplicationContext, mHardwareBackBtnHandler),
+ new ExceptionsManagerModule(mReactInstanceManager.getDevSupportManager()),
+ new Timing(catalystApplicationContext, mReactInstanceManager.getDevSupportManager()),
+ new SourceCodeModule(mReactInstanceManager.getSourceUrl()),
+ uiManagerModule,
+ new JSCHeapCapture(catalystApplicationContext),
+ new DebugComponentOwnershipModule(catalystApplicationContext));
+ }
+
+ @Override
+ public List> createJSModules() {
+ return Arrays.asList(
+ DeviceEventManagerModule.RCTDeviceEventEmitter.class,
+ JSTimersExecution.class,
+ RCTEventEmitter.class,
+ RCTNativeAppEventEmitter.class,
+ AppRegistry.class,
+ com.facebook.react.bridge.Systrace.class,
+ HMRClient.class,
+ JSCHeapCapture.HeapCapture.class,
+ DebugComponentOwnershipModule.RCTDebugComponentOwnership.class);
+ }
+
+ @Override
+ public List createViewManagers(ReactApplicationContext reactContext) {
+ return new ArrayList<>(0);
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/JSCConfig.java b/android/ReactAndroid/src/main/java/com/facebook/react/JSCConfig.java
new file mode 100644
index 00000000000000..b541cfb0124388
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/JSCConfig.java
@@ -0,0 +1,19 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+package com.facebook.react;
+
+import com.facebook.react.bridge.WritableNativeMap;
+
+/**
+ * Interface for the configuration object that is passed to JSC.
+ */
+public interface JSCConfig {
+ JSCConfig EMPTY = new JSCConfig() {
+ @Override
+ public WritableNativeMap getConfigMap() {
+ return new WritableNativeMap();
+ }
+ };
+
+ WritableNativeMap getConfigMap();
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/LifecycleState.java b/android/ReactAndroid/src/main/java/com/facebook/react/LifecycleState.java
new file mode 100644
index 00000000000000..068bd063fb0c36
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/LifecycleState.java
@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react;
+
+/**
+ * Lifecycle state for an Activity. The state right after pause and right before resume are the
+ * basically the same so this enum is in terms of the forward lifecycle progression (onResume, etc).
+ * Eventually, if necessary, it could contain something like:
+ *
+ * BEFORE_CREATE,
+ * CREATED,
+ * VIEW_CREATED,
+ * STARTED,
+ * RESUMED
+ */
+public enum LifecycleState {
+ BEFORE_CREATE,
+ BEFORE_RESUME,
+ RESUMED,
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/MemoryPressureRouter.java b/android/ReactAndroid/src/main/java/com/facebook/react/MemoryPressureRouter.java
new file mode 100644
index 00000000000000..7a17830a8c003e
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/MemoryPressureRouter.java
@@ -0,0 +1,118 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+package com.facebook.react;
+
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+import android.annotation.TargetApi;
+import android.app.Application;
+import android.content.ComponentCallbacks2;
+import android.content.Context;
+import android.content.res.Configuration;
+import android.os.Build;
+
+import com.facebook.react.bridge.MemoryPressure;
+import com.facebook.react.bridge.MemoryPressureListener;
+
+import static android.content.ComponentCallbacks2.TRIM_MEMORY_BACKGROUND;
+import static android.content.ComponentCallbacks2.TRIM_MEMORY_COMPLETE;
+import static android.content.ComponentCallbacks2.TRIM_MEMORY_MODERATE;
+import static android.content.ComponentCallbacks2.TRIM_MEMORY_RUNNING_CRITICAL;
+import static android.content.ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN;
+
+/**
+ * Translates and routes memory pressure events to the current catalyst instance.
+ */
+public class MemoryPressureRouter {
+ // Trigger this by sending an intent to your activity with adb shell:
+ // am broadcast -a com.facebook.catalyst.ACTION_TRIM_MEMORY_MODERATE
+ private static final String ACTION_TRIM_MEMORY_UI_HIDDEN =
+ "com.facebook.rnfeed.ACTION_TRIM_MEMORY_UI_HIDDEN";
+ private static final String ACTION_TRIM_MEMORY_MODERATE =
+ "com.facebook.rnfeed.ACTION_TRIM_MEMORY_MODERATE";
+ private static final String ACTION_TRIM_MEMORY_CRITICAL =
+ "com.facebook.rnfeed.ACTION_TRIM_MEMORY_CRITICAL";
+
+ private final Set mListeners =
+ Collections.synchronizedSet(new LinkedHashSet());
+ private final ComponentCallbacks2 mCallbacks = new ComponentCallbacks2() {
+ @Override
+ public void onTrimMemory(int level) {
+ trimMemory(level);
+ }
+
+ @Override
+ public void onConfigurationChanged(Configuration newConfig) {
+ }
+
+ @Override
+ public void onLowMemory() {
+ }
+ };
+
+ @TargetApi(Build.VERSION_CODES.JELLY_BEAN)
+ public static boolean handleDebugIntent(Application application, String action) {
+ switch (action) {
+ case ACTION_TRIM_MEMORY_UI_HIDDEN:
+ simulateTrimMemory(application, ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN);
+ break;
+ case ACTION_TRIM_MEMORY_MODERATE:
+ simulateTrimMemory(application, TRIM_MEMORY_MODERATE);
+ break;
+ case ACTION_TRIM_MEMORY_CRITICAL:
+ simulateTrimMemory(application, TRIM_MEMORY_COMPLETE);
+ default:
+ return false;
+ }
+
+ return true;
+ }
+
+ MemoryPressureRouter(Context context) {
+ context.getApplicationContext().registerComponentCallbacks(mCallbacks);
+ }
+
+ /**
+ * Add a listener to be notified of memory pressure events.
+ */
+ public void addMemoryPressureListener(MemoryPressureListener listener) {
+ mListeners.add(listener);
+ }
+
+ /**
+ * Remove a listener previously added with {@link #addMemoryPressureListener}.
+ */
+ public void removeMemoryPressureListener(MemoryPressureListener listener) {
+ mListeners.remove(listener);
+ }
+
+ public void destroy(Context context) {
+ context.getApplicationContext().unregisterComponentCallbacks(mCallbacks);
+ }
+
+ private void trimMemory(int level) {
+ if (level >= TRIM_MEMORY_COMPLETE) {
+ dispatchMemoryPressure(MemoryPressure.CRITICAL);
+ } else if (level >= TRIM_MEMORY_BACKGROUND || level == TRIM_MEMORY_RUNNING_CRITICAL) {
+ dispatchMemoryPressure(MemoryPressure.MODERATE);
+ } else if (level == TRIM_MEMORY_UI_HIDDEN) {
+ dispatchMemoryPressure(MemoryPressure.UI_HIDDEN);
+ }
+ }
+
+ private void dispatchMemoryPressure(MemoryPressure level) {
+ // copy listeners array to avoid ConcurrentModificationException if any of the listeners remove
+ // themselves in handleMemoryPressure()
+ MemoryPressureListener[] listeners =
+ mListeners.toArray(new MemoryPressureListener[mListeners.size()]);
+ for (MemoryPressureListener listener : listeners) {
+ listener.handleMemoryPressure(level);
+ }
+ }
+
+ private static void simulateTrimMemory(Application application, int level) {
+ application.onTrimMemory(level);
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/ReactActivity.java b/android/ReactAndroid/src/main/java/com/facebook/react/ReactActivity.java
new file mode 100644
index 00000000000000..23f4060b4386a1
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/ReactActivity.java
@@ -0,0 +1,208 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react;
+
+import javax.annotation.Nullable;
+
+import java.util.List;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.os.Build;
+import android.os.Bundle;
+import android.provider.Settings;
+import android.view.KeyEvent;
+import android.widget.Toast;
+
+import com.facebook.common.logging.FLog;
+import com.facebook.react.common.ReactConstants;
+import com.facebook.react.devsupport.DoubleTapReloadRecognizer;
+import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
+import com.facebook.react.modules.core.PermissionAwareActivity;
+import com.facebook.react.modules.core.PermissionListener;
+
+/**
+ * Base Activity for React Native applications.
+ */
+public abstract class ReactActivity extends Activity
+ implements DefaultHardwareBackBtnHandler, PermissionAwareActivity {
+
+ private static final String REDBOX_PERMISSION_MESSAGE =
+ "Overlay permissions needs to be granted in order for react native apps to run in dev mode";
+
+ private @Nullable PermissionListener mPermissionListener;
+ private @Nullable ReactInstanceManager mReactInstanceManager;
+ private @Nullable ReactRootView mReactRootView;
+ private DoubleTapReloadRecognizer mDoubleTapReloadRecognizer;
+ private boolean mDoRefresh = false;
+
+ /**
+ * Returns the launchOptions which will be passed to the {@link ReactInstanceManager}
+ * when the application is started. By default, this will return null and an empty
+ * object will be passed to your top level component as its initial props.
+ * If your React Native application requires props set outside of JS, override
+ * this method to return the Android.os.Bundle of your desired initial props.
+ */
+ protected @Nullable Bundle getLaunchOptions() {
+ return null;
+ }
+
+ /**
+ * Returns the name of the main component registered from JavaScript.
+ * This is used to schedule rendering of the component.
+ * e.g. "MoviesApp"
+ */
+ protected abstract String getMainComponentName();
+
+ /**
+ * A subclass may override this method if it needs to use a custom {@link ReactRootView}.
+ */
+ protected ReactRootView createRootView() {
+ return new ReactRootView(this);
+ }
+
+ /**
+ * Get the {@link ReactNativeHost} used by this app. By default, assumes {@link #getApplication()}
+ * is an instance of {@link ReactApplication} and calls
+ * {@link ReactApplication#getReactNativeHost()}. Override this method if your application class
+ * does not implement {@code ReactApplication} or you simply have a different mechanism for
+ * storing a {@code ReactNativeHost}, e.g. as a static field somewhere.
+ */
+ protected ReactNativeHost getReactNativeHost() {
+ return ((ReactApplication) getApplication()).getReactNativeHost();
+ }
+
+ /**
+ * Get whether developer support should be enabled or not. By default this delegates to
+ * {@link ReactNativeHost#getUseDeveloperSupport()}. Override this method if your application
+ * class does not implement {@code ReactApplication} or you simply have a different logic for
+ * determining this (default just checks {@code BuildConfig}).
+ */
+ protected boolean getUseDeveloperSupport() {
+ return ((ReactApplication) getApplication()).getReactNativeHost().getUseDeveloperSupport();
+ }
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+
+ if (getUseDeveloperSupport() && Build.VERSION.SDK_INT >= 23) {
+ // Get permission to show redbox in dev builds.
+ if (!Settings.canDrawOverlays(this)) {
+ Intent serviceIntent = new Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION);
+ startActivity(serviceIntent);
+ FLog.w(ReactConstants.TAG, REDBOX_PERMISSION_MESSAGE);
+ Toast.makeText(this, REDBOX_PERMISSION_MESSAGE, Toast.LENGTH_LONG).show();
+ }
+ }
+
+ mReactRootView = createRootView();
+ mReactRootView.startReactApplication(
+ getReactNativeHost().getReactInstanceManager(),
+ getMainComponentName(),
+ getLaunchOptions());
+ setContentView(mReactRootView);
+ mDoubleTapReloadRecognizer = new DoubleTapReloadRecognizer();
+ }
+
+ @Override
+ protected void onPause() {
+ super.onPause();
+
+ if (getReactNativeHost().hasInstance()) {
+ getReactNativeHost().getReactInstanceManager().onHostPause();
+ }
+ }
+
+ @Override
+ protected void onResume() {
+ super.onResume();
+
+ if (getReactNativeHost().hasInstance()) {
+ getReactNativeHost().getReactInstanceManager().onHostResume(this, this);
+ }
+ }
+
+ @Override
+ protected void onDestroy() {
+ super.onDestroy();
+
+ if (mReactRootView != null) {
+ mReactRootView.unmountReactApplication();
+ mReactRootView = null;
+ }
+ getReactNativeHost().clear();
+ }
+
+ @Override
+ public void onActivityResult(int requestCode, int resultCode, Intent data) {
+ if (getReactNativeHost().hasInstance()) {
+ getReactNativeHost().getReactInstanceManager()
+ .onActivityResult(requestCode, resultCode, data);
+ }
+ }
+
+ @Override
+ public boolean onKeyUp(int keyCode, KeyEvent event) {
+ if (getReactNativeHost().hasInstance() && getUseDeveloperSupport()) {
+ if (keyCode == KeyEvent.KEYCODE_MENU) {
+ getReactNativeHost().getReactInstanceManager().showDevOptionsDialog();
+ return true;
+ }
+ if (mDoubleTapReloadRecognizer.didDoubleTapR(keyCode, getCurrentFocus())) {
+ getReactNativeHost().getReactInstanceManager().getDevSupportManager().handleReloadJS();
+ }
+ }
+ return super.onKeyUp(keyCode, event);
+ }
+
+ @Override
+ public void onBackPressed() {
+ if (getReactNativeHost().hasInstance()) {
+ getReactNativeHost().getReactInstanceManager().onBackPressed();
+ } else {
+ super.onBackPressed();
+ }
+ }
+
+ @Override
+ public void invokeDefaultOnBackPressed() {
+ super.onBackPressed();
+ }
+
+ @Override
+ public void onNewIntent(Intent intent) {
+ if (getReactNativeHost().hasInstance()) {
+ getReactNativeHost().getReactInstanceManager().onNewIntent(intent);
+ } else {
+ super.onNewIntent(intent);
+ }
+ }
+
+ @Override
+ public void requestPermissions(
+ String[] permissions,
+ int requestCode,
+ PermissionListener listener) {
+ mPermissionListener = listener;
+ this.requestPermissions(permissions, requestCode);
+ }
+
+ @Override
+ public void onRequestPermissionsResult(
+ int requestCode,
+ String[] permissions,
+ int[] grantResults) {
+ if (mPermissionListener != null &&
+ mPermissionListener.onRequestPermissionsResult(requestCode, permissions, grantResults)) {
+ mPermissionListener = null;
+ }
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/ReactApplication.java b/android/ReactAndroid/src/main/java/com/facebook/react/ReactApplication.java
new file mode 100644
index 00000000000000..6b74532dfe546e
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/ReactApplication.java
@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react;
+
+public interface ReactApplication {
+
+ /**
+ * Get the default {@link ReactNativeHost} for this app.
+ */
+ ReactNativeHost getReactNativeHost();
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/ReactInstanceManager.java b/android/ReactAndroid/src/main/java/com/facebook/react/ReactInstanceManager.java
new file mode 100644
index 00000000000000..4aa08512f627ad
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/ReactInstanceManager.java
@@ -0,0 +1,404 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react;
+
+import javax.annotation.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import android.app.Activity;
+import android.app.Application;
+import android.content.Intent;
+
+import com.facebook.infer.annotation.Assertions;
+import com.facebook.react.bridge.NativeModuleCallExceptionHandler;
+import com.facebook.react.bridge.NotThreadSafeBridgeIdleDebugListener;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.cxxbridge.JSBundleLoader;
+import com.facebook.react.common.annotations.VisibleForTesting;
+import com.facebook.react.devsupport.DevSupportManager;
+import com.facebook.react.devsupport.RedBoxHandler;
+import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
+import com.facebook.react.uimanager.UIImplementationProvider;
+import com.facebook.react.uimanager.ViewManager;
+
+/**
+ * This class is managing instances of {@link CatalystInstance}. It exposes a way to configure
+ * catalyst instance using {@link ReactPackage} and keeps track of the lifecycle of that
+ * instance. It also sets up connection between the instance and developers support functionality
+ * of the framework.
+ *
+ * An instance of this manager is required to start JS application in {@link ReactRootView} (see
+ * {@link ReactRootView#startReactApplication} for more info).
+ *
+ * The lifecycle of the instance of {@link ReactInstanceManager} should be bound to the activity
+ * that owns the {@link ReactRootView} that is used to render react application using this
+ * instance manager (see {@link ReactRootView#startReactApplication}). It's required to pass
+ * owning activity's lifecycle events to the instance manager (see {@link #onHostPause},
+ * {@link #onHostDestroy} and {@link #onHostResume}).
+ *
+ * Ideally, this would be an interface, but because of the API used by earlier versions, it has to
+ * have a static method, and so cannot (in Java < 8), be one.
+ */
+public abstract class ReactInstanceManager {
+
+ /**
+ * Listener interface for react instance events.
+ */
+ public interface ReactInstanceEventListener {
+ /**
+ * Called when the react context is initialized (all modules registered). Always called on the
+ * UI thread.
+ */
+ void onReactContextInitialized(ReactContext context);
+ }
+
+ public abstract DevSupportManager getDevSupportManager();
+
+ public abstract MemoryPressureRouter getMemoryPressureRouter();
+
+ /**
+ * Trigger react context initialization asynchronously in a background async task. This enables
+ * applications to pre-load the application JS, and execute global code before
+ * {@link ReactRootView} is available and measured. This should only be called the first time the
+ * application is set up, which is enforced to keep developers from accidentally creating their
+ * application multiple times without realizing it.
+ *
+ * Called from UI thread.
+ */
+ public abstract void createReactContextInBackground();
+
+ /**
+ * @return whether createReactContextInBackground has been called. Will return false after
+ * onDestroy until a new initial context has been created.
+ */
+ public abstract boolean hasStartedCreatingInitialContext();
+
+ /**
+ * This method will give JS the opportunity to consume the back button event. If JS does not
+ * consume the event, mDefaultBackButtonImpl will be invoked at the end of the round trip to JS.
+ */
+ public abstract void onBackPressed();
+
+ /**
+ * This method will give JS the opportunity to receive intents via Linking.
+ */
+ public abstract void onNewIntent(Intent intent);
+
+ /**
+ * Call this from {@link Activity#onPause()}. This notifies any listening modules so they can do
+ * any necessary cleanup.
+ */
+ public abstract void onHostPause();
+ /**
+ * Use this method when the activity resumes to enable invoking the back button directly from JS.
+ *
+ * This method retains an instance to provided mDefaultBackButtonImpl. Thus it's
+ * important to pass from the activity instance that owns this particular instance of {@link
+ * ReactInstanceManager}, so that once this instance receive {@link #onHostDestroy} event it will
+ * clear the reference to that defaultBackButtonImpl.
+ *
+ * @param defaultBackButtonImpl a {@link DefaultHardwareBackBtnHandler} from an Activity that owns
+ * this instance of {@link ReactInstanceManager}.
+ */
+ public abstract void onHostResume(
+ Activity activity,
+ DefaultHardwareBackBtnHandler defaultBackButtonImpl);
+
+ /**
+ * Call this from {@link Activity#onDestroy()}. This notifies any listening modules so they can do
+ * any necessary cleanup.
+ */
+ public abstract void onHostDestroy();
+ public abstract void onActivityResult(int requestCode, int resultCode, Intent data);
+ public abstract void showDevOptionsDialog();
+
+ /**
+ * Get the URL where the last bundle was loaded from.
+ */
+ public abstract String getSourceUrl();
+
+ /**
+ * The JS Bundle file that this Instance Manager was constructed with.
+ */
+ public abstract @Nullable String getJSBundleFile();
+
+ /**
+ * Attach given {@param rootView} to a catalyst instance manager and start JS application using
+ * JS module provided by {@link ReactRootView#getJSModuleName}. If the react context is currently
+ * being (re)-created, or if react context has not been created yet, the JS application associated
+ * with the provided root view will be started asynchronously, i.e this method won't block.
+ * This view will then be tracked by this manager and in case of catalyst instance restart it will
+ * be re-attached.
+ */
+ public abstract void attachMeasuredRootView(ReactRootView rootView);
+
+ /**
+ * Detach given {@param rootView} from current catalyst instance. It's safe to call this method
+ * multiple times on the same {@param rootView} - in that case view will be detached with the
+ * first call.
+ */
+ public abstract void detachRootView(ReactRootView rootView);
+
+ /**
+ * Destroy this React instance and the attached JS context.
+ */
+ public abstract void destroy();
+
+ /**
+ * Uses configured {@link ReactPackage} instances to create all view managers
+ */
+ public abstract List createAllViewManagers(
+ ReactApplicationContext catalystApplicationContext);
+
+ /**
+ * Add a listener to be notified of react instance events.
+ */
+ public abstract void addReactInstanceEventListener(ReactInstanceEventListener listener);
+
+ /**
+ * Remove a listener previously added with {@link #addReactInstanceEventListener}.
+ */
+ public abstract void removeReactInstanceEventListener(ReactInstanceEventListener listener);
+
+ @VisibleForTesting
+ public abstract @Nullable ReactContext getCurrentReactContext();
+
+ public abstract LifecycleState getLifecycleState();
+
+ /**
+ * Creates a builder that is capable of creating an instance of {@link ReactInstanceManagerImpl}.
+ */
+ public static Builder builder() {
+ return new Builder();
+ }
+
+ /**
+ * Builder class for {@link ReactInstanceManagerImpl}
+ */
+ public static class Builder {
+
+ protected final List mPackages = new ArrayList<>();
+
+ protected @Nullable String mJSBundleFile;
+ protected @Nullable JSBundleLoader mJSBundleLoader;
+ protected @Nullable String mJSMainModuleName;
+ protected @Nullable NotThreadSafeBridgeIdleDebugListener mBridgeIdleDebugListener;
+ protected @Nullable Application mApplication;
+ protected boolean mUseDeveloperSupport;
+ protected @Nullable LifecycleState mInitialLifecycleState;
+ protected @Nullable UIImplementationProvider mUIImplementationProvider;
+ protected @Nullable NativeModuleCallExceptionHandler mNativeModuleCallExceptionHandler;
+ protected JSCConfig mJSCConfig = JSCConfig.EMPTY;
+ protected @Nullable Activity mCurrentActivity;
+ protected @Nullable DefaultHardwareBackBtnHandler mDefaultHardwareBackBtnHandler;
+ protected @Nullable RedBoxHandler mRedBoxHandler;
+ protected boolean mUseOldBridge;
+
+ protected Builder() {
+ }
+
+ /**
+ * Sets a provider of {@link UIImplementation}.
+ * Uses default provider if null is passed.
+ */
+ public Builder setUIImplementationProvider(
+ @Nullable UIImplementationProvider uiImplementationProvider) {
+ mUIImplementationProvider = uiImplementationProvider;
+ return this;
+ }
+
+ /**
+ * Name of the JS bundle file to be loaded from application's raw assets.
+ * Example: {@code "index.android.js"}
+ */
+ public Builder setBundleAssetName(String bundleAssetName) {
+ return this.setJSBundleFile(bundleAssetName == null ? null : "assets://" + bundleAssetName);
+ }
+
+ /**
+ * Path to the JS bundle file to be loaded from the file system.
+ *
+ * Example: {@code "assets://index.android.js" or "/sdcard/main.jsbundle"}
+ */
+ public Builder setJSBundleFile(String jsBundleFile) {
+ mJSBundleFile = jsBundleFile;
+ mJSBundleLoader = null;
+ return this;
+ }
+
+ /**
+ * Bundle loader to use when setting up JS environment. This supersedes
+ * prior invcations of {@link setJSBundleFile} and {@link setBundleAssetName}.
+ *
+ * Example: {@code JSBundleLoader.createFileLoader(application, bundleFile)}
+ */
+ public Builder setJSBundleLoader(JSBundleLoader jsBundleLoader) {
+ mJSBundleLoader = jsBundleLoader;
+ mJSBundleFile = null;
+ return this;
+ }
+
+ /**
+ * Path to your app's main module on the packager server. This is used when
+ * reloading JS during development. All paths are relative to the root folder
+ * the packager is serving files from.
+ * Examples:
+ * {@code "index.android"} or
+ * {@code "subdirectory/index.android"}
+ */
+ public Builder setJSMainModuleName(String jsMainModuleName) {
+ mJSMainModuleName = jsMainModuleName;
+ return this;
+ }
+
+ public Builder addPackage(ReactPackage reactPackage) {
+ mPackages.add(reactPackage);
+ return this;
+ }
+
+ public Builder setBridgeIdleDebugListener(
+ NotThreadSafeBridgeIdleDebugListener bridgeIdleDebugListener) {
+ mBridgeIdleDebugListener = bridgeIdleDebugListener;
+ return this;
+ }
+
+ /**
+ * Required. This must be your {@code Application} instance.
+ */
+ public Builder setApplication(Application application) {
+ mApplication = application;
+ return this;
+ }
+
+ public Builder setCurrentActivity(Activity activity) {
+ mCurrentActivity = activity;
+ return this;
+ }
+
+ public Builder setDefaultHardwareBackBtnHandler(
+ DefaultHardwareBackBtnHandler defaultHardwareBackBtnHandler) {
+ mDefaultHardwareBackBtnHandler = defaultHardwareBackBtnHandler;
+ return this;
+ }
+
+ /**
+ * When {@code true}, developer options such as JS reloading and debugging are enabled.
+ * Note you still have to call {@link #showDevOptionsDialog} to show the dev menu,
+ * e.g. when the device Menu button is pressed.
+ */
+ public Builder setUseDeveloperSupport(boolean useDeveloperSupport) {
+ mUseDeveloperSupport = useDeveloperSupport;
+ return this;
+ }
+
+ /**
+ * Sets the initial lifecycle state of the host. For example, if the host is already resumed at
+ * creation time, we wouldn't expect an onResume call until we get an onPause call.
+ */
+ public Builder setInitialLifecycleState(LifecycleState initialLifecycleState) {
+ mInitialLifecycleState = initialLifecycleState;
+ return this;
+ }
+
+ /**
+ * Set the exception handler for all native module calls. If not set, the default
+ * {@link DevSupportManager} will be used, which shows a redbox in dev mode and rethrows
+ * (crashes the app) in prod mode.
+ */
+ public Builder setNativeModuleCallExceptionHandler(NativeModuleCallExceptionHandler handler) {
+ mNativeModuleCallExceptionHandler = handler;
+ return this;
+ }
+
+ public Builder setJSCConfig(JSCConfig jscConfig) {
+ mJSCConfig = jscConfig;
+ return this;
+ }
+
+ public Builder setRedBoxHandler(@Nullable RedBoxHandler redBoxHandler) {
+ mRedBoxHandler = redBoxHandler;
+ return this;
+ }
+
+ public Builder setUseOldBridge(boolean enable) {
+ mUseOldBridge = enable;
+ return this;
+ }
+
+ /**
+ * Instantiates a new {@link ReactInstanceManagerImpl}.
+ * Before calling {@code build}, the following must be called:
+ *
+ * - {@link #setApplication}
+ *
- {@link #setCurrentActivity} if the activity has already resumed
+ *
- {@link #setDefaultHardwareBackBtnHandler} if the activity has already resumed
+ *
- {@link #setJSBundleFile} or {@link #setJSMainModuleName}
+ *
+ */
+ public ReactInstanceManager build() {
+ Assertions.assertNotNull(
+ mApplication,
+ "Application property has not been set with this builder");
+
+ Assertions.assertCondition(
+ mJSBundleLoader == null || !mUseOldBridge,
+ "JSBundleLoader can't be used with the old bridge");
+
+ Assertions.assertCondition(
+ mUseDeveloperSupport || mJSBundleFile != null || mJSBundleLoader != null,
+ "JS Bundle File has to be provided when dev support is disabled");
+
+ Assertions.assertCondition(
+ mJSMainModuleName != null || mJSBundleFile != null || mJSBundleLoader != null,
+ "Either MainModuleName or JS Bundle File needs to be provided");
+
+ if (mUIImplementationProvider == null) {
+ // create default UIImplementationProvider if the provided one is null.
+ mUIImplementationProvider = new UIImplementationProvider();
+ }
+
+ if (mUseOldBridge) {
+ return new ReactInstanceManagerImpl(
+ mApplication,
+ mCurrentActivity,
+ mDefaultHardwareBackBtnHandler,
+ mJSBundleFile,
+ mJSMainModuleName,
+ mPackages,
+ mUseDeveloperSupport,
+ mBridgeIdleDebugListener,
+ Assertions.assertNotNull(mInitialLifecycleState, "Initial lifecycle state was not set"),
+ mUIImplementationProvider,
+ mNativeModuleCallExceptionHandler,
+ mJSCConfig,
+ mRedBoxHandler);
+ } else {
+ return new XReactInstanceManagerImpl(
+ mApplication,
+ mCurrentActivity,
+ mDefaultHardwareBackBtnHandler,
+ (mJSBundleLoader == null && mJSBundleFile != null) ?
+ JSBundleLoader.createFileLoader(mApplication, mJSBundleFile) : mJSBundleLoader,
+ mJSMainModuleName,
+ mPackages,
+ mUseDeveloperSupport,
+ mBridgeIdleDebugListener,
+ Assertions.assertNotNull(mInitialLifecycleState, "Initial lifecycle state was not set"),
+ mUIImplementationProvider,
+ mNativeModuleCallExceptionHandler,
+ mJSCConfig,
+ mRedBoxHandler);
+ }
+ }
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/ReactInstanceManagerImpl.java b/android/ReactAndroid/src/main/java/com/facebook/react/ReactInstanceManagerImpl.java
new file mode 100644
index 00000000000000..d33fd10d2acfe4
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/ReactInstanceManagerImpl.java
@@ -0,0 +1,941 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react;
+
+import javax.annotation.Nullable;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+
+import android.app.Activity;
+import android.app.Application;
+import android.content.Context;
+import android.content.Intent;
+import android.os.AsyncTask;
+import android.os.Bundle;
+import android.view.View;
+import android.net.Uri;
+
+import com.facebook.common.logging.FLog;
+import com.facebook.infer.annotation.Assertions;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.CatalystInstance;
+import com.facebook.react.bridge.CatalystInstanceImpl;
+import com.facebook.react.bridge.JSBundleLoader;
+import com.facebook.react.bridge.JSCJavaScriptExecutor;
+import com.facebook.react.bridge.JavaJSExecutor;
+import com.facebook.react.bridge.JavaScriptExecutor;
+import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.bridge.JavaScriptModuleRegistry;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.NativeModuleCallExceptionHandler;
+import com.facebook.react.bridge.NativeModuleRegistry;
+import com.facebook.react.bridge.NotThreadSafeBridgeIdleDebugListener;
+import com.facebook.react.bridge.ProxyJavaScriptExecutor;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.ReactMarker;
+import com.facebook.react.bridge.UiThreadUtil;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+import com.facebook.react.bridge.queue.ReactQueueConfigurationSpec;
+import com.facebook.react.common.ApplicationHolder;
+import com.facebook.react.common.ReactConstants;
+import com.facebook.react.common.annotations.VisibleForTesting;
+import com.facebook.react.devsupport.DevServerHelper;
+import com.facebook.react.devsupport.DevSupportManager;
+import com.facebook.react.devsupport.DevSupportManagerFactory;
+import com.facebook.react.devsupport.ReactInstanceDevCommandsHandler;
+import com.facebook.react.devsupport.RedBoxHandler;
+import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.facebook.react.views.imagehelper.ResourceDrawableIdHelper;
+import com.facebook.react.uimanager.AppRegistry;
+import com.facebook.react.uimanager.DisplayMetricsHolder;
+import com.facebook.react.uimanager.UIImplementationProvider;
+import com.facebook.react.uimanager.UIManagerModule;
+import com.facebook.react.uimanager.ViewManager;
+import com.facebook.soloader.SoLoader;
+import com.facebook.systrace.Systrace;
+
+import static com.facebook.react.bridge.ReactMarkerConstants.BUILD_NATIVE_MODULE_REGISTRY_END;
+import static com.facebook.react.bridge.ReactMarkerConstants.BUILD_NATIVE_MODULE_REGISTRY_START;
+import static com.facebook.react.bridge.ReactMarkerConstants.CREATE_CATALYST_INSTANCE_END;
+import static com.facebook.react.bridge.ReactMarkerConstants.CREATE_CATALYST_INSTANCE_START;
+import static com.facebook.react.bridge.ReactMarkerConstants.CREATE_REACT_CONTEXT_START;
+import static com.facebook.react.bridge.ReactMarkerConstants.PROCESS_PACKAGES_END;
+import static com.facebook.react.bridge.ReactMarkerConstants.PROCESS_PACKAGES_START;
+import static com.facebook.react.bridge.ReactMarkerConstants.RUN_JS_BUNDLE_START;
+
+/**
+ * This class manages instances of {@link CatalystInstance}. It exposes a way to configure
+ * catalyst instances using {@link ReactPackage} and keeps track of the lifecycle of that
+ * instance. It also sets up connection between the instance and developers support functionality
+ * of the framework.
+ *
+ * An instance of this manager is required to start JS application in {@link ReactRootView} (see
+ * {@link ReactRootView#startReactApplication} for more info).
+ *
+ * The lifecycle of the instance of {@link ReactInstanceManagerImpl} should be bound to the activity
+ * that owns the {@link ReactRootView} that is used to render react application using this
+ * instance manager (see {@link ReactRootView#startReactApplication}). It's required to pass
+ * owning activity's lifecycle events to the instance manager (see {@link #onHostPause},
+ * {@link #onHostDestroy} and {@link #onHostResume}).
+ *
+ * To instantiate an instance of this class use {@link #builder}.
+ */
+/* package */ class ReactInstanceManagerImpl extends ReactInstanceManager {
+
+ /* should only be accessed from main thread (UI thread) */
+ private final List mAttachedRootViews = new ArrayList<>();
+ private LifecycleState mLifecycleState;
+ private @Nullable ReactContextInitParams mPendingReactContextInitParams;
+ private @Nullable ReactContextInitAsyncTask mReactContextInitAsyncTask;
+
+ /* accessed from any thread */
+ private @Nullable String mJSBundleFile; /* path to JS bundle on file system */
+ private final @Nullable String mJSMainModuleName; /* path to JS bundle root on packager server */
+ private final List mPackages;
+ private final DevSupportManager mDevSupportManager;
+ private final boolean mUseDeveloperSupport;
+ private final @Nullable NotThreadSafeBridgeIdleDebugListener mBridgeIdleDebugListener;
+ private @Nullable volatile ReactContext mCurrentReactContext;
+ private final Context mApplicationContext;
+ private @Nullable DefaultHardwareBackBtnHandler mDefaultBackButtonImpl;
+ private String mSourceUrl;
+ private @Nullable Activity mCurrentActivity;
+ private final Collection mReactInstanceEventListeners =
+ Collections.synchronizedSet(new HashSet());
+ private volatile boolean mHasStartedCreatingInitialContext = false;
+ private final UIImplementationProvider mUIImplementationProvider;
+ private final MemoryPressureRouter mMemoryPressureRouter;
+ private final @Nullable NativeModuleCallExceptionHandler mNativeModuleCallExceptionHandler;
+ private final @Nullable JSCConfig mJSCConfig;
+ private @Nullable RedBoxHandler mRedBoxHandler;
+
+ private final ReactInstanceDevCommandsHandler mDevInterface =
+ new ReactInstanceDevCommandsHandler() {
+
+ @Override
+ public void onReloadWithJSDebugger(JavaJSExecutor.Factory jsExecutorFactory) {
+ ReactInstanceManagerImpl.this.onReloadWithJSDebugger(jsExecutorFactory);
+ }
+
+ @Override
+ public void onJSBundleLoadedFromServer() {
+ ReactInstanceManagerImpl.this.onJSBundleLoadedFromServer();
+ }
+
+ @Override
+ public void toggleElementInspector() {
+ ReactInstanceManagerImpl.this.toggleElementInspector();
+ }
+ };
+
+ private final DefaultHardwareBackBtnHandler mBackBtnHandler =
+ new DefaultHardwareBackBtnHandler() {
+ @Override
+ public void invokeDefaultOnBackPressed() {
+ ReactInstanceManagerImpl.this.invokeDefaultOnBackPressed();
+ }
+ };
+
+ private class ReactContextInitParams {
+ private final JavaScriptExecutor.Factory mJsExecutorFactory;
+ private final JSBundleLoader mJsBundleLoader;
+
+ public ReactContextInitParams(
+ JavaScriptExecutor.Factory jsExecutorFactory,
+ JSBundleLoader jsBundleLoader) {
+ mJsExecutorFactory = Assertions.assertNotNull(jsExecutorFactory);
+ mJsBundleLoader = Assertions.assertNotNull(jsBundleLoader);
+ }
+
+ public JavaScriptExecutor.Factory getJsExecutorFactory() {
+ return mJsExecutorFactory;
+ }
+
+ public JSBundleLoader getJsBundleLoader() {
+ return mJsBundleLoader;
+ }
+ }
+
+ /*
+ * Task class responsible for (re)creating react context in the background. These tasks can only
+ * be executing one at time, see {@link #recreateReactContextInBackground()}.
+ */
+ private final class ReactContextInitAsyncTask extends
+ AsyncTask> {
+ @Override
+ protected void onPreExecute() {
+ if (mCurrentReactContext != null) {
+ tearDownReactContext(mCurrentReactContext);
+ mCurrentReactContext = null;
+ }
+ }
+
+ @Override
+ protected Result doInBackground(ReactContextInitParams... params) {
+ Assertions.assertCondition(params != null && params.length > 0 && params[0] != null);
+ try {
+ JavaScriptExecutor jsExecutor =
+ params[0].getJsExecutorFactory().create(
+ mJSCConfig == null ? new WritableNativeMap() : mJSCConfig.getConfigMap());
+ return Result.of(createReactContext(jsExecutor, params[0].getJsBundleLoader()));
+ } catch (Exception e) {
+ // Pass exception to onPostExecute() so it can be handled on the main thread
+ return Result.of(e);
+ }
+ }
+
+ @Override
+ protected void onPostExecute(Result result) {
+ try {
+ setupReactContext(result.get());
+ } catch (Exception e) {
+ mDevSupportManager.handleException(e);
+ } finally {
+ mReactContextInitAsyncTask = null;
+ }
+
+ // Handle enqueued request to re-initialize react context.
+ if (mPendingReactContextInitParams != null) {
+ recreateReactContextInBackground(
+ mPendingReactContextInitParams.getJsExecutorFactory(),
+ mPendingReactContextInitParams.getJsBundleLoader());
+ mPendingReactContextInitParams = null;
+ }
+ }
+
+ @Override
+ protected void onCancelled(Result reactApplicationContextResult) {
+ try {
+ mMemoryPressureRouter.destroy(reactApplicationContextResult.get());
+ } catch (Exception e) {
+ FLog.w(ReactConstants.TAG, "Caught exception after cancelling react context init", e);
+ } finally {
+ mReactContextInitAsyncTask = null;
+ }
+ }
+ }
+
+ private static class Result {
+ @Nullable private final T mResult;
+ @Nullable private final Exception mException;
+
+ public static Result of(U result) {
+ return new Result(result);
+ }
+
+ public static Result of(Exception exception) {
+ return new Result<>(exception);
+ }
+
+ private Result(T result) {
+ mException = null;
+ mResult = result;
+ }
+
+ private Result(Exception exception) {
+ mException = exception;
+ mResult = null;
+ }
+
+ public T get() throws Exception {
+ if (mException != null) {
+ throw mException;
+ }
+
+ Assertions.assertNotNull(mResult);
+
+ return mResult;
+ }
+ }
+
+ /* package */ ReactInstanceManagerImpl(
+ Context applicationContext,
+ @Nullable Activity currentActivity,
+ @Nullable DefaultHardwareBackBtnHandler defaultHardwareBackBtnHandler,
+ @Nullable String jsBundleFile,
+ @Nullable String jsMainModuleName,
+ List packages,
+ boolean useDeveloperSupport,
+ @Nullable NotThreadSafeBridgeIdleDebugListener bridgeIdleDebugListener,
+ LifecycleState initialLifecycleState,
+ UIImplementationProvider uiImplementationProvider,
+ NativeModuleCallExceptionHandler nativeModuleCallExceptionHandler,
+ @Nullable JSCConfig jscConfig) {
+
+ this(applicationContext,
+ currentActivity,
+ defaultHardwareBackBtnHandler,
+ jsBundleFile,
+ jsMainModuleName,
+ packages,
+ useDeveloperSupport,
+ bridgeIdleDebugListener,
+ initialLifecycleState,
+ uiImplementationProvider,
+ nativeModuleCallExceptionHandler,
+ jscConfig,
+ null);
+ }
+
+ /* package */ ReactInstanceManagerImpl(
+ Context applicationContext,
+ @Nullable Activity currentActivity,
+ @Nullable DefaultHardwareBackBtnHandler defaultHardwareBackBtnHandler,
+ @Nullable String jsBundleFile,
+ @Nullable String jsMainModuleName,
+ List packages,
+ boolean useDeveloperSupport,
+ @Nullable NotThreadSafeBridgeIdleDebugListener bridgeIdleDebugListener,
+ LifecycleState initialLifecycleState,
+ UIImplementationProvider uiImplementationProvider,
+ NativeModuleCallExceptionHandler nativeModuleCallExceptionHandler,
+ @Nullable JSCConfig jscConfig,
+ @Nullable RedBoxHandler redBoxHandler) {
+ initializeSoLoaderIfNecessary(applicationContext);
+
+ // TODO(9577825): remove this
+ ApplicationHolder.setApplication((Application) applicationContext.getApplicationContext());
+ DisplayMetricsHolder.initDisplayMetricsIfNotInitialized(applicationContext);
+
+ mApplicationContext = applicationContext;
+ mCurrentActivity = currentActivity;
+ mDefaultBackButtonImpl = defaultHardwareBackBtnHandler;
+ mJSBundleFile = jsBundleFile;
+ mJSMainModuleName = jsMainModuleName;
+ mPackages = packages;
+ mUseDeveloperSupport = useDeveloperSupport;
+ mRedBoxHandler = redBoxHandler;
+ mDevSupportManager = DevSupportManagerFactory.create(
+ applicationContext,
+ mDevInterface,
+ mJSMainModuleName,
+ useDeveloperSupport,
+ mRedBoxHandler);
+ mBridgeIdleDebugListener = bridgeIdleDebugListener;
+ mLifecycleState = initialLifecycleState;
+ mUIImplementationProvider = uiImplementationProvider;
+ mMemoryPressureRouter = new MemoryPressureRouter(applicationContext);
+ mNativeModuleCallExceptionHandler = nativeModuleCallExceptionHandler;
+ mJSCConfig = jscConfig;
+ }
+
+ @Override
+ public DevSupportManager getDevSupportManager() {
+ return mDevSupportManager;
+ }
+
+ @Override
+ public MemoryPressureRouter getMemoryPressureRouter() {
+ return mMemoryPressureRouter;
+ }
+
+ private static void initializeSoLoaderIfNecessary(Context applicationContext) {
+ // Call SoLoader.initialize here, this is required for apps that does not use exopackage and
+ // does not use SoLoader for loading other native code except from the one used by React Native
+ // This way we don't need to require others to have additional initialization code and to
+ // subclass android.app.Application.
+
+ // Method SoLoader.init is idempotent, so if you wish to use native exopackage, just call
+ // SoLoader.init with appropriate args before initializing ReactInstanceManagerImpl
+ SoLoader.init(applicationContext, /* native exopackage */ false);
+ }
+
+ /**
+ * Trigger react context initialization asynchronously in a background async task. This enables
+ * applications to pre-load the application JS, and execute global code before
+ * {@link ReactRootView} is available and measured. This should only be called the first time the
+ * application is set up, which is enforced to keep developers from accidentally creating their
+ * application multiple times without realizing it.
+ *
+ * Called from UI thread.
+ */
+ @Override
+ public void createReactContextInBackground() {
+ Assertions.assertCondition(
+ !mHasStartedCreatingInitialContext,
+ "createReactContextInBackground should only be called when creating the react " +
+ "application for the first time. When reloading JS, e.g. from a new file, explicitly " +
+ "use recreateReactContextInBackground");
+
+ mHasStartedCreatingInitialContext = true;
+ recreateReactContextInBackgroundInner();
+ }
+
+ /**
+ * Recreate the react application and context. This should be called if configuration has
+ * changed or the developer has requested the app to be reloaded. It should only be called after
+ * an initial call to createReactContextInBackground.
+ *
+ * Called from UI thread.
+ */
+ public void recreateReactContextInBackground() {
+ Assertions.assertCondition(
+ mHasStartedCreatingInitialContext,
+ "recreateReactContextInBackground should only be called after the initial " +
+ "createReactContextInBackground call.");
+ recreateReactContextInBackgroundInner();
+ }
+
+ private void recreateReactContextInBackgroundInner() {
+ UiThreadUtil.assertOnUiThread();
+
+ if (mUseDeveloperSupport && mJSMainModuleName != null) {
+ if (mDevSupportManager.hasUpToDateJSBundleInCache()) {
+ // If there is a up-to-date bundle downloaded from server, always use that
+ onJSBundleLoadedFromServer();
+ } else if (mJSBundleFile == null) {
+ mDevSupportManager.handleReloadJS();
+ } else {
+ mDevSupportManager.isPackagerRunning(
+ new DevServerHelper.PackagerStatusCallback() {
+ @Override
+ public void onPackagerStatusFetched(final boolean packagerIsRunning) {
+ UiThreadUtil.runOnUiThread(
+ new Runnable() {
+ @Override
+ public void run() {
+ if (packagerIsRunning) {
+ mDevSupportManager.handleReloadJS();
+ } else {
+ recreateReactContextInBackgroundFromBundleFile();
+ }
+ }
+ });
+ }
+ });
+ }
+ return;
+ }
+
+ recreateReactContextInBackgroundFromBundleFile();
+ }
+
+ private void recreateReactContextInBackgroundFromBundleFile() {
+ recreateReactContextInBackground(
+ new JSCJavaScriptExecutor.Factory(),
+ JSBundleLoader.createFileLoader(mApplicationContext, mJSBundleFile));
+ }
+
+ /**
+ * @return whether createReactContextInBackground has been called. Will return false after
+ * onDestroy until a new initial context has been created.
+ */
+ public boolean hasStartedCreatingInitialContext() {
+ return mHasStartedCreatingInitialContext;
+ }
+
+ /**
+ * This method will give JS the opportunity to consume the back button event. If JS does not
+ * consume the event, mDefaultBackButtonImpl will be invoked at the end of the round trip to JS.
+ */
+ @Override
+ public void onBackPressed() {
+ UiThreadUtil.assertOnUiThread();
+ ReactContext reactContext = mCurrentReactContext;
+ if (mCurrentReactContext == null) {
+ // Invoke without round trip to JS.
+ FLog.w(ReactConstants.TAG, "Instance detached from instance manager");
+ invokeDefaultOnBackPressed();
+ } else {
+ DeviceEventManagerModule deviceEventManagerModule =
+ Assertions.assertNotNull(reactContext).getNativeModule(DeviceEventManagerModule.class);
+ deviceEventManagerModule.emitHardwareBackPressed();
+ }
+ }
+
+ private void invokeDefaultOnBackPressed() {
+ UiThreadUtil.assertOnUiThread();
+ if (mDefaultBackButtonImpl != null) {
+ mDefaultBackButtonImpl.invokeDefaultOnBackPressed();
+ }
+ }
+
+ @Override
+ public void onNewIntent(Intent intent) {
+ if (mCurrentReactContext == null) {
+ FLog.w(ReactConstants.TAG, "Instance detached from instance manager");
+ } else {
+ String action = intent.getAction();
+ Uri uri = intent.getData();
+
+ if (Intent.ACTION_VIEW.equals(action) && uri != null) {
+ DeviceEventManagerModule deviceEventManagerModule =
+ Assertions.assertNotNull(mCurrentReactContext).getNativeModule(DeviceEventManagerModule.class);
+ deviceEventManagerModule.emitNewIntentReceived(uri);
+ }
+
+ mCurrentReactContext.onNewIntent(mCurrentActivity, intent);
+ }
+ }
+
+ private void toggleElementInspector() {
+ if (mCurrentReactContext != null) {
+ mCurrentReactContext
+ .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+ .emit("toggleElementInspector", null);
+ }
+ }
+
+ @Override
+ public void onHostPause() {
+ UiThreadUtil.assertOnUiThread();
+
+ mDefaultBackButtonImpl = null;
+ if (mUseDeveloperSupport) {
+ mDevSupportManager.setDevSupportEnabled(false);
+ }
+
+ moveToBeforeResumeLifecycleState();
+ mCurrentActivity = null;
+ }
+
+ /**
+ * Use this method when the activity resumes to enable invoking the back button directly from JS.
+ *
+ * This method retains an instance to provided mDefaultBackButtonImpl. Thus it's
+ * important to pass from the activity instance that owns this particular instance of {@link
+ * ReactInstanceManagerImpl}, so that once this instance receive {@link #onHostDestroy} event it will
+ * clear the reference to that defaultBackButtonImpl.
+ *
+ * @param defaultBackButtonImpl a {@link DefaultHardwareBackBtnHandler} from an Activity that owns
+ * this instance of {@link ReactInstanceManagerImpl}.
+ */
+ @Override
+ public void onHostResume(Activity activity, DefaultHardwareBackBtnHandler defaultBackButtonImpl) {
+ UiThreadUtil.assertOnUiThread();
+
+ mDefaultBackButtonImpl = defaultBackButtonImpl;
+ if (mUseDeveloperSupport) {
+ mDevSupportManager.setDevSupportEnabled(true);
+ }
+
+ mCurrentActivity = activity;
+ moveToResumedLifecycleState(false);
+ }
+
+ @Override
+ public void onHostDestroy() {
+ UiThreadUtil.assertOnUiThread();
+
+ if (mUseDeveloperSupport) {
+ mDevSupportManager.setDevSupportEnabled(false);
+ }
+
+ moveToBeforeCreateLifecycleState();
+ mCurrentActivity = null;
+ }
+
+ @Override
+ public void destroy() {
+ UiThreadUtil.assertOnUiThread();
+
+ if (mUseDeveloperSupport) {
+ mDevSupportManager.setDevSupportEnabled(false);
+ }
+
+ moveToBeforeCreateLifecycleState();
+
+ if (mReactContextInitAsyncTask != null) {
+ mReactContextInitAsyncTask.cancel(true);
+ }
+
+ mMemoryPressureRouter.destroy(mApplicationContext);
+
+ if (mCurrentReactContext != null) {
+ mCurrentReactContext.destroy();
+ mCurrentReactContext = null;
+ mHasStartedCreatingInitialContext = false;
+ }
+ mCurrentActivity = null;
+
+ ResourceDrawableIdHelper.getInstance().clear();
+ }
+
+ private void moveToResumedLifecycleState(boolean force) {
+ if (mCurrentReactContext != null) {
+ // we currently don't have an onCreate callback so we call onResume for both transitions
+ if (force ||
+ mLifecycleState == LifecycleState.BEFORE_RESUME ||
+ mLifecycleState == LifecycleState.BEFORE_CREATE) {
+ mCurrentReactContext.onHostResume(mCurrentActivity);
+ }
+ }
+ mLifecycleState = LifecycleState.RESUMED;
+ }
+
+ private void moveToBeforeResumeLifecycleState() {
+ if (mCurrentReactContext != null) {
+ if (mLifecycleState == LifecycleState.BEFORE_CREATE) {
+ mCurrentReactContext.onHostResume(mCurrentActivity);
+ mCurrentReactContext.onHostPause();
+ } else if (mLifecycleState == LifecycleState.RESUMED) {
+ mCurrentReactContext.onHostPause();
+ }
+ }
+ mLifecycleState = LifecycleState.BEFORE_RESUME;
+ }
+
+ private void moveToBeforeCreateLifecycleState() {
+ if (mCurrentReactContext != null) {
+ if (mLifecycleState == LifecycleState.RESUMED) {
+ mCurrentReactContext.onHostPause();
+ mLifecycleState = LifecycleState.BEFORE_RESUME;
+ }
+ if (mLifecycleState == LifecycleState.BEFORE_RESUME) {
+ mCurrentReactContext.onHostDestroy();
+ }
+ }
+ mLifecycleState = LifecycleState.BEFORE_CREATE;
+ }
+
+ public LifecycleState getLifecycleState() {
+ return mLifecycleState;
+ }
+
+ @Override
+ public void onActivityResult(int requestCode, int resultCode, Intent data) {
+ if (mCurrentReactContext != null) {
+ mCurrentReactContext.onActivityResult(requestCode, resultCode, data);
+ }
+ }
+
+ @Override
+ public void showDevOptionsDialog() {
+ UiThreadUtil.assertOnUiThread();
+ mDevSupportManager.showDevOptionsDialog();
+ }
+
+ /**
+ * Get the URL where the last bundle was loaded from.
+ */
+ @Override
+ public String getSourceUrl() {
+ return Assertions.assertNotNull(mSourceUrl);
+ }
+
+ @Override
+ public @Nullable String getJSBundleFile() {
+ return mJSBundleFile;
+ }
+
+ /**
+ * Attach given {@param rootView} to a catalyst instance manager and start JS application using
+ * JS module provided by {@link ReactRootView#getJSModuleName}. If the react context is currently
+ * being (re)-created, or if react context has not been created yet, the JS application associated
+ * with the provided root view will be started asynchronously, i.e this method won't block.
+ * This view will then be tracked by this manager and in case of catalyst instance restart it will
+ * be re-attached.
+ */
+ @Override
+ public void attachMeasuredRootView(ReactRootView rootView) {
+ UiThreadUtil.assertOnUiThread();
+ mAttachedRootViews.add(rootView);
+
+ // If react context is being created in the background, JS application will be started
+ // automatically when creation completes, as root view is part of the attached root view list.
+ if (mReactContextInitAsyncTask == null && mCurrentReactContext != null) {
+ attachMeasuredRootViewToInstance(rootView, mCurrentReactContext.getCatalystInstance());
+ }
+ }
+
+ /**
+ * Detach given {@param rootView} from current catalyst instance. It's safe to call this method
+ * multiple times on the same {@param rootView} - in that case view will be detached with the
+ * first call.
+ */
+ @Override
+ public void detachRootView(ReactRootView rootView) {
+ UiThreadUtil.assertOnUiThread();
+ if (mAttachedRootViews.remove(rootView)) {
+ if (mCurrentReactContext != null && mCurrentReactContext.hasActiveCatalystInstance()) {
+ detachViewFromInstance(rootView, mCurrentReactContext.getCatalystInstance());
+ }
+ }
+ }
+
+ /**
+ * Uses configured {@link ReactPackage} instances to create all view managers
+ */
+ @Override
+ public List createAllViewManagers(
+ ReactApplicationContext catalystApplicationContext) {
+ Systrace.beginSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "createAllViewManagers");
+ try {
+ List allViewManagers = new ArrayList<>();
+ for (ReactPackage reactPackage : mPackages) {
+ allViewManagers.addAll(reactPackage.createViewManagers(catalystApplicationContext));
+ }
+ return allViewManagers;
+ } finally {
+ Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
+ }
+ }
+
+ @Override
+ public void addReactInstanceEventListener(ReactInstanceEventListener listener) {
+ mReactInstanceEventListeners.add(listener);
+ }
+
+ @Override
+ public void removeReactInstanceEventListener(ReactInstanceEventListener listener) {
+ mReactInstanceEventListeners.remove(listener);
+ }
+
+ @VisibleForTesting
+ @Override
+ public @Nullable ReactContext getCurrentReactContext() {
+ return mCurrentReactContext;
+ }
+
+ private void onReloadWithJSDebugger(JavaJSExecutor.Factory jsExecutorFactory) {
+ recreateReactContextInBackground(
+ new ProxyJavaScriptExecutor.Factory(jsExecutorFactory),
+ JSBundleLoader.createRemoteDebuggerBundleLoader(
+ mDevSupportManager.getJSBundleURLForRemoteDebugging(),
+ mDevSupportManager.getSourceUrl()));
+ }
+
+ private void onJSBundleLoadedFromServer() {
+ recreateReactContextInBackground(
+ new JSCJavaScriptExecutor.Factory(),
+ JSBundleLoader.createCachedBundleFromNetworkLoader(
+ mDevSupportManager.getSourceUrl(),
+ mDevSupportManager.getDownloadedJSBundleFile()));
+ }
+
+ private void recreateReactContextInBackground(
+ JavaScriptExecutor.Factory jsExecutorFactory,
+ JSBundleLoader jsBundleLoader) {
+ UiThreadUtil.assertOnUiThread();
+
+ ReactContextInitParams initParams =
+ new ReactContextInitParams(jsExecutorFactory, jsBundleLoader);
+ if (mReactContextInitAsyncTask == null) {
+ // No background task to create react context is currently running, create and execute one.
+ mReactContextInitAsyncTask = new ReactContextInitAsyncTask();
+ mReactContextInitAsyncTask.execute(initParams);
+ } else {
+ // Background task is currently running, queue up most recent init params to recreate context
+ // once task completes.
+ mPendingReactContextInitParams = initParams;
+ }
+ }
+
+ private void setupReactContext(ReactApplicationContext reactContext) {
+ UiThreadUtil.assertOnUiThread();
+ Assertions.assertCondition(mCurrentReactContext == null);
+ mCurrentReactContext = Assertions.assertNotNull(reactContext);
+ CatalystInstance catalystInstance =
+ Assertions.assertNotNull(reactContext.getCatalystInstance());
+
+ catalystInstance.initialize();
+ mDevSupportManager.onNewReactContextCreated(reactContext);
+ mMemoryPressureRouter.addMemoryPressureListener(catalystInstance);
+ moveReactContextToCurrentLifecycleState();
+
+ for (ReactRootView rootView : mAttachedRootViews) {
+ attachMeasuredRootViewToInstance(rootView, catalystInstance);
+ }
+
+ ReactInstanceEventListener[] listeners =
+ new ReactInstanceEventListener[mReactInstanceEventListeners.size()];
+ listeners = mReactInstanceEventListeners.toArray(listeners);
+
+ for (ReactInstanceEventListener listener : listeners) {
+ listener.onReactContextInitialized(reactContext);
+ }
+ }
+
+ private void attachMeasuredRootViewToInstance(
+ ReactRootView rootView,
+ CatalystInstance catalystInstance) {
+ UiThreadUtil.assertOnUiThread();
+
+ // Reset view content as it's going to be populated by the application content from JS
+ rootView.removeAllViews();
+ rootView.setId(View.NO_ID);
+
+ UIManagerModule uiManagerModule = catalystInstance.getNativeModule(UIManagerModule.class);
+ int rootTag = uiManagerModule.addMeasuredRootView(rootView);
+ @Nullable Bundle launchOptions = rootView.getLaunchOptions();
+ WritableMap initialProps = launchOptions != null
+ ? Arguments.fromBundle(launchOptions)
+ : Arguments.createMap();
+ String jsAppModuleName = rootView.getJSModuleName();
+
+ WritableNativeMap appParams = new WritableNativeMap();
+ appParams.putDouble("rootTag", rootTag);
+ appParams.putMap("initialProps", initialProps);
+ catalystInstance.getJSModule(AppRegistry.class).runApplication(jsAppModuleName, appParams);
+ }
+
+ private void detachViewFromInstance(
+ ReactRootView rootView,
+ CatalystInstance catalystInstance) {
+ UiThreadUtil.assertOnUiThread();
+ catalystInstance.getJSModule(AppRegistry.class)
+ .unmountApplicationComponentAtRootTag(rootView.getId());
+ }
+
+ private void tearDownReactContext(ReactContext reactContext) {
+ UiThreadUtil.assertOnUiThread();
+ if (mLifecycleState == LifecycleState.RESUMED) {
+ reactContext.onHostPause();
+ }
+ for (ReactRootView rootView : mAttachedRootViews) {
+ detachViewFromInstance(rootView, reactContext.getCatalystInstance());
+ }
+ reactContext.destroy();
+ mDevSupportManager.onReactInstanceDestroyed(reactContext);
+ mMemoryPressureRouter.removeMemoryPressureListener(reactContext.getCatalystInstance());
+ }
+
+ /**
+ * @return instance of {@link ReactContext} configured a {@link CatalystInstance} set
+ */
+ private ReactApplicationContext createReactContext(
+ JavaScriptExecutor jsExecutor,
+ JSBundleLoader jsBundleLoader) {
+ FLog.i(ReactConstants.TAG, "Creating react context.");
+ ReactMarker.logMarker(CREATE_REACT_CONTEXT_START);
+ // CREATE_REACT_CONTEXT_END is in JSCExecutor.cpp
+ mSourceUrl = jsBundleLoader.getSourceUrl();
+ NativeModuleRegistry.Builder nativeRegistryBuilder = new NativeModuleRegistry.Builder();
+ JavaScriptModuleRegistry.Builder jsModulesBuilder = new JavaScriptModuleRegistry.Builder();
+
+ final ReactApplicationContext reactContext = new ReactApplicationContext(mApplicationContext);
+ if (mUseDeveloperSupport) {
+ reactContext.setNativeModuleCallExceptionHandler(mDevSupportManager);
+ }
+
+ ReactMarker.logMarker(PROCESS_PACKAGES_START);
+ Systrace.beginSection(
+ Systrace.TRACE_TAG_REACT_JAVA_BRIDGE,
+ "createAndProcessCoreModulesPackage");
+ try {
+ CoreModulesPackage coreModulesPackage =
+ new CoreModulesPackage(this, mBackBtnHandler, mUIImplementationProvider);
+ processPackage(coreModulesPackage, reactContext, nativeRegistryBuilder, jsModulesBuilder);
+ } finally {
+ Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
+ }
+
+ // TODO(6818138): Solve use-case of native/js modules overriding
+ for (ReactPackage reactPackage : mPackages) {
+ Systrace.beginSection(
+ Systrace.TRACE_TAG_REACT_JAVA_BRIDGE,
+ "createAndProcessCustomReactPackage");
+ try {
+ processPackage(reactPackage, reactContext, nativeRegistryBuilder, jsModulesBuilder);
+ } finally {
+ Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
+ }
+ }
+ ReactMarker.logMarker(PROCESS_PACKAGES_END);
+
+ ReactMarker.logMarker(BUILD_NATIVE_MODULE_REGISTRY_START);
+ Systrace.beginSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "buildNativeModuleRegistry");
+ NativeModuleRegistry nativeModuleRegistry;
+ try {
+ nativeModuleRegistry = nativeRegistryBuilder.build();
+ } finally {
+ Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
+ ReactMarker.logMarker(BUILD_NATIVE_MODULE_REGISTRY_END);
+ }
+
+ NativeModuleCallExceptionHandler exceptionHandler = mNativeModuleCallExceptionHandler != null
+ ? mNativeModuleCallExceptionHandler
+ : mDevSupportManager;
+ CatalystInstanceImpl.Builder catalystInstanceBuilder = new CatalystInstanceImpl.Builder()
+ .setReactQueueConfigurationSpec(ReactQueueConfigurationSpec.createDefault())
+ .setJSExecutor(jsExecutor)
+ .setRegistry(nativeModuleRegistry)
+ .setJSModuleRegistry(jsModulesBuilder.build())
+ .setJSBundleLoader(jsBundleLoader)
+ .setNativeModuleCallExceptionHandler(exceptionHandler);
+
+ ReactMarker.logMarker(CREATE_CATALYST_INSTANCE_START);
+ Systrace.beginSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "createCatalystInstance");
+ final CatalystInstance catalystInstance;
+ try {
+ catalystInstance = catalystInstanceBuilder.build();
+ } finally {
+ Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
+ ReactMarker.logMarker(CREATE_CATALYST_INSTANCE_END);
+ }
+
+ if (mBridgeIdleDebugListener != null) {
+ catalystInstance.addBridgeIdleDebugListener(mBridgeIdleDebugListener);
+ }
+
+ try {
+ catalystInstance.getReactQueueConfiguration().getJSQueueThread().callOnQueue(
+ new Callable() {
+ @Override
+ public Void call() {
+ // We want to ensure that any code that checks ReactContext#hasActiveCatalystInstance
+ // can be sure that it's safe to call a JS module function. As JS module function calls
+ // execute on the JS thread, and this Runnable runs on the JS thread, at this point we
+ // know that no JS module function calls will be executed until after this Runnable completes.
+ //
+ // This means it is now safe to say the instance is initialized.
+ //
+ // The reason we call this here instead of after this Runnable completes is so that we can
+ // reduce the amount of time until the React instance is able to start accepting JS calls,
+ // and so that any native module calls that result from runJSBundle can access JS modules.
+ reactContext.initializeWithInstance(catalystInstance);
+
+ ReactMarker.logMarker(RUN_JS_BUNDLE_START);
+ // RUN_JS_BUNDLE_END is in JSCExecutor.cpp
+ Systrace.beginSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "runJSBundle");
+ try {
+ catalystInstance.runJSBundle();
+ } finally {
+ // This will actually finish when `JSCExecutor#loadApplicationScript()` finishes
+ Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
+ }
+ return null;
+ }
+ }).get();
+ } catch (InterruptedException | ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+
+ return reactContext;
+ }
+
+ private void processPackage(
+ ReactPackage reactPackage,
+ ReactApplicationContext reactContext,
+ NativeModuleRegistry.Builder nativeRegistryBuilder,
+ JavaScriptModuleRegistry.Builder jsModulesBuilder) {
+ for (NativeModule nativeModule : reactPackage.createNativeModules(reactContext)) {
+ nativeRegistryBuilder.add(nativeModule);
+ }
+ for (Class jsModuleClass : reactPackage.createJSModules()) {
+ jsModulesBuilder.add(jsModuleClass);
+ }
+ }
+
+ private void moveReactContextToCurrentLifecycleState() {
+ if (mLifecycleState == LifecycleState.RESUMED) {
+ moveToResumedLifecycleState(true);
+ }
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/ReactNativeHost.java b/android/ReactAndroid/src/main/java/com/facebook/react/ReactNativeHost.java
new file mode 100644
index 00000000000000..b302024426b3bb
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/ReactNativeHost.java
@@ -0,0 +1,125 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react;
+
+import javax.annotation.Nullable;
+
+import java.util.List;
+
+import android.app.Application;
+
+import com.facebook.infer.annotation.Assertions;
+
+/**
+ * Simple class that holds an instance of {@link ReactInstanceManager}. This can be used in your
+ * {@link Application class} (see {@link ReactApplication}), or as a static field.
+ */
+public abstract class ReactNativeHost {
+
+ private final Application mApplication;
+ private @Nullable ReactInstanceManager mReactInstanceManager;
+
+ protected ReactNativeHost(Application application) {
+ mApplication = application;
+ }
+
+ /**
+ * Get the current {@link ReactInstanceManager} instance, or create one.
+ */
+ public ReactInstanceManager getReactInstanceManager() {
+ if (mReactInstanceManager == null) {
+ mReactInstanceManager = createReactInstanceManager();
+ }
+ return mReactInstanceManager;
+ }
+
+ /**
+ * Get whether this holder contains a {@link ReactInstanceManager} instance, or not. I.e. if
+ * {@link #getReactInstanceManager()} has been called at least once since this object was created
+ * or {@link #clear()} was called.
+ */
+ public boolean hasInstance() {
+ return mReactInstanceManager != null;
+ }
+
+ /**
+ * Destroy the current instance and release the internal reference to it, allowing it to be GCed.
+ */
+ public void clear() {
+ if (mReactInstanceManager != null) {
+ mReactInstanceManager.destroy();
+ mReactInstanceManager = null;
+ }
+ }
+
+ protected ReactInstanceManager createReactInstanceManager() {
+ ReactInstanceManager.Builder builder = ReactInstanceManager.builder()
+ .setApplication(mApplication)
+ .setJSMainModuleName(getJSMainModuleName())
+ .setUseDeveloperSupport(getUseDeveloperSupport())
+ .setInitialLifecycleState(LifecycleState.BEFORE_CREATE);
+
+ for (ReactPackage reactPackage : getPackages()) {
+ builder.addPackage(reactPackage);
+ }
+
+ String jsBundleFile = getJSBundleFile();
+ if (jsBundleFile != null) {
+ builder.setJSBundleFile(jsBundleFile);
+ } else {
+ builder.setBundleAssetName(Assertions.assertNotNull(getBundleAssetName()));
+ }
+
+ return builder.build();
+ }
+
+ /**
+ * Returns the name of the main module. Determines the URL used to fetch the JS bundle
+ * from the packager server. It is only used when dev support is enabled.
+ * This is the first file to be executed once the {@link ReactInstanceManager} is created.
+ * e.g. "index.android"
+ */
+ protected String getJSMainModuleName() {
+ return "index.android";
+ }
+
+ /**
+ * Returns a custom path of the bundle file. This is used in cases the bundle should be loaded
+ * from a custom path. By default it is loaded from Android assets, from a path specified
+ * by {@link getBundleAssetName}.
+ * e.g. "file://sdcard/myapp_cache/index.android.bundle"
+ */
+ protected @Nullable String getJSBundleFile() {
+ return null;
+ }
+
+ /**
+ * Returns the name of the bundle in assets. If this is null, and no file path is specified for
+ * the bundle, the app will only work with {@code getUseDeveloperSupport} enabled and will
+ * always try to load the JS bundle from the packager server.
+ * e.g. "index.android.bundle"
+ */
+ protected @Nullable String getBundleAssetName() {
+ return "index.android.bundle";
+ }
+
+ /**
+ * Returns whether dev mode should be enabled. This enables e.g. the dev menu.
+ */
+ protected abstract boolean getUseDeveloperSupport();
+
+ /**
+ * Returns a list of {@link ReactPackage} used by the app.
+ * You'll most likely want to return at least the {@code MainReactPackage}.
+ * If your app uses additional views or modules besides the default ones,
+ * you'll want to include more packages here.
+ */
+ protected abstract List getPackages();
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/ReactPackage.java b/android/ReactAndroid/src/main/java/com/facebook/react/ReactPackage.java
new file mode 100644
index 00000000000000..f11c2408cf0642
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/ReactPackage.java
@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react;
+
+import java.util.List;
+
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.uimanager.UIManagerModule;
+import com.facebook.react.uimanager.ViewManager;
+
+/**
+ * Main interface for providing additional capabilities to the catalyst framework by couple of
+ * different means:
+ * 1) Registering new native modules
+ * 2) Registering new JS modules that may be accessed from native modules or from other parts of the
+ * native code (requiring JS modules from the package doesn't mean it will automatically be included
+ * as a part of the JS bundle, so there should be a corresponding piece of code on JS side that will
+ * require implementation of that JS module so that it gets bundled)
+ * 3) Registering custom native views (view managers) and custom event types
+ * 4) Registering natively packaged assets/resources (e.g. images) exposed to JS
+ *
+ * TODO(6788500, 6788507): Implement support for adding custom views, events and resources
+ */
+public interface ReactPackage {
+
+ /**
+ * @param reactContext react application context that can be used to create modules
+ * @return list of native modules to register with the newly created catalyst instance
+ */
+ List createNativeModules(ReactApplicationContext reactContext);
+
+ /**
+ * @return list of JS modules to register with the newly created catalyst instance.
+ *
+ * IMPORTANT: Note that only modules that needs to be accessible from the native code should be
+ * listed here. Also listing a native module here doesn't imply that the JS implementation of it
+ * will be automatically included in the JS bundle.
+ */
+ List> createJSModules();
+
+ /**
+ * @return a list of view managers that should be registered with {@link UIManagerModule}
+ */
+ List createViewManagers(ReactApplicationContext reactContext);
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/ReactRootView.java b/android/ReactAndroid/src/main/java/com/facebook/react/ReactRootView.java
new file mode 100644
index 00000000000000..50f7f4077bb764
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/ReactRootView.java
@@ -0,0 +1,334 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react;
+
+import javax.annotation.Nullable;
+
+import android.content.Context;
+import android.graphics.Rect;
+import android.os.Bundle;
+import android.util.AttributeSet;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewTreeObserver;
+
+import com.facebook.common.logging.FLog;
+import com.facebook.infer.annotation.Assertions;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.UiThreadUtil;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.common.ReactConstants;
+import com.facebook.react.common.annotations.VisibleForTesting;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.facebook.react.uimanager.DisplayMetricsHolder;
+import com.facebook.react.uimanager.PixelUtil;
+import com.facebook.react.uimanager.RootView;
+import com.facebook.react.uimanager.SizeMonitoringFrameLayout;
+import com.facebook.react.uimanager.JSTouchDispatcher;
+import com.facebook.react.uimanager.UIManagerModule;
+import com.facebook.react.uimanager.events.EventDispatcher;
+
+/**
+ * Default root view for catalyst apps. Provides the ability to listen for size changes so that a UI
+ * manager can re-layout its elements.
+ * It delegates handling touch events for itself and child views and sending those events to JS by
+ * using JSTouchDispatcher.
+ * This view is overriding {@link ViewGroup#onInterceptTouchEvent} method in order to be notified
+ * about the events for all of it's children and it's also overriding
+ * {@link ViewGroup#requestDisallowInterceptTouchEvent} to make sure that
+ * {@link ViewGroup#onInterceptTouchEvent} will get events even when some child view start
+ * intercepting it. In case when no child view is interested in handling some particular
+ * touch event this view's {@link View#onTouchEvent} will still return true in order to be notified
+ * about all subsequent touch events related to that gesture (in case when JS code want to handle
+ * that gesture).
+ */
+public class ReactRootView extends SizeMonitoringFrameLayout implements RootView {
+
+ private @Nullable ReactInstanceManager mReactInstanceManager;
+ private @Nullable String mJSModuleName;
+ private @Nullable Bundle mLaunchOptions;
+ private @Nullable KeyboardListener mKeyboardListener;
+ private @Nullable OnGenericMotionListener mOnGenericMotionListener;
+ private boolean mWasMeasured = false;
+ private boolean mIsAttachedToInstance = false;
+ private final JSTouchDispatcher mJSTouchDispatcher = new JSTouchDispatcher(this);
+
+ public ReactRootView(Context context) {
+ super(context);
+ }
+
+ public ReactRootView(Context context, AttributeSet attrs) {
+ super(context, attrs);
+ }
+
+ public ReactRootView(Context context, AttributeSet attrs, int defStyle) {
+ super(context, attrs, defStyle);
+ }
+
+ @Override
+ protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+ int widthMode = MeasureSpec.getMode(widthMeasureSpec);
+ int heightMode = MeasureSpec.getMode(heightMeasureSpec);
+
+ if (widthMode == MeasureSpec.UNSPECIFIED || heightMode == MeasureSpec.UNSPECIFIED) {
+ throw new IllegalStateException(
+ "The root catalyst view must have a width and height given to it by it's parent view. " +
+ "You can do this by specifying MATCH_PARENT or explicit width and height in the layout.");
+ }
+
+ setMeasuredDimension(
+ MeasureSpec.getSize(widthMeasureSpec),
+ MeasureSpec.getSize(heightMeasureSpec));
+
+ mWasMeasured = true;
+ // Check if we were waiting for onMeasure to attach the root view
+ if (mReactInstanceManager != null && !mIsAttachedToInstance) {
+ // Enqueue it to UIThread not to block onMeasure waiting for the catalyst instance creation
+ UiThreadUtil.runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ attachToReactInstanceManager();
+ }
+ });
+ }
+ }
+
+ @Override
+ public void onChildStartedNativeGesture(MotionEvent androidEvent) {
+ if (mReactInstanceManager == null || !mIsAttachedToInstance ||
+ mReactInstanceManager.getCurrentReactContext() == null) {
+ FLog.w(
+ ReactConstants.TAG,
+ "Unable to dispatch touch to JS as the catalyst instance has not been attached");
+ return;
+ }
+ ReactContext reactContext = mReactInstanceManager.getCurrentReactContext();
+ EventDispatcher eventDispatcher = reactContext.getNativeModule(UIManagerModule.class)
+ .getEventDispatcher();
+ mJSTouchDispatcher.onChildStartedNativeGesture(androidEvent, eventDispatcher);
+ // Hook for containers or fragments to get informed of the on touch events to perform actions.
+ if (mOnGenericMotionListener != null) {
+ mOnGenericMotionListener.onGenericMotion(this, androidEvent);
+ }
+ }
+
+ @Override
+ public boolean onInterceptTouchEvent(MotionEvent ev) {
+ dispatchJSTouchEvent(ev);
+ return super.onInterceptTouchEvent(ev);
+ }
+
+ @Override
+ public boolean onTouchEvent(MotionEvent ev) {
+ dispatchJSTouchEvent(ev);
+ super.onTouchEvent(ev);
+ // In case when there is no children interested in handling touch event, we return true from
+ // the root view in order to receive subsequent events related to that gesture
+ return true;
+ }
+
+ public void setOnGenericMotionListener(OnGenericMotionListener listener) {
+ mOnGenericMotionListener = listener;
+ }
+
+ private void dispatchJSTouchEvent(MotionEvent event) {
+ if (mReactInstanceManager == null || !mIsAttachedToInstance ||
+ mReactInstanceManager.getCurrentReactContext() == null) {
+ FLog.w(
+ ReactConstants.TAG,
+ "Unable to dispatch touch to JS as the catalyst instance has not been attached");
+ return;
+ }
+ ReactContext reactContext = mReactInstanceManager.getCurrentReactContext();
+ EventDispatcher eventDispatcher = reactContext.getNativeModule(UIManagerModule.class)
+ .getEventDispatcher();
+ mJSTouchDispatcher.handleTouchEvent(event, eventDispatcher);
+ }
+
+ @Override
+ public void requestDisallowInterceptTouchEvent(boolean disallowIntercept) {
+ // No-op - override in order to still receive events to onInterceptTouchEvent
+ // even when some other view disallow that
+ }
+
+ @Override
+ protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
+ // No-op since UIManagerModule handles actually laying out children.
+ }
+
+ @Override
+ protected void onAttachedToWindow() {
+ super.onAttachedToWindow();
+ if (mIsAttachedToInstance) {
+ getViewTreeObserver().addOnGlobalLayoutListener(getKeyboardListener());
+ }
+ }
+
+ @Override
+ protected void onDetachedFromWindow() {
+ super.onDetachedFromWindow();
+ if (mIsAttachedToInstance) {
+ getViewTreeObserver().removeOnGlobalLayoutListener(getKeyboardListener());
+ }
+ }
+
+ /**
+ * {@see #startReactApplication(ReactInstanceManager, String, android.os.Bundle)}
+ */
+ public void startReactApplication(ReactInstanceManager reactInstanceManager, String moduleName) {
+ startReactApplication(reactInstanceManager, moduleName, null);
+ }
+
+ /**
+ * Schedule rendering of the react component rendered by the JS application from the given JS
+ * module (@{param moduleName}) using provided {@param reactInstanceManager} to attach to the
+ * JS context of that manager. Extra parameter {@param launchOptions} can be used to pass initial
+ * properties for the react component.
+ */
+ public void startReactApplication(
+ ReactInstanceManager reactInstanceManager,
+ String moduleName,
+ @Nullable Bundle launchOptions) {
+ UiThreadUtil.assertOnUiThread();
+
+ // TODO(6788889): Use POJO instead of bundle here, apparently we can't just use WritableMap
+ // here as it may be deallocated in native after passing via JNI bridge, but we want to reuse
+ // it in the case of re-creating the catalyst instance
+ Assertions.assertCondition(
+ mReactInstanceManager == null,
+ "This root view has already been attached to a catalyst instance manager");
+
+ mReactInstanceManager = reactInstanceManager;
+ mJSModuleName = moduleName;
+ mLaunchOptions = launchOptions;
+
+ if (!mReactInstanceManager.hasStartedCreatingInitialContext()) {
+ mReactInstanceManager.createReactContextInBackground();
+ }
+
+ // We need to wait for the initial onMeasure, if this view has not yet been measured, we set which
+ // will make this view startReactApplication itself to instance manager once onMeasure is called.
+ if (mWasMeasured) {
+ attachToReactInstanceManager();
+ }
+ }
+
+ /**
+ * Unmount the react application at this root view, reclaiming any JS memory associated with that
+ * application. If {@link #startReactApplication} is called, this method must be called before the
+ * ReactRootView is garbage collected (typically in your Activity's onDestroy, or in your Fragment's
+ * onDestroyView).
+ */
+ public void unmountReactApplication() {
+ if (mReactInstanceManager != null && mIsAttachedToInstance) {
+ mReactInstanceManager.detachRootView(this);
+ mIsAttachedToInstance = false;
+ }
+ }
+
+ /* package */ String getJSModuleName() {
+ return Assertions.assertNotNull(mJSModuleName);
+ }
+
+ /* package */ @Nullable Bundle getLaunchOptions() {
+ return mLaunchOptions;
+ }
+
+ /**
+ * Is used by unit test to setup mWasMeasured and mIsAttachedToWindow flags, that will let this
+ * view to be properly attached to catalyst instance by startReactApplication call
+ */
+ @VisibleForTesting
+ /* package */ void simulateAttachForTesting() {
+ mIsAttachedToInstance = true;
+ mWasMeasured = true;
+ }
+
+ private KeyboardListener getKeyboardListener() {
+ if (mKeyboardListener == null) {
+ mKeyboardListener = new KeyboardListener();
+ }
+ return mKeyboardListener;
+ }
+
+ private void attachToReactInstanceManager() {
+ if (mIsAttachedToInstance) {
+ return;
+ }
+
+ mIsAttachedToInstance = true;
+ Assertions.assertNotNull(mReactInstanceManager).attachMeasuredRootView(this);
+ getViewTreeObserver().addOnGlobalLayoutListener(getKeyboardListener());
+ }
+
+ @Override
+ protected void finalize() throws Throwable {
+ super.finalize();
+ Assertions.assertCondition(
+ !mIsAttachedToInstance,
+ "The application this ReactRootView was rendering was not unmounted before the ReactRootView " +
+ "was garbage collected. This usually means that your application is leaking large amounts of " +
+ "memory. To solve this, make sure to call ReactRootView#unmountReactApplication in the onDestroy() " +
+ "of your hosting Activity or in the onDestroyView() of your hosting Fragment.");
+ }
+
+ private class KeyboardListener implements ViewTreeObserver.OnGlobalLayoutListener {
+ private final Rect mVisibleViewArea;
+ private final int mMinKeyboardHeightDetected;
+
+ private int mKeyboardHeight = 0;
+
+ /* package */ KeyboardListener() {
+ mVisibleViewArea = new Rect();
+ mMinKeyboardHeightDetected = (int) PixelUtil.toPixelFromDIP(60);
+ }
+
+ @Override
+ public void onGlobalLayout() {
+ if (mReactInstanceManager == null || !mIsAttachedToInstance ||
+ mReactInstanceManager.getCurrentReactContext() == null) {
+ FLog.w(
+ ReactConstants.TAG,
+ "Unable to dispatch keyboard events in JS as the react instance has not been attached");
+ return;
+ }
+
+ getRootView().getWindowVisibleDisplayFrame(mVisibleViewArea);
+ final int heightDiff =
+ DisplayMetricsHolder.getWindowDisplayMetrics().heightPixels - mVisibleViewArea.bottom;
+ if (mKeyboardHeight != heightDiff && heightDiff > mMinKeyboardHeightDetected) {
+ // keyboard is now showing, or the keyboard height has changed
+ mKeyboardHeight = heightDiff;
+ WritableMap params = Arguments.createMap();
+ WritableMap coordinates = Arguments.createMap();
+ coordinates.putDouble("screenY", PixelUtil.toDIPFromPixel(mVisibleViewArea.bottom));
+ coordinates.putDouble("screenX", PixelUtil.toDIPFromPixel(mVisibleViewArea.left));
+ coordinates.putDouble("width", PixelUtil.toDIPFromPixel(mVisibleViewArea.width()));
+ coordinates.putDouble("height", PixelUtil.toDIPFromPixel(mKeyboardHeight));
+ params.putMap("endCoordinates", coordinates);
+ sendEvent("keyboardDidShow", params);
+ } else if (mKeyboardHeight != 0 && heightDiff <= mMinKeyboardHeightDetected) {
+ // keyboard is now hidden
+ mKeyboardHeight = 0;
+ sendEvent("keyboardDidHide", null);
+ }
+ }
+
+ private void sendEvent(String eventName, @Nullable WritableMap params) {
+ if (mReactInstanceManager != null) {
+ mReactInstanceManager.getCurrentReactContext()
+ .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+ .emit(eventName, params);
+ }
+ }
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/XReactInstanceManagerImpl.java b/android/ReactAndroid/src/main/java/com/facebook/react/XReactInstanceManagerImpl.java
new file mode 100644
index 00000000000000..adc4ff8d454938
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/XReactInstanceManagerImpl.java
@@ -0,0 +1,927 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react;
+
+import javax.annotation.Nullable;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+
+import android.app.Activity;
+import android.app.Application;
+import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.AsyncTask;
+import android.os.Bundle;
+import android.os.Process;
+import android.view.View;
+
+import com.facebook.common.logging.FLog;
+import com.facebook.infer.annotation.Assertions;
+import com.facebook.react.bridge.CatalystInstance;
+import com.facebook.react.bridge.JavaJSExecutor;
+import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.bridge.JavaScriptModuleRegistry;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.NativeModuleCallExceptionHandler;
+import com.facebook.react.bridge.NotThreadSafeBridgeIdleDebugListener;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.ReactMarker;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+import com.facebook.react.bridge.queue.ReactQueueConfigurationSpec;
+import com.facebook.react.common.ApplicationHolder;
+import com.facebook.react.common.ReactConstants;
+import com.facebook.react.common.annotations.VisibleForTesting;
+import com.facebook.react.cxxbridge.Arguments;
+import com.facebook.react.cxxbridge.CatalystInstanceImpl;
+import com.facebook.react.cxxbridge.JSBundleLoader;
+import com.facebook.react.cxxbridge.JSCJavaScriptExecutor;
+import com.facebook.react.cxxbridge.JavaScriptExecutor;
+import com.facebook.react.cxxbridge.NativeModuleRegistry;
+import com.facebook.react.cxxbridge.ProxyJavaScriptExecutor;
+import com.facebook.react.cxxbridge.UiThreadUtil;
+import com.facebook.react.devsupport.DevServerHelper;
+import com.facebook.react.devsupport.DevSupportManager;
+import com.facebook.react.devsupport.DevSupportManagerFactory;
+import com.facebook.react.devsupport.ReactInstanceDevCommandsHandler;
+import com.facebook.react.devsupport.RedBoxHandler;
+import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.facebook.react.modules.debug.DeveloperSettings;
+import com.facebook.react.views.imagehelper.ResourceDrawableIdHelper;
+import com.facebook.react.uimanager.AppRegistry;
+import com.facebook.react.uimanager.DisplayMetricsHolder;
+import com.facebook.react.uimanager.UIImplementationProvider;
+import com.facebook.react.uimanager.UIManagerModule;
+import com.facebook.react.uimanager.ViewManager;
+import com.facebook.soloader.SoLoader;
+import com.facebook.systrace.Systrace;
+
+import static com.facebook.react.bridge.ReactMarkerConstants.BUILD_NATIVE_MODULE_REGISTRY_END;
+import static com.facebook.react.bridge.ReactMarkerConstants.BUILD_NATIVE_MODULE_REGISTRY_START;
+import static com.facebook.react.bridge.ReactMarkerConstants.CREATE_CATALYST_INSTANCE_END;
+import static com.facebook.react.bridge.ReactMarkerConstants.CREATE_CATALYST_INSTANCE_START;
+import static com.facebook.react.bridge.ReactMarkerConstants.CREATE_REACT_CONTEXT_START;
+import static com.facebook.react.bridge.ReactMarkerConstants.PROCESS_PACKAGES_END;
+import static com.facebook.react.bridge.ReactMarkerConstants.PROCESS_PACKAGES_START;
+import static com.facebook.react.bridge.ReactMarkerConstants.RUN_JS_BUNDLE_END;
+import static com.facebook.react.bridge.ReactMarkerConstants.RUN_JS_BUNDLE_START;
+import static com.facebook.systrace.Systrace.TRACE_TAG_REACT_JAVA_BRIDGE;
+
+/**
+ * This class is managing instances of {@link CatalystInstance}. It expose a way to configure
+ * catalyst instance using {@link ReactPackage} and keeps track of the lifecycle of that
+ * instance. It also sets up connection between the instance and developers support functionality
+ * of the framework.
+ *
+ * An instance of this manager is required to start JS application in {@link ReactRootView} (see
+ * {@link ReactRootView#startReactApplication} for more info).
+ *
+ * The lifecycle of the instance of {@link XReactInstanceManagerImpl} should be bound to the
+ * activity that owns the {@link ReactRootView} that is used to render react application using this
+ * instance manager (see {@link ReactRootView#startReactApplication}). It's required to pass owning
+ * activity's lifecycle events to the instance manager (see {@link #onHostPause}, {@link
+ * #onHostDestroy} and {@link #onHostResume}).
+ *
+ * To instantiate an instance of this class use {@link #builder}.
+ */
+/* package */ class XReactInstanceManagerImpl extends ReactInstanceManager {
+
+ /* should only be accessed from main thread (UI thread) */
+ private final List mAttachedRootViews = new ArrayList<>();
+ private LifecycleState mLifecycleState;
+ private @Nullable ReactContextInitParams mPendingReactContextInitParams;
+ private @Nullable ReactContextInitAsyncTask mReactContextInitAsyncTask;
+
+ /* accessed from any thread */
+ private final @Nullable JSBundleLoader mBundleLoader; /* path to JS bundle on file system */
+ private final @Nullable String mJSMainModuleName; /* path to JS bundle root on packager server */
+ private final List mPackages;
+ private final DevSupportManager mDevSupportManager;
+ private final boolean mUseDeveloperSupport;
+ private final @Nullable NotThreadSafeBridgeIdleDebugListener mBridgeIdleDebugListener;
+ private @Nullable volatile ReactContext mCurrentReactContext;
+ private final Context mApplicationContext;
+ private @Nullable DefaultHardwareBackBtnHandler mDefaultBackButtonImpl;
+ private String mSourceUrl;
+ private @Nullable Activity mCurrentActivity;
+ private final Collection mReactInstanceEventListeners =
+ Collections.synchronizedSet(new HashSet());
+ private volatile boolean mHasStartedCreatingInitialContext = false;
+ private final UIImplementationProvider mUIImplementationProvider;
+ private final MemoryPressureRouter mMemoryPressureRouter;
+ private final @Nullable NativeModuleCallExceptionHandler mNativeModuleCallExceptionHandler;
+ private final JSCConfig mJSCConfig;
+
+ private final ReactInstanceDevCommandsHandler mDevInterface =
+ new ReactInstanceDevCommandsHandler() {
+
+ @Override
+ public void onReloadWithJSDebugger(JavaJSExecutor.Factory jsExecutorFactory) {
+ XReactInstanceManagerImpl.this.onReloadWithJSDebugger(jsExecutorFactory);
+ }
+
+ @Override
+ public void onJSBundleLoadedFromServer() {
+ XReactInstanceManagerImpl.this.onJSBundleLoadedFromServer();
+ }
+
+ @Override
+ public void toggleElementInspector() {
+ XReactInstanceManagerImpl.this.toggleElementInspector();
+ }
+ };
+
+ private final DefaultHardwareBackBtnHandler mBackBtnHandler =
+ new DefaultHardwareBackBtnHandler() {
+ @Override
+ public void invokeDefaultOnBackPressed() {
+ XReactInstanceManagerImpl.this.invokeDefaultOnBackPressed();
+ }
+ };
+
+ private class ReactContextInitParams {
+ private final JavaScriptExecutor.Factory mJsExecutorFactory;
+ private final JSBundleLoader mJsBundleLoader;
+
+ public ReactContextInitParams(
+ JavaScriptExecutor.Factory jsExecutorFactory,
+ JSBundleLoader jsBundleLoader) {
+ mJsExecutorFactory = Assertions.assertNotNull(jsExecutorFactory);
+ mJsBundleLoader = Assertions.assertNotNull(jsBundleLoader);
+ }
+
+ public JavaScriptExecutor.Factory getJsExecutorFactory() {
+ return mJsExecutorFactory;
+ }
+
+ public JSBundleLoader getJsBundleLoader() {
+ return mJsBundleLoader;
+ }
+ }
+
+ /*
+ * Task class responsible for (re)creating react context in the background. These tasks can only
+ * be executing one at time, see {@link #recreateReactContextInBackground()}.
+ */
+ private final class ReactContextInitAsyncTask extends
+ AsyncTask> {
+ @Override
+ protected void onPreExecute() {
+ if (mCurrentReactContext != null) {
+ tearDownReactContext(mCurrentReactContext);
+ mCurrentReactContext = null;
+ }
+ }
+
+ @Override
+ protected Result doInBackground(ReactContextInitParams... params) {
+ // TODO(t11687218): Look over all threading
+ // Default priority is Process.THREAD_PRIORITY_BACKGROUND which means we'll be put in a cgroup
+ // that only has access to a small fraction of CPU time. The priority will be reset after
+ // this task finishes: https://android.googlesource.com/platform/frameworks/base/+/d630f105e8bc0021541aacb4dc6498a49048ecea/core/java/android/os/AsyncTask.java#256
+ Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
+
+ Assertions.assertCondition(params != null && params.length > 0 && params[0] != null);
+ try {
+ JavaScriptExecutor jsExecutor = params[0].getJsExecutorFactory().create();
+ return Result.of(createReactContext(jsExecutor, params[0].getJsBundleLoader()));
+ } catch (Exception e) {
+ // Pass exception to onPostExecute() so it can be handled on the main thread
+ return Result.of(e);
+ }
+ }
+
+ @Override
+ protected void onPostExecute(Result result) {
+ try {
+ setupReactContext(result.get());
+ } catch (Exception e) {
+ mDevSupportManager.handleException(e);
+ } finally {
+ mReactContextInitAsyncTask = null;
+ }
+
+ // Handle enqueued request to re-initialize react context.
+ if (mPendingReactContextInitParams != null) {
+ recreateReactContextInBackground(
+ mPendingReactContextInitParams.getJsExecutorFactory(),
+ mPendingReactContextInitParams.getJsBundleLoader());
+ mPendingReactContextInitParams = null;
+ }
+ }
+
+ @Override
+ protected void onCancelled(Result reactApplicationContextResult) {
+ try {
+ mMemoryPressureRouter.destroy(reactApplicationContextResult.get());
+ } catch (Exception e) {
+ FLog.w(ReactConstants.TAG, "Caught exception after cancelling react context init", e);
+ } finally {
+ mReactContextInitAsyncTask = null;
+ }
+ }
+ }
+
+ private static class Result {
+ @Nullable private final T mResult;
+ @Nullable private final Exception mException;
+
+ public static Result of(U result) {
+ return new Result(result);
+ }
+
+ public static Result of(Exception exception) {
+ return new Result<>(exception);
+ }
+
+ private Result(T result) {
+ mException = null;
+ mResult = result;
+ }
+
+ private Result(Exception exception) {
+ mException = exception;
+ mResult = null;
+ }
+
+ public T get() throws Exception {
+ if (mException != null) {
+ throw mException;
+ }
+
+ Assertions.assertNotNull(mResult);
+
+ return mResult;
+ }
+ }
+
+ /* package */ XReactInstanceManagerImpl(
+ Context applicationContext,
+ @Nullable Activity currentActivity,
+ @Nullable DefaultHardwareBackBtnHandler defaultHardwareBackBtnHandler,
+ @Nullable JSBundleLoader bundleLoader,
+ @Nullable String jsMainModuleName,
+ List packages,
+ boolean useDeveloperSupport,
+ @Nullable NotThreadSafeBridgeIdleDebugListener bridgeIdleDebugListener,
+ LifecycleState initialLifecycleState,
+ UIImplementationProvider uiImplementationProvider,
+ NativeModuleCallExceptionHandler nativeModuleCallExceptionHandler,
+ JSCConfig jscConfig,
+ @Nullable RedBoxHandler redBoxHandler) {
+
+ initializeSoLoaderIfNecessary(applicationContext);
+
+ // TODO(9577825): remove this
+ ApplicationHolder.setApplication((Application) applicationContext.getApplicationContext());
+ DisplayMetricsHolder.initDisplayMetricsIfNotInitialized(applicationContext);
+
+ mApplicationContext = applicationContext;
+ mCurrentActivity = currentActivity;
+ mDefaultBackButtonImpl = defaultHardwareBackBtnHandler;
+ mBundleLoader = bundleLoader;
+ mJSMainModuleName = jsMainModuleName;
+ mPackages = packages;
+ mUseDeveloperSupport = useDeveloperSupport;
+ mDevSupportManager = DevSupportManagerFactory.create(
+ applicationContext,
+ mDevInterface,
+ mJSMainModuleName,
+ useDeveloperSupport,
+ redBoxHandler);
+ mBridgeIdleDebugListener = bridgeIdleDebugListener;
+ mLifecycleState = initialLifecycleState;
+ mUIImplementationProvider = uiImplementationProvider;
+ mMemoryPressureRouter = new MemoryPressureRouter(applicationContext);
+ mNativeModuleCallExceptionHandler = nativeModuleCallExceptionHandler;
+ mJSCConfig = jscConfig;
+ }
+
+ @Override
+ public DevSupportManager getDevSupportManager() {
+ return mDevSupportManager;
+ }
+
+ @Override
+ public MemoryPressureRouter getMemoryPressureRouter() {
+ return mMemoryPressureRouter;
+ }
+
+ private static void initializeSoLoaderIfNecessary(Context applicationContext) {
+ // Call SoLoader.initialize here, this is required for apps that does not use exopackage and
+ // does not use SoLoader for loading other native code except from the one used by React Native
+ // This way we don't need to require others to have additional initialization code and to
+ // subclass android.app.Application.
+
+ // Method SoLoader.init is idempotent, so if you wish to use native exopackage, just call
+ // SoLoader.init with appropriate args before initializing XReactInstanceManagerImpl
+ SoLoader.init(applicationContext, /* native exopackage */ false);
+ }
+
+ /**
+ * Trigger react context initialization asynchronously in a background async task. This enables
+ * applications to pre-load the application JS, and execute global code before
+ * {@link ReactRootView} is available and measured. This should only be called the first time the
+ * application is set up, which is enforced to keep developers from accidentally creating their
+ * application multiple times without realizing it.
+ *
+ * Called from UI thread.
+ */
+ @Override
+ public void createReactContextInBackground() {
+ Assertions.assertCondition(
+ !mHasStartedCreatingInitialContext,
+ "createReactContextInBackground should only be called when creating the react " +
+ "application for the first time. When reloading JS, e.g. from a new file, explicitly" +
+ "use recreateReactContextInBackground");
+
+ mHasStartedCreatingInitialContext = true;
+ recreateReactContextInBackgroundInner();
+ }
+
+ /**
+ * Recreate the react application and context. This should be called if configuration has
+ * changed or the developer has requested the app to be reloaded. It should only be called after
+ * an initial call to createReactContextInBackground.
+ *
+ * Called from UI thread.
+ */
+ public void recreateReactContextInBackground() {
+ Assertions.assertCondition(
+ mHasStartedCreatingInitialContext,
+ "recreateReactContextInBackground should only be called after the initial " +
+ "createReactContextInBackground call.");
+ recreateReactContextInBackgroundInner();
+ }
+
+ private void recreateReactContextInBackgroundInner() {
+ UiThreadUtil.assertOnUiThread();
+
+ if (mUseDeveloperSupport && mJSMainModuleName != null) {
+ final DeveloperSettings devSettings = mDevSupportManager.getDevSettings();
+
+ // If remote JS debugging is enabled, load from dev server.
+ if (mDevSupportManager.hasUpToDateJSBundleInCache() &&
+ !devSettings.isRemoteJSDebugEnabled()) {
+ // If there is a up-to-date bundle downloaded from server,
+ // with remote JS debugging disabled, always use that.
+ onJSBundleLoadedFromServer();
+ } else if (mBundleLoader == null) {
+ mDevSupportManager.handleReloadJS();
+ } else {
+ mDevSupportManager.isPackagerRunning(
+ new DevServerHelper.PackagerStatusCallback() {
+ @Override
+ public void onPackagerStatusFetched(final boolean packagerIsRunning) {
+ UiThreadUtil.runOnUiThread(
+ new Runnable() {
+ @Override
+ public void run() {
+ if (packagerIsRunning) {
+ mDevSupportManager.handleReloadJS();
+ } else {
+ // If dev server is down, disable the remote JS debugging.
+ devSettings.setRemoteJSDebugEnabled(false);
+ recreateReactContextInBackgroundFromBundleLoader();
+ }
+ }
+ });
+ }
+ });
+ }
+ return;
+ }
+
+ recreateReactContextInBackgroundFromBundleLoader();
+ }
+
+ private void recreateReactContextInBackgroundFromBundleLoader() {
+ recreateReactContextInBackground(
+ new JSCJavaScriptExecutor.Factory(mJSCConfig.getConfigMap()),
+ mBundleLoader);
+ }
+
+ /**
+ * @return whether createReactContextInBackground has been called. Will return false after
+ * onDestroy until a new initial context has been created.
+ */
+ public boolean hasStartedCreatingInitialContext() {
+ return mHasStartedCreatingInitialContext;
+ }
+
+ /**
+ * This method will give JS the opportunity to consume the back button event. If JS does not
+ * consume the event, mDefaultBackButtonImpl will be invoked at the end of the round trip to JS.
+ */
+ @Override
+ public void onBackPressed() {
+ UiThreadUtil.assertOnUiThread();
+ ReactContext reactContext = mCurrentReactContext;
+ if (mCurrentReactContext == null) {
+ // Invoke without round trip to JS.
+ FLog.w(ReactConstants.TAG, "Instance detached from instance manager");
+ invokeDefaultOnBackPressed();
+ } else {
+ DeviceEventManagerModule deviceEventManagerModule =
+ Assertions.assertNotNull(reactContext).getNativeModule(DeviceEventManagerModule.class);
+ deviceEventManagerModule.emitHardwareBackPressed();
+ }
+ }
+
+ private void invokeDefaultOnBackPressed() {
+ UiThreadUtil.assertOnUiThread();
+ if (mDefaultBackButtonImpl != null) {
+ mDefaultBackButtonImpl.invokeDefaultOnBackPressed();
+ }
+ }
+
+ @Override
+ public void onNewIntent(Intent intent) {
+ if (mCurrentReactContext == null) {
+ FLog.w(ReactConstants.TAG, "Instance detached from instance manager");
+ } else {
+ String action = intent.getAction();
+ Uri uri = intent.getData();
+
+ if (Intent.ACTION_VIEW.equals(action) && uri != null) {
+ DeviceEventManagerModule deviceEventManagerModule =
+ Assertions.assertNotNull(mCurrentReactContext).getNativeModule(DeviceEventManagerModule.class);
+ deviceEventManagerModule.emitNewIntentReceived(uri);
+ }
+
+ mCurrentReactContext.onNewIntent(mCurrentActivity, intent);
+ }
+ }
+
+ private void toggleElementInspector() {
+ if (mCurrentReactContext != null) {
+ mCurrentReactContext
+ .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+ .emit("toggleElementInspector", null);
+ }
+ }
+
+ @Override
+ public void onHostPause() {
+ UiThreadUtil.assertOnUiThread();
+
+ mDefaultBackButtonImpl = null;
+ if (mUseDeveloperSupport) {
+ mDevSupportManager.setDevSupportEnabled(false);
+ }
+
+ moveToBeforeResumeLifecycleState();
+ mCurrentActivity = null;
+ }
+
+ /**
+ * Use this method when the activity resumes to enable invoking the back button directly from JS.
+ *
+ * This method retains an instance to provided mDefaultBackButtonImpl. Thus it's important to pass
+ * from the activity instance that owns this particular instance of {@link
+ * XReactInstanceManagerImpl}, so that once this instance receive {@link #onHostDestroy} event it
+ * will clear the reference to that defaultBackButtonImpl.
+ *
+ * @param defaultBackButtonImpl a {@link DefaultHardwareBackBtnHandler} from an Activity that owns
+ * this instance of {@link XReactInstanceManagerImpl}.
+ */
+ @Override
+ public void onHostResume(Activity activity, DefaultHardwareBackBtnHandler defaultBackButtonImpl) {
+ UiThreadUtil.assertOnUiThread();
+
+ mDefaultBackButtonImpl = defaultBackButtonImpl;
+ if (mUseDeveloperSupport) {
+ mDevSupportManager.setDevSupportEnabled(true);
+ }
+
+ mCurrentActivity = activity;
+ moveToResumedLifecycleState(false);
+ }
+
+ @Override
+ public void onHostDestroy() {
+ UiThreadUtil.assertOnUiThread();
+
+ if (mUseDeveloperSupport) {
+ mDevSupportManager.setDevSupportEnabled(false);
+ }
+
+ moveToBeforeCreateLifecycleState();
+ mCurrentActivity = null;
+ }
+
+ @Override
+ public void destroy() {
+ UiThreadUtil.assertOnUiThread();
+
+ if (mUseDeveloperSupport) {
+ mDevSupportManager.setDevSupportEnabled(false);
+ }
+
+ moveToBeforeCreateLifecycleState();
+
+ if (mReactContextInitAsyncTask != null) {
+ mReactContextInitAsyncTask.cancel(true);
+ }
+
+ mMemoryPressureRouter.destroy(mApplicationContext);
+
+ if (mCurrentReactContext != null) {
+ mCurrentReactContext.destroy();
+ mCurrentReactContext = null;
+ mHasStartedCreatingInitialContext = false;
+ }
+ mCurrentActivity = null;
+
+ ResourceDrawableIdHelper.getInstance().clear();
+ }
+
+ private void moveToResumedLifecycleState(boolean force) {
+ if (mCurrentReactContext != null) {
+ // we currently don't have an onCreate callback so we call onResume for both transitions
+ if (force ||
+ mLifecycleState == LifecycleState.BEFORE_RESUME ||
+ mLifecycleState == LifecycleState.BEFORE_CREATE) {
+ mCurrentReactContext.onHostResume(mCurrentActivity);
+ }
+ }
+ mLifecycleState = LifecycleState.RESUMED;
+ }
+
+ private void moveToBeforeResumeLifecycleState() {
+ if (mCurrentReactContext != null) {
+ if (mLifecycleState == LifecycleState.BEFORE_CREATE) {
+ mCurrentReactContext.onHostResume(mCurrentActivity);
+ mCurrentReactContext.onHostPause();
+ } else if (mLifecycleState == LifecycleState.RESUMED) {
+ mCurrentReactContext.onHostPause();
+ }
+ }
+ mLifecycleState = LifecycleState.BEFORE_RESUME;
+ }
+
+ private void moveToBeforeCreateLifecycleState() {
+ if (mCurrentReactContext != null) {
+ if (mLifecycleState == LifecycleState.RESUMED) {
+ mCurrentReactContext.onHostPause();
+ mLifecycleState = LifecycleState.BEFORE_RESUME;
+ }
+ if (mLifecycleState == LifecycleState.BEFORE_RESUME) {
+ mCurrentReactContext.onHostDestroy();
+ }
+ }
+ mLifecycleState = LifecycleState.BEFORE_CREATE;
+ }
+
+ @Override
+ public void onActivityResult(int requestCode, int resultCode, Intent data) {
+ if (mCurrentReactContext != null) {
+ mCurrentReactContext.onActivityResult(requestCode, resultCode, data);
+ }
+ }
+
+ @Override
+ public void showDevOptionsDialog() {
+ UiThreadUtil.assertOnUiThread();
+ mDevSupportManager.showDevOptionsDialog();
+ }
+
+ /**
+ * Get the URL where the last bundle was loaded from.
+ */
+ @Override
+ public String getSourceUrl() {
+ return Assertions.assertNotNull(mSourceUrl);
+ }
+
+ @Override
+ public @Nullable String getJSBundleFile() {
+ if (mBundleLoader == null) {
+ return null;
+ }
+ return mBundleLoader.getSourceUrl();
+ }
+
+ /**
+ * Attach given {@param rootView} to a catalyst instance manager and start JS application using
+ * JS module provided by {@link ReactRootView#getJSModuleName}. If the react context is currently
+ * being (re)-created, or if react context has not been created yet, the JS application associated
+ * with the provided root view will be started asynchronously, i.e this method won't block.
+ * This view will then be tracked by this manager and in case of catalyst instance restart it will
+ * be re-attached.
+ */
+ @Override
+ public void attachMeasuredRootView(ReactRootView rootView) {
+ UiThreadUtil.assertOnUiThread();
+ mAttachedRootViews.add(rootView);
+
+ // If react context is being created in the background, JS application will be started
+ // automatically when creation completes, as root view is part of the attached root view list.
+ if (mReactContextInitAsyncTask == null && mCurrentReactContext != null) {
+ attachMeasuredRootViewToInstance(rootView, mCurrentReactContext.getCatalystInstance());
+ }
+ }
+
+ /**
+ * Detach given {@param rootView} from current catalyst instance. It's safe to call this method
+ * multiple times on the same {@param rootView} - in that case view will be detached with the
+ * first call.
+ */
+ @Override
+ public void detachRootView(ReactRootView rootView) {
+ UiThreadUtil.assertOnUiThread();
+ if (mAttachedRootViews.remove(rootView)) {
+ if (mCurrentReactContext != null && mCurrentReactContext.hasActiveCatalystInstance()) {
+ detachViewFromInstance(rootView, mCurrentReactContext.getCatalystInstance());
+ }
+ }
+ }
+
+ /**
+ * Uses configured {@link ReactPackage} instances to create all view managers
+ */
+ @Override
+ public List createAllViewManagers(
+ ReactApplicationContext catalystApplicationContext) {
+ Systrace.beginSection(TRACE_TAG_REACT_JAVA_BRIDGE, "createAllViewManagers");
+ try {
+ List allViewManagers = new ArrayList<>();
+ for (ReactPackage reactPackage : mPackages) {
+ allViewManagers.addAll(reactPackage.createViewManagers(catalystApplicationContext));
+ }
+ return allViewManagers;
+ } finally {
+ Systrace.endSection(TRACE_TAG_REACT_JAVA_BRIDGE);
+ }
+ }
+
+ @Override
+ public void addReactInstanceEventListener(ReactInstanceEventListener listener) {
+ mReactInstanceEventListeners.add(listener);
+ }
+
+ @Override
+ public void removeReactInstanceEventListener(ReactInstanceEventListener listener) {
+ mReactInstanceEventListeners.remove(listener);
+ }
+
+ @VisibleForTesting
+ @Override
+ public @Nullable ReactContext getCurrentReactContext() {
+ return mCurrentReactContext;
+ }
+
+ @Override
+ public LifecycleState getLifecycleState() {
+ return mLifecycleState;
+ }
+
+ private void onReloadWithJSDebugger(JavaJSExecutor.Factory jsExecutorFactory) {
+ recreateReactContextInBackground(
+ new ProxyJavaScriptExecutor.Factory(jsExecutorFactory),
+ JSBundleLoader.createRemoteDebuggerBundleLoader(
+ mDevSupportManager.getJSBundleURLForRemoteDebugging(),
+ mDevSupportManager.getSourceUrl()));
+ }
+
+ private void onJSBundleLoadedFromServer() {
+ recreateReactContextInBackground(
+ new JSCJavaScriptExecutor.Factory(mJSCConfig.getConfigMap()),
+ JSBundleLoader.createCachedBundleFromNetworkLoader(
+ mDevSupportManager.getSourceUrl(),
+ mDevSupportManager.getDownloadedJSBundleFile()));
+ }
+
+ private void recreateReactContextInBackground(
+ JavaScriptExecutor.Factory jsExecutorFactory,
+ JSBundleLoader jsBundleLoader) {
+ UiThreadUtil.assertOnUiThread();
+
+ ReactContextInitParams initParams =
+ new ReactContextInitParams(jsExecutorFactory, jsBundleLoader);
+ if (mReactContextInitAsyncTask == null) {
+ // No background task to create react context is currently running, create and execute one.
+ mReactContextInitAsyncTask = new ReactContextInitAsyncTask();
+ mReactContextInitAsyncTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, initParams);
+ } else {
+ // Background task is currently running, queue up most recent init params to recreate context
+ // once task completes.
+ mPendingReactContextInitParams = initParams;
+ }
+ }
+
+ private void setupReactContext(ReactApplicationContext reactContext) {
+ Systrace.beginSection(TRACE_TAG_REACT_JAVA_BRIDGE, "setupReactContext");
+ UiThreadUtil.assertOnUiThread();
+ Assertions.assertCondition(mCurrentReactContext == null);
+ mCurrentReactContext = Assertions.assertNotNull(reactContext);
+ CatalystInstance catalystInstance =
+ Assertions.assertNotNull(reactContext.getCatalystInstance());
+
+ catalystInstance.initialize();
+ mDevSupportManager.onNewReactContextCreated(reactContext);
+ mMemoryPressureRouter.addMemoryPressureListener(catalystInstance);
+ moveReactContextToCurrentLifecycleState();
+
+ for (ReactRootView rootView : mAttachedRootViews) {
+ attachMeasuredRootViewToInstance(rootView, catalystInstance);
+ }
+
+ ReactInstanceEventListener[] listeners =
+ new ReactInstanceEventListener[mReactInstanceEventListeners.size()];
+ listeners = mReactInstanceEventListeners.toArray(listeners);
+
+ for (ReactInstanceEventListener listener : listeners) {
+ listener.onReactContextInitialized(reactContext);
+ }
+ Systrace.endSection(TRACE_TAG_REACT_JAVA_BRIDGE);
+ }
+
+ private void attachMeasuredRootViewToInstance(
+ ReactRootView rootView,
+ CatalystInstance catalystInstance) {
+ Systrace.beginSection(TRACE_TAG_REACT_JAVA_BRIDGE, "attachMeasuredRootViewToInstance");
+ UiThreadUtil.assertOnUiThread();
+
+ // Reset view content as it's going to be populated by the application content from JS
+ rootView.removeAllViews();
+ rootView.setId(View.NO_ID);
+
+ UIManagerModule uiManagerModule = catalystInstance.getNativeModule(UIManagerModule.class);
+ int rootTag = uiManagerModule.addMeasuredRootView(rootView);
+ @Nullable Bundle launchOptions = rootView.getLaunchOptions();
+ WritableMap initialProps = Arguments.makeNativeMap(launchOptions);
+ String jsAppModuleName = rootView.getJSModuleName();
+
+ WritableNativeMap appParams = new WritableNativeMap();
+ appParams.putDouble("rootTag", rootTag);
+ appParams.putMap("initialProps", initialProps);
+ catalystInstance.getJSModule(AppRegistry.class).runApplication(jsAppModuleName, appParams);
+ Systrace.endSection(TRACE_TAG_REACT_JAVA_BRIDGE);
+ }
+
+ private void detachViewFromInstance(
+ ReactRootView rootView,
+ CatalystInstance catalystInstance) {
+ UiThreadUtil.assertOnUiThread();
+ catalystInstance.getJSModule(AppRegistry.class)
+ .unmountApplicationComponentAtRootTag(rootView.getId());
+ }
+
+ private void tearDownReactContext(ReactContext reactContext) {
+ UiThreadUtil.assertOnUiThread();
+ if (mLifecycleState == LifecycleState.RESUMED) {
+ reactContext.onHostPause();
+ }
+ for (ReactRootView rootView : mAttachedRootViews) {
+ detachViewFromInstance(rootView, reactContext.getCatalystInstance());
+ }
+ reactContext.destroy();
+ mDevSupportManager.onReactInstanceDestroyed(reactContext);
+ mMemoryPressureRouter.removeMemoryPressureListener(reactContext.getCatalystInstance());
+ }
+
+ /**
+ * @return instance of {@link ReactContext} configured a {@link CatalystInstance} set
+ */
+ private ReactApplicationContext createReactContext(
+ JavaScriptExecutor jsExecutor,
+ JSBundleLoader jsBundleLoader) {
+ FLog.i(ReactConstants.TAG, "Creating react context.");
+ ReactMarker.logMarker(CREATE_REACT_CONTEXT_START);
+ mSourceUrl = jsBundleLoader.getSourceUrl();
+ NativeModuleRegistry.Builder nativeRegistryBuilder = new NativeModuleRegistry.Builder();
+ JavaScriptModuleRegistry.Builder jsModulesBuilder = new JavaScriptModuleRegistry.Builder();
+
+ final ReactApplicationContext reactContext = new ReactApplicationContext(mApplicationContext);
+ if (mUseDeveloperSupport) {
+ reactContext.setNativeModuleCallExceptionHandler(mDevSupportManager);
+ }
+
+ ReactMarker.logMarker(PROCESS_PACKAGES_START);
+ Systrace.beginSection(
+ TRACE_TAG_REACT_JAVA_BRIDGE,
+ "createAndProcessCoreModulesPackage");
+ try {
+ CoreModulesPackage coreModulesPackage =
+ new CoreModulesPackage(this, mBackBtnHandler, mUIImplementationProvider);
+ processPackage(coreModulesPackage, reactContext, nativeRegistryBuilder, jsModulesBuilder);
+ } finally {
+ Systrace.endSection(TRACE_TAG_REACT_JAVA_BRIDGE);
+ }
+
+ // TODO(6818138): Solve use-case of native/js modules overriding
+ for (ReactPackage reactPackage : mPackages) {
+ Systrace.beginSection(
+ TRACE_TAG_REACT_JAVA_BRIDGE,
+ "createAndProcessCustomReactPackage");
+ try {
+ processPackage(reactPackage, reactContext, nativeRegistryBuilder, jsModulesBuilder);
+ } finally {
+ Systrace.endSection(TRACE_TAG_REACT_JAVA_BRIDGE);
+ }
+ }
+ ReactMarker.logMarker(PROCESS_PACKAGES_END);
+
+ ReactMarker.logMarker(BUILD_NATIVE_MODULE_REGISTRY_START);
+ Systrace.beginSection(TRACE_TAG_REACT_JAVA_BRIDGE, "buildNativeModuleRegistry");
+ NativeModuleRegistry nativeModuleRegistry;
+ try {
+ nativeModuleRegistry = nativeRegistryBuilder.build();
+ } finally {
+ Systrace.endSection(TRACE_TAG_REACT_JAVA_BRIDGE);
+ ReactMarker.logMarker(BUILD_NATIVE_MODULE_REGISTRY_END);
+ }
+
+ NativeModuleCallExceptionHandler exceptionHandler = mNativeModuleCallExceptionHandler != null
+ ? mNativeModuleCallExceptionHandler
+ : mDevSupportManager;
+ CatalystInstanceImpl.Builder catalystInstanceBuilder = new CatalystInstanceImpl.Builder()
+ .setReactQueueConfigurationSpec(ReactQueueConfigurationSpec.createDefault())
+ .setJSExecutor(jsExecutor)
+ .setRegistry(nativeModuleRegistry)
+ .setJSModuleRegistry(jsModulesBuilder.build())
+ .setJSBundleLoader(jsBundleLoader)
+ .setNativeModuleCallExceptionHandler(exceptionHandler);
+
+ ReactMarker.logMarker(CREATE_CATALYST_INSTANCE_START);
+ // CREATE_CATALYST_INSTANCE_END is in JSCExecutor.cpp
+ Systrace.beginSection(TRACE_TAG_REACT_JAVA_BRIDGE, "createCatalystInstance");
+ final CatalystInstance catalystInstance;
+ try {
+ catalystInstance = catalystInstanceBuilder.build();
+ } finally {
+ Systrace.endSection(TRACE_TAG_REACT_JAVA_BRIDGE);
+ ReactMarker.logMarker(CREATE_CATALYST_INSTANCE_END);
+ }
+
+ if (mBridgeIdleDebugListener != null) {
+ catalystInstance.addBridgeIdleDebugListener(mBridgeIdleDebugListener);
+ }
+
+ ReactMarker.logMarker(RUN_JS_BUNDLE_START);
+ try {
+ catalystInstance.getReactQueueConfiguration().getJSQueueThread().callOnQueue(
+ new Callable() {
+ @Override
+ public Void call() throws Exception {
+ reactContext.initializeWithInstance(catalystInstance);
+
+ Systrace.beginSection(TRACE_TAG_REACT_JAVA_BRIDGE, "runJSBundle");
+ try {
+ catalystInstance.runJSBundle();
+ } finally {
+ Systrace.endSection(TRACE_TAG_REACT_JAVA_BRIDGE);
+ ReactMarker.logMarker(RUN_JS_BUNDLE_END);
+ }
+ return null;
+ }
+ }).get();
+ } catch (InterruptedException e) {
+ throw new RuntimeException(e);
+ } catch (ExecutionException e) {
+ if (e.getCause() instanceof RuntimeException) {
+ throw (RuntimeException) e.getCause();
+ } else {
+ throw new RuntimeException(e);
+ }
+ }
+
+ return reactContext;
+ }
+
+ private void processPackage(
+ ReactPackage reactPackage,
+ ReactApplicationContext reactContext,
+ NativeModuleRegistry.Builder nativeRegistryBuilder,
+ JavaScriptModuleRegistry.Builder jsModulesBuilder) {
+ for (NativeModule nativeModule : reactPackage.createNativeModules(reactContext)) {
+ nativeRegistryBuilder.add(nativeModule);
+ }
+ for (Class jsModuleClass : reactPackage.createJSModules()) {
+ jsModulesBuilder.add(jsModuleClass);
+ }
+ }
+
+ private void moveReactContextToCurrentLifecycleState() {
+ if (mLifecycleState == LifecycleState.RESUMED) {
+ moveToResumedLifecycleState(true);
+ }
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/animated/AdditionAnimatedNode.java b/android/ReactAndroid/src/main/java/com/facebook/react/animated/AdditionAnimatedNode.java
new file mode 100644
index 00000000000000..34b96be57e3188
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/animated/AdditionAnimatedNode.java
@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.animated;
+
+import com.facebook.react.bridge.JSApplicationCausedNativeException;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+
+/**
+ * Animated node that plays a role of value aggregator. It takes two or more value nodes as an input
+ * and outputs a sum of values outputted by those nodes.
+ */
+/*package*/ class AdditionAnimatedNode extends ValueAnimatedNode {
+
+ private final NativeAnimatedNodesManager mNativeAnimatedNodesManager;
+ private final int[] mInputNodes;
+
+ public AdditionAnimatedNode(
+ ReadableMap config,
+ NativeAnimatedNodesManager nativeAnimatedNodesManager) {
+ mNativeAnimatedNodesManager = nativeAnimatedNodesManager;
+ ReadableArray inputNodes = config.getArray("input");
+ mInputNodes = new int[inputNodes.size()];
+ for (int i = 0; i < mInputNodes.length; i++) {
+ mInputNodes[i] = inputNodes.getInt(i);
+ }
+ }
+
+ @Override
+ public void update() {
+ mValue = 0;
+ for (int i = 0; i < mInputNodes.length; i++) {
+ AnimatedNode animatedNode = mNativeAnimatedNodesManager.getNodeById(mInputNodes[i]);
+ if (animatedNode != null && animatedNode instanceof ValueAnimatedNode) {
+ mValue += ((ValueAnimatedNode) animatedNode).mValue;
+ } else {
+ throw new JSApplicationCausedNativeException("Illegal node ID set as an input for " +
+ "Animated.Add node");
+ }
+ }
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/animated/AnimatedNode.java b/android/ReactAndroid/src/main/java/com/facebook/react/animated/AnimatedNode.java
new file mode 100644
index 00000000000000..61e02b1055e900
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/animated/AnimatedNode.java
@@ -0,0 +1,71 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.animated;
+
+import com.facebook.infer.annotation.Assertions;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.annotation.Nullable;
+
+/**
+ * Base class for all Animated.js library node types that can be created on the "native" side.
+ */
+/*package*/ abstract class AnimatedNode {
+
+ public static final int INITIAL_BFS_COLOR = 0;
+
+ private static final int DEFAULT_ANIMATED_NODE_CHILD_COUNT = 1;
+
+ /*package*/ @Nullable List mChildren; /* lazy-initialized when a child is added */
+ /*package*/ int mActiveIncomingNodes = 0;
+ /*package*/ int mBFSColor = INITIAL_BFS_COLOR;
+ /*package*/ int mTag = -1;
+
+ public final void addChild(AnimatedNode child) {
+ if (mChildren == null) {
+ mChildren = new ArrayList<>(DEFAULT_ANIMATED_NODE_CHILD_COUNT);
+ }
+ Assertions.assertNotNull(mChildren).add(child);
+ child.onAttachedToNode(this);
+ }
+
+ public final void removeChild(AnimatedNode child) {
+ if (mChildren == null) {
+ return;
+ }
+ child.onDetachedFromNode(this);
+ mChildren.remove(child);
+ }
+
+ /**
+ * Subclasses may want to override this method in order to store a reference to the parent of a
+ * given node that can then be used to calculate current node's value in {@link #update}.
+ * In that case it is important to also override {@link #onDetachedFromNode} to clear that
+ * reference once current node gets detached.
+ */
+ public void onAttachedToNode(AnimatedNode parent) {
+ }
+
+ /**
+ * See {@link #onAttachedToNode}
+ */
+ public void onDetachedFromNode(AnimatedNode parent) {
+ }
+
+ /**
+ * This method will be run on each node at most once every repetition of the animation loop. It
+ * will be executed on a node only when all the node's parent has already been updated. Therefore
+ * it can be used to calculate node's value.
+ */
+ public void update() {
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/animated/AnimatedNodeValueListener.java b/android/ReactAndroid/src/main/java/com/facebook/react/animated/AnimatedNodeValueListener.java
new file mode 100644
index 00000000000000..fa0248cb3e1947
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/animated/AnimatedNodeValueListener.java
@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.animated;
+
+/**
+ * Interface used to listen to {@link ValueAnimatedNode} updates.
+ */
+public interface AnimatedNodeValueListener {
+ void onValueUpdate(double value);
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/animated/AnimationDriver.java b/android/ReactAndroid/src/main/java/com/facebook/react/animated/AnimationDriver.java
new file mode 100644
index 00000000000000..ad715d45c9bac1
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/animated/AnimationDriver.java
@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.animated;
+
+import com.facebook.react.bridge.Callback;
+
+/**
+ * Base class for different types of animation drivers. Can be used to implement simple time-based
+ * animations as well as spring based animations.
+ */
+/*package*/ abstract class AnimationDriver {
+
+ /*package*/ boolean mHasFinished = false;
+ /*package*/ ValueAnimatedNode mAnimatedValue;
+ /*package*/ Callback mEndCallback;
+ /*package*/ int mId;
+
+ /**
+ * This method gets called in the main animation loop with a frame time passed down from the
+ * android choreographer callback.
+ */
+ public abstract void runAnimationStep(long frameTimeNanos);
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/animated/BUCK b/android/ReactAndroid/src/main/java/com/facebook/react/animated/BUCK
new file mode 100644
index 00000000000000..d6c34221f18ed1
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/animated/BUCK
@@ -0,0 +1,24 @@
+include_defs('//ReactAndroid/DEFS')
+
+android_library(
+ name = 'animated',
+ srcs = glob([
+ '*.java',
+ ]),
+ deps = [
+ react_native_target('java/com/facebook/react/bridge:bridge'),
+ react_native_target('java/com/facebook/react/modules/core:core'),
+ react_native_target('java/com/facebook/react/uimanager:uimanager'),
+ react_native_target('java/com/facebook/react/uimanager/annotations:annotations'),
+ react_native_dep('third-party/java/infer-annotations:infer-annotations'),
+ react_native_dep('third-party/java/jsr-305:jsr-305'),
+ react_native_dep('third-party/android/support/v4:lib-support-v4'),
+ ],
+ visibility = [
+ 'PUBLIC',
+ ],
+)
+
+project_config(
+ src_target = ':animated',
+)
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/animated/FrameBasedAnimationDriver.java b/android/ReactAndroid/src/main/java/com/facebook/react/animated/FrameBasedAnimationDriver.java
new file mode 100644
index 00000000000000..f697e98f885ba7
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/animated/FrameBasedAnimationDriver.java
@@ -0,0 +1,63 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.animated;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+
+/**
+ * Implementation of {@link AnimationDriver} which provides a support for simple time-based
+ * animations that are pre-calculate on the JS side. For each animation frame JS provides a value
+ * from 0 to 1 that indicates a progress of the animation at that frame.
+ */
+class FrameBasedAnimationDriver extends AnimationDriver {
+
+ private long mStartFrameTimeNanos = -1;
+ private final double[] mFrames;
+ private final double mToValue;
+ private double mFromValue;
+
+ FrameBasedAnimationDriver(ReadableMap config) {
+ ReadableArray frames = config.getArray("frames");
+ int numberOfFrames = frames.size();
+ mFrames = new double[numberOfFrames];
+ for (int i = 0; i < numberOfFrames; i++) {
+ mFrames[i] = frames.getDouble(i);
+ }
+ mToValue = config.getDouble("toValue");
+ }
+
+ @Override
+ public void runAnimationStep(long frameTimeNanos) {
+ if (mStartFrameTimeNanos < 0) {
+ mStartFrameTimeNanos = frameTimeNanos;
+ mFromValue = mAnimatedValue.mValue;
+ }
+ long timeFromStartNanos = (frameTimeNanos - mStartFrameTimeNanos);
+ // frames are calculated at 60FPS, to get index by a given time offset from the start of the
+ // animation, we take the time diff in millisecond and divide it by 60 frames per 1000ms.
+ int frameIndex = (int) (timeFromStartNanos / 1000000L * 60L / 1000L);
+ if (frameIndex < 0) {
+ throw new IllegalStateException("Calculated frame index should never be lower than 0");
+ } else if (mHasFinished) {
+ // nothing to do here
+ return;
+ }
+ double nextValue;
+ if (frameIndex >= mFrames.length - 1) {
+ // animation has completed, no more frames left
+ mHasFinished = true;
+ nextValue = mToValue;
+ } else {
+ nextValue = mFromValue + mFrames[frameIndex] * (mToValue - mFromValue);
+ }
+ mAnimatedValue.mValue = nextValue;
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/animated/InterpolationAnimatedNode.java b/android/ReactAndroid/src/main/java/com/facebook/react/animated/InterpolationAnimatedNode.java
new file mode 100644
index 00000000000000..89baf9c43898a5
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/animated/InterpolationAnimatedNode.java
@@ -0,0 +1,108 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.animated;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableType;
+
+import javax.annotation.Nullable;
+
+/**
+ * Animated node that corresponds to {@code AnimatedInterpolation} from AnimatedImplementation.js.
+ *
+ * Currently only a linear interpolation is supported on an input range of an arbitrary size.
+ */
+/*package*/ class InterpolationAnimatedNode extends ValueAnimatedNode {
+
+ private static double[] fromArray(ReadableArray ary) {
+ double[] res = new double[ary.size()];
+ for (int i = 0; i < res.length; i++) {
+ ReadableType type = ary.getType(i);
+ if (type == ReadableType.Number) {
+ res[i] = ary.getDouble(i);
+ } else if (type == ReadableType.String) {
+ res[i] = NativeAnimatedHelper.parseAngle(ary.getString(i));
+ } else {
+ throw new IllegalArgumentException(
+ "Interpolation inputs and outputs must be a number or a string.");
+ }
+
+ }
+ return res;
+ }
+
+ private static double interpolate(
+ double value,
+ double inputMin,
+ double inputMax,
+ double outputMin,
+ double outputMax) {
+ return outputMin + (outputMax - outputMin) *
+ (value - inputMin) / (inputMax - inputMin);
+ }
+
+ /*package*/ static double interpolate(double value, double[] inputRange, double[] outputRange) {
+ int rangeIndex = findRangeIndex(value, inputRange);
+ return interpolate(
+ value,
+ inputRange[rangeIndex],
+ inputRange[rangeIndex + 1],
+ outputRange[rangeIndex],
+ outputRange[rangeIndex + 1]);
+ }
+
+ private static int findRangeIndex(double value, double[] ranges) {
+ int index;
+ for (index = 1; index < ranges.length - 1; index++) {
+ if (ranges[index] >= value) {
+ break;
+ }
+ }
+ return index - 1;
+ }
+
+ private final double mInputRange[];
+ private final double mOutputRange[];
+ private @Nullable ValueAnimatedNode mParent;
+
+ public InterpolationAnimatedNode(ReadableMap config) {
+ mInputRange = fromArray(config.getArray("inputRange"));
+ mOutputRange = fromArray(config.getArray("outputRange"));
+ }
+
+ @Override
+ public void onAttachedToNode(AnimatedNode parent) {
+ if (mParent != null) {
+ throw new IllegalStateException("Parent already attached");
+ }
+ if (!(parent instanceof ValueAnimatedNode)) {
+ throw new IllegalArgumentException("Parent is of an invalid type");
+ }
+ mParent = (ValueAnimatedNode) parent;
+ }
+
+ @Override
+ public void onDetachedFromNode(AnimatedNode parent) {
+ if (parent != mParent) {
+ throw new IllegalArgumentException("Invalid parent node provided");
+ }
+ mParent = null;
+ }
+
+ @Override
+ public void update() {
+ if (mParent == null) {
+ throw new IllegalStateException("Trying to update interpolation node that has not been " +
+ "attached to the parent");
+ }
+ mValue = interpolate(mParent.mValue, mInputRange, mOutputRange);
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/animated/MultiplicationAnimatedNode.java b/android/ReactAndroid/src/main/java/com/facebook/react/animated/MultiplicationAnimatedNode.java
new file mode 100644
index 00000000000000..5838ed0c5ce6d1
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/animated/MultiplicationAnimatedNode.java
@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.animated;
+
+import com.facebook.react.bridge.JSApplicationCausedNativeException;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+
+/**
+ * Animated node which takes two or more value node as an input and outputs a product of their
+ * values
+ */
+/*package*/ class MultiplicationAnimatedNode extends ValueAnimatedNode {
+
+ private final NativeAnimatedNodesManager mNativeAnimatedNodesManager;
+ private final int[] mInputNodes;
+
+ public MultiplicationAnimatedNode(
+ ReadableMap config,
+ NativeAnimatedNodesManager nativeAnimatedNodesManager) {
+ mNativeAnimatedNodesManager = nativeAnimatedNodesManager;
+ ReadableArray inputNodes = config.getArray("input");
+ mInputNodes = new int[inputNodes.size()];
+ for (int i = 0; i < mInputNodes.length; i++) {
+ mInputNodes[i] = inputNodes.getInt(i);
+ }
+ }
+
+ @Override
+ public void update() {
+ mValue = 1;
+ for (int i = 0; i < mInputNodes.length; i++) {
+ AnimatedNode animatedNode = mNativeAnimatedNodesManager.getNodeById(mInputNodes[i]);
+ if (animatedNode != null && animatedNode instanceof ValueAnimatedNode) {
+ mValue *= ((ValueAnimatedNode) animatedNode).mValue;
+ } else {
+ throw new JSApplicationCausedNativeException("Illegal node ID set as an input for " +
+ "Animated.multiply node");
+ }
+ }
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/animated/NativeAnimatedHelper.java b/android/ReactAndroid/src/main/java/com/facebook/react/animated/NativeAnimatedHelper.java
new file mode 100644
index 00000000000000..5d11b258ecebbb
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/animated/NativeAnimatedHelper.java
@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.animated;
+
+
+/* package */ class NativeAnimatedHelper {
+
+ private static double degreesToRadians(double degrees) {
+ return degrees * Math.PI / 180;
+ }
+
+ public static double parseAngle(String angle) {
+ if (angle.endsWith("deg")) {
+ return degreesToRadians(
+ Double.parseDouble(angle.substring(0, angle.length() - 3)));
+ } else {
+ // Assume radians.
+ return Double.parseDouble(angle);
+ }
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/animated/NativeAnimatedModule.java b/android/ReactAndroid/src/main/java/com/facebook/react/animated/NativeAnimatedModule.java
new file mode 100644
index 00000000000000..303fb83253bc5f
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/animated/NativeAnimatedModule.java
@@ -0,0 +1,313 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.animated;
+
+import javax.annotation.Nullable;
+
+import com.facebook.infer.annotation.Assertions;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.LifecycleEventListener;
+import com.facebook.react.bridge.OnBatchCompleteListener;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.facebook.react.uimanager.GuardedChoreographerFrameCallback;
+import com.facebook.react.uimanager.ReactChoreographer;
+import com.facebook.react.uimanager.UIImplementation;
+import com.facebook.react.uimanager.UIManagerModule;
+
+import java.util.ArrayList;
+
+/**
+ * Module that exposes interface for creating and managing animated nodes on the "native" side.
+ *
+ * Animated.js library is based on a concept of a graph where nodes are values or transform
+ * operations (such as interpolation, addition, etc) and connection are used to describe how change
+ * of the value in one node can affect other nodes.
+ *
+ * Few examples of the nodes that can be created on the JS side:
+ * - Animated.Value is a simplest type of node with a numeric value which can be driven by an
+ * animation engine (spring, decay, etc) or by calling setValue on it directly from JS
+ * - Animated.add is a type of node that may have two or more input nodes. It outputs the sum of
+ * all the input node values
+ * - interpolate - is actually a method you can call on any node and it creates a new node that
+ * takes the parent node as an input and outputs its interpolated value (e.g. if you have value
+ * that can animate from 0 to 1 you can create interpolated node and set output range to be 0 to
+ * 100 and when the input node changes the output of interpolated node will multiply the values
+ * by 100)
+ *
+ * You can mix and chain nodes however you like and this way create nodes graph with connections
+ * between them.
+ *
+ * To map animated node values to view properties there is a special type of a node: AnimatedProps.
+ * It is created by AnimatedImplementation whenever you render Animated.View and stores a mapping
+ * from the view properties to the corresponding animated values (so it's actually also a node with
+ * connections to the value nodes).
+ *
+ * Last "special" elements of the the graph are "animation drivers". Those are objects (represented
+ * as a graph nodes too) that based on some criteria updates attached values every frame (we have
+ * few types of those, e.g., spring, timing, decay). Animation objects can be "started" and
+ * "stopped". Those are like "pulse generators" for the rest of the nodes graph. Those pulses then
+ * propagate along the graph to the children nodes up to the special node type: AnimatedProps which
+ * then can be used to calculate property update map for a view.
+ *
+ * This class acts as a proxy between the "native" API that can be called from JS and the main class
+ * that coordinates all the action: {@link NativeAnimatedNodesManager}. Since all the methods from
+ * {@link NativeAnimatedNodesManager} need to be called from the UI thread, we we create a queue of
+ * animated graph operations that is then enqueued to be executed in the UI Thread at the end of the
+ * batch of JS->native calls (similarily to how it's handled in {@link UIManagerModule}). This
+ * isolates us from the problems that may be caused by concurrent updates of animated graph while UI
+ * thread is "executing" the animation loop.
+ */
+public class NativeAnimatedModule extends ReactContextBaseJavaModule implements
+ OnBatchCompleteListener, LifecycleEventListener {
+
+ private interface UIThreadOperation {
+ void execute(NativeAnimatedNodesManager animatedNodesManager);
+ }
+
+ private final Object mOperationsCopyLock = new Object();
+ private @Nullable GuardedChoreographerFrameCallback mAnimatedFrameCallback;
+ private @Nullable ReactChoreographer mReactChoreographer;
+ private ArrayList mOperations = new ArrayList<>();
+ private volatile @Nullable ArrayList mReadyOperations = null;
+
+ public NativeAnimatedModule(ReactApplicationContext reactContext) {
+ super(reactContext);
+ }
+
+ @Override
+ public void initialize() {
+ // Safe to acquire choreographer here, as initialize() is invoked from UI thread.
+ mReactChoreographer = ReactChoreographer.getInstance();
+
+ ReactApplicationContext reactCtx = getReactApplicationContext();
+ UIImplementation uiImplementation =
+ reactCtx.getNativeModule(UIManagerModule.class).getUIImplementation();
+
+ final NativeAnimatedNodesManager nodesManager =
+ new NativeAnimatedNodesManager(uiImplementation);
+ mAnimatedFrameCallback = new GuardedChoreographerFrameCallback(reactCtx) {
+ @Override
+ protected void doFrameGuarded(final long frameTimeNanos) {
+
+ ArrayList operations;
+ synchronized (mOperationsCopyLock) {
+ operations = mReadyOperations;
+ mReadyOperations = null;
+ }
+
+ if (operations != null) {
+ for (int i = 0, size = operations.size(); i < size; i++) {
+ operations.get(i).execute(nodesManager);
+ }
+ }
+
+ if (nodesManager.hasActiveAnimations()) {
+ nodesManager.runUpdates(frameTimeNanos);
+ }
+
+ // TODO: Would be great to avoid adding this callback in case there are no active animations
+ // and no outstanding tasks on the operations queue. Apparently frame callbacks can only
+ // be posted from the UI thread and therefore we cannot schedule them directly from
+ // @ReactMethod methods
+ Assertions.assertNotNull(mReactChoreographer).postFrameCallback(
+ ReactChoreographer.CallbackType.NATIVE_ANIMATED_MODULE,
+ mAnimatedFrameCallback);
+ }
+ };
+ reactCtx.addLifecycleEventListener(this);
+ }
+
+ @Override
+ public void onBatchComplete() {
+ // Note: The order of executing onBatchComplete handler (especially in terms of onBatchComplete
+ // from the UIManagerModule) doesn't matter as we only enqueue operations for the UI thread to
+ // be executed from here. Thanks to ReactChoreographer all the operations from here are going
+ // to be executed *after* all the operations enqueued by UIManager as the callback type that we
+ // use for ReactChoreographer (CallbackType.NATIVE_ANIMATED_MODULE) is run after callbacks that UIManager
+ // use
+ ArrayList operations = mOperations.isEmpty() ? null : mOperations;
+ if (operations != null) {
+ mOperations = new ArrayList<>();
+ synchronized (mOperationsCopyLock) {
+ if (mReadyOperations == null) {
+ mReadyOperations = operations;
+ } else {
+ mReadyOperations.addAll(operations);
+ }
+ }
+ }
+ }
+
+ @Override
+ public void onHostResume() {
+ enqueueFrameCallback();
+ }
+
+ @Override
+ public void onHostPause() {
+ clearFrameCallback();
+ }
+
+ @Override
+ public void onHostDestroy() {
+ // do nothing
+ }
+
+ @Override
+ public String getName() {
+ return "NativeAnimatedModule";
+ }
+
+ private void clearFrameCallback() {
+ Assertions.assertNotNull(mReactChoreographer).removeFrameCallback(
+ ReactChoreographer.CallbackType.NATIVE_ANIMATED_MODULE,
+ mAnimatedFrameCallback);
+ }
+
+ private void enqueueFrameCallback() {
+ Assertions.assertNotNull(mReactChoreographer).postFrameCallback(
+ ReactChoreographer.CallbackType.NATIVE_ANIMATED_MODULE,
+ mAnimatedFrameCallback);
+ }
+
+ @ReactMethod
+ public void createAnimatedNode(final int tag, final ReadableMap config) {
+ mOperations.add(new UIThreadOperation() {
+ @Override
+ public void execute(NativeAnimatedNodesManager animatedNodesManager) {
+ animatedNodesManager.createAnimatedNode(tag, config);
+ }
+ });
+ }
+
+ @ReactMethod
+ public void startListeningToAnimatedNodeValue(final int tag) {
+ final AnimatedNodeValueListener listener = new AnimatedNodeValueListener() {
+ public void onValueUpdate(double value) {
+ WritableMap onAnimatedValueData = Arguments.createMap();
+ onAnimatedValueData.putInt("tag", tag);
+ onAnimatedValueData.putDouble("value", value);
+ getReactApplicationContext().getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+ .emit("onAnimatedValueUpdate", onAnimatedValueData);
+ }
+ };
+
+ mOperations.add(new UIThreadOperation() {
+ @Override
+ public void execute(NativeAnimatedNodesManager animatedNodesManager) {
+ animatedNodesManager.startListeningToAnimatedNodeValue(tag, listener);
+ }
+ });
+ }
+
+ @ReactMethod
+ public void stopListeningToAnimatedNodeValue(final int tag) {
+ mOperations.add(new UIThreadOperation() {
+ @Override
+ public void execute(NativeAnimatedNodesManager animatedNodesManager) {
+ animatedNodesManager.stopListeningToAnimatedNodeValue(tag);
+ }
+ });
+ }
+
+ @ReactMethod
+ public void dropAnimatedNode(final int tag) {
+ mOperations.add(new UIThreadOperation() {
+ @Override
+ public void execute(NativeAnimatedNodesManager animatedNodesManager) {
+ animatedNodesManager.dropAnimatedNode(tag);
+ }
+ });
+ }
+
+ @ReactMethod
+ public void setAnimatedNodeValue(final int tag, final double value) {
+ mOperations.add(new UIThreadOperation() {
+ @Override
+ public void execute(NativeAnimatedNodesManager animatedNodesManager) {
+ animatedNodesManager.setAnimatedNodeValue(tag, value);
+ }
+ });
+ }
+
+ @ReactMethod
+ public void startAnimatingNode(
+ final int animationId,
+ final int animatedNodeTag,
+ final ReadableMap animationConfig,
+ final Callback endCallback) {
+ mOperations.add(new UIThreadOperation() {
+ @Override
+ public void execute(NativeAnimatedNodesManager animatedNodesManager) {
+ animatedNodesManager.startAnimatingNode(
+ animationId,
+ animatedNodeTag,
+ animationConfig,
+ endCallback);
+ }
+ });
+ }
+
+ @ReactMethod
+ public void stopAnimation(final int animationId) {
+ mOperations.add(new UIThreadOperation() {
+ @Override
+ public void execute(NativeAnimatedNodesManager animatedNodesManager) {
+ animatedNodesManager.stopAnimation(animationId);
+ }
+ });
+ }
+
+ @ReactMethod
+ public void connectAnimatedNodes(final int parentNodeTag, final int childNodeTag) {
+ mOperations.add(new UIThreadOperation() {
+ @Override
+ public void execute(NativeAnimatedNodesManager animatedNodesManager) {
+ animatedNodesManager.connectAnimatedNodes(parentNodeTag, childNodeTag);
+ }
+ });
+ }
+
+ @ReactMethod
+ public void disconnectAnimatedNodes(final int parentNodeTag, final int childNodeTag) {
+ mOperations.add(new UIThreadOperation() {
+ @Override
+ public void execute(NativeAnimatedNodesManager animatedNodesManager) {
+ animatedNodesManager.disconnectAnimatedNodes(parentNodeTag, childNodeTag);
+ }
+ });
+ }
+
+ @ReactMethod
+ public void connectAnimatedNodeToView(final int animatedNodeTag, final int viewTag) {
+ mOperations.add(new UIThreadOperation() {
+ @Override
+ public void execute(NativeAnimatedNodesManager animatedNodesManager) {
+ animatedNodesManager.connectAnimatedNodeToView(animatedNodeTag, viewTag);
+ }
+ });
+ }
+
+ @ReactMethod
+ public void disconnectAnimatedNodeFromView(final int animatedNodeTag, final int viewTag) {
+ mOperations.add(new UIThreadOperation() {
+ @Override
+ public void execute(NativeAnimatedNodesManager animatedNodesManager) {
+ animatedNodesManager.disconnectAnimatedNodeFromView(animatedNodeTag, viewTag);
+ }
+ });
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/animated/NativeAnimatedNodesManager.java b/android/ReactAndroid/src/main/java/com/facebook/react/animated/NativeAnimatedNodesManager.java
new file mode 100644
index 00000000000000..67a735e16ca654
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/animated/NativeAnimatedNodesManager.java
@@ -0,0 +1,397 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.animated;
+
+import android.util.SparseArray;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.JSApplicationIllegalArgumentException;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.UiThreadUtil;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.uimanager.UIImplementation;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Queue;
+
+import javax.annotation.Nullable;
+
+/**
+ * This is the main class that coordinates how native animated JS implementation drives UI changes.
+ *
+ * It implements a management interface for animated nodes graph as well as implements a graph
+ * traversal algorithm that is run for each animation frame.
+ *
+ * For each animation frame we visit animated nodes that might've been updated as well as their
+ * children that may use parent's values to update themselves. At the end of the traversal algorithm
+ * we expect to reach a special type of the node: PropsAnimatedNode that is then responsible for
+ * calculating property map which can be sent to native view hierarchy to update the view.
+ *
+ * IMPORTANT: This class should be accessed only from the UI Thread
+ */
+/*package*/ class NativeAnimatedNodesManager {
+
+ private final SparseArray mAnimatedNodes = new SparseArray<>();
+ private final ArrayList mActiveAnimations = new ArrayList<>();
+ private final ArrayList mUpdatedNodes = new ArrayList<>();
+ private final UIImplementation mUIImplementation;
+ private int mAnimatedGraphBFSColor = 0;
+
+ public NativeAnimatedNodesManager(UIImplementation uiImplementation) {
+ mUIImplementation = uiImplementation;
+ }
+
+ /*package*/ @Nullable AnimatedNode getNodeById(int id) {
+ return mAnimatedNodes.get(id);
+ }
+
+ public boolean hasActiveAnimations() {
+ return !mActiveAnimations.isEmpty() || !mUpdatedNodes.isEmpty();
+ }
+
+ public void createAnimatedNode(int tag, ReadableMap config) {
+ if (mAnimatedNodes.get(tag) != null) {
+ throw new JSApplicationIllegalArgumentException("Animated node with tag " + tag +
+ " already exists");
+ }
+ String type = config.getString("type");
+ final AnimatedNode node;
+ if ("style".equals(type)) {
+ node = new StyleAnimatedNode(config, this);
+ } else if ("value".equals(type)) {
+ node = new ValueAnimatedNode(config);
+ mUpdatedNodes.add(node);
+ } else if ("props".equals(type)) {
+ node = new PropsAnimatedNode(config, this);
+ } else if ("interpolation".equals(type)) {
+ node = new InterpolationAnimatedNode(config);
+ } else if ("addition".equals(type)) {
+ node = new AdditionAnimatedNode(config, this);
+ } else if ("multiplication".equals(type)) {
+ node = new MultiplicationAnimatedNode(config, this);
+ } else if ("transform".equals(type)) {
+ node = new TransformAnimatedNode(config, this);
+ } else {
+ throw new JSApplicationIllegalArgumentException("Unsupported node type: " + type);
+ }
+ node.mTag = tag;
+ mAnimatedNodes.put(tag, node);
+ }
+
+ public void dropAnimatedNode(int tag) {
+ mAnimatedNodes.remove(tag);
+ }
+
+ public void startListeningToAnimatedNodeValue(int tag, AnimatedNodeValueListener listener) {
+ AnimatedNode node = mAnimatedNodes.get(tag);
+ if (node == null || !(node instanceof ValueAnimatedNode)) {
+ throw new JSApplicationIllegalArgumentException("Animated node with tag " + tag +
+ " does not exists or is not a 'value' node");
+ }
+ ((ValueAnimatedNode) node).setValueListener(listener);
+ }
+
+ public void stopListeningToAnimatedNodeValue(int tag) {
+ AnimatedNode node = mAnimatedNodes.get(tag);
+ if (node == null || !(node instanceof ValueAnimatedNode)) {
+ throw new JSApplicationIllegalArgumentException("Animated node with tag " + tag +
+ " does not exists or is not a 'value' node");
+ }
+ ((ValueAnimatedNode) node).setValueListener(null);
+ }
+
+ public void setAnimatedNodeValue(int tag, double value) {
+ AnimatedNode node = mAnimatedNodes.get(tag);
+ if (node == null || !(node instanceof ValueAnimatedNode)) {
+ throw new JSApplicationIllegalArgumentException("Animated node with tag " + tag +
+ " does not exists or is not a 'value' node");
+ }
+ ((ValueAnimatedNode) node).mValue = value;
+ mUpdatedNodes.add(node);
+ }
+
+ public void startAnimatingNode(
+ int animationId,
+ int animatedNodeTag,
+ ReadableMap animationConfig,
+ Callback endCallback) {
+ AnimatedNode node = mAnimatedNodes.get(animatedNodeTag);
+ if (node == null) {
+ throw new JSApplicationIllegalArgumentException("Animated node with tag " + animatedNodeTag +
+ " does not exists");
+ }
+ if (!(node instanceof ValueAnimatedNode)) {
+ throw new JSApplicationIllegalArgumentException("Animated node should be of type " +
+ ValueAnimatedNode.class.getName());
+ }
+ String type = animationConfig.getString("type");
+ final AnimationDriver animation;
+ if ("frames".equals(type)) {
+ animation = new FrameBasedAnimationDriver(animationConfig);
+ } else if ("spring".equals(type)) {
+ animation = new SpringAnimation(animationConfig);
+ } else {
+ throw new JSApplicationIllegalArgumentException("Unsupported animation type: " + type);
+ }
+ animation.mId = animationId;
+ animation.mEndCallback = endCallback;
+ animation.mAnimatedValue = (ValueAnimatedNode) node;
+ mActiveAnimations.add(animation);
+ }
+
+ public void stopAnimation(int animationId) {
+ // in most of the cases there should never be more than a few active animations running at the
+ // same time. Therefore it does not make much sense to create an animationId -> animation
+ // object map that would require additional memory just to support the use-case of stopping
+ // an animation
+ for (int i = 0; i < mActiveAnimations.size(); i++) {
+ AnimationDriver animation = mActiveAnimations.get(i);
+ if (animation.mId == animationId) {
+ // Invoke animation end callback with {finished: false}
+ WritableMap endCallbackResponse = Arguments.createMap();
+ endCallbackResponse.putBoolean("finished", false);
+ animation.mEndCallback.invoke(endCallbackResponse);
+ mActiveAnimations.remove(i);
+ return;
+ }
+ }
+ // Do not throw an error in the case animation could not be found. We only keep "active"
+ // animations in the registry and there is a chance that Animated.js will enqueue a
+ // stopAnimation call after the animation has ended or the call will reach native thread only
+ // when the animation is already over.
+ }
+
+ public void connectAnimatedNodes(int parentNodeTag, int childNodeTag) {
+ AnimatedNode parentNode = mAnimatedNodes.get(parentNodeTag);
+ if (parentNode == null) {
+ throw new JSApplicationIllegalArgumentException("Animated node with tag " + parentNodeTag +
+ " does not exists");
+ }
+ AnimatedNode childNode = mAnimatedNodes.get(childNodeTag);
+ if (childNode == null) {
+ throw new JSApplicationIllegalArgumentException("Animated node with tag " + childNodeTag +
+ " does not exists");
+ }
+ parentNode.addChild(childNode);
+ }
+
+ public void disconnectAnimatedNodes(int parentNodeTag, int childNodeTag) {
+ AnimatedNode parentNode = mAnimatedNodes.get(parentNodeTag);
+ if (parentNode == null) {
+ throw new JSApplicationIllegalArgumentException("Animated node with tag " + parentNodeTag +
+ " does not exists");
+ }
+ AnimatedNode childNode = mAnimatedNodes.get(childNodeTag);
+ if (childNode == null) {
+ throw new JSApplicationIllegalArgumentException("Animated node with tag " + childNodeTag +
+ " does not exists");
+ }
+ parentNode.removeChild(childNode);
+ }
+
+ public void connectAnimatedNodeToView(int animatedNodeTag, int viewTag) {
+ AnimatedNode node = mAnimatedNodes.get(animatedNodeTag);
+ if (node == null) {
+ throw new JSApplicationIllegalArgumentException("Animated node with tag " + animatedNodeTag +
+ " does not exists");
+ }
+ if (!(node instanceof PropsAnimatedNode)) {
+ throw new JSApplicationIllegalArgumentException("Animated node connected to view should be" +
+ "of type " + PropsAnimatedNode.class.getName());
+ }
+ PropsAnimatedNode propsAnimatedNode = (PropsAnimatedNode) node;
+ if (propsAnimatedNode.mConnectedViewTag != -1) {
+ throw new JSApplicationIllegalArgumentException("Animated node " + animatedNodeTag + " is " +
+ "already attached to a view");
+ }
+ propsAnimatedNode.mConnectedViewTag = viewTag;
+ }
+
+ public void disconnectAnimatedNodeFromView(int animatedNodeTag, int viewTag) {
+ AnimatedNode node = mAnimatedNodes.get(animatedNodeTag);
+ if (node == null) {
+ throw new JSApplicationIllegalArgumentException("Animated node with tag " + animatedNodeTag +
+ " does not exists");
+ }
+ if (!(node instanceof PropsAnimatedNode)) {
+ throw new JSApplicationIllegalArgumentException("Animated node connected to view should be" +
+ "of type " + PropsAnimatedNode.class.getName());
+ }
+ PropsAnimatedNode propsAnimatedNode = (PropsAnimatedNode) node;
+ if (propsAnimatedNode.mConnectedViewTag != viewTag) {
+ throw new JSApplicationIllegalArgumentException("Attempting to disconnect view that has " +
+ "not been connected with the given animated node");
+ }
+ propsAnimatedNode.mConnectedViewTag = -1;
+ }
+
+ /**
+ * Animation loop performs two BFSes over the graph of animated nodes. We use incremented
+ * {@code mAnimatedGraphBFSColor} to mark nodes as visited in each of the BFSes which saves
+ * additional loops for clearing "visited" states.
+ *
+ * First BFS starts with nodes that are in {@code mUpdatedNodes} (that is, their value have been
+ * modified from JS in the last batch of JS operations) or directly attached to an active
+ * animation (hence linked to objects from {@code mActiveAnimations}). In that step we calculate
+ * an attribute {@code mActiveIncomingNodes}. The second BFS runs in topological order over the
+ * sub-graph of *active* nodes. This is done by adding node to the BFS queue only if all its
+ * "predecessors" have already been visited.
+ */
+ public void runUpdates(long frameTimeNanos) {
+ UiThreadUtil.assertOnUiThread();
+ int activeNodesCount = 0;
+ int updatedNodesCount = 0;
+ boolean hasFinishedAnimations = false;
+
+ // STEP 1.
+ // BFS over graph of nodes starting from ones from `mUpdatedNodes` and ones that are attached to
+ // active animations (from `mActiveAnimations)`. Update `mIncomingNodes` attribute for each node
+ // during that BFS. Store number of visited nodes in `activeNodesCount`. We "execute" active
+ // animations as a part of this step.
+
+ mAnimatedGraphBFSColor++; /* use new color */
+ if (mAnimatedGraphBFSColor == AnimatedNode.INITIAL_BFS_COLOR) {
+ // value "0" is used as an initial color for a new node, using it in BFS may cause some nodes
+ // to be skipped.
+ mAnimatedGraphBFSColor++;
+ }
+
+ Queue nodesQueue = new ArrayDeque<>();
+ for (int i = 0; i < mUpdatedNodes.size(); i++) {
+ AnimatedNode node = mUpdatedNodes.get(i);
+ if (node.mBFSColor != mAnimatedGraphBFSColor) {
+ node.mBFSColor = mAnimatedGraphBFSColor;
+ activeNodesCount++;
+ nodesQueue.add(node);
+ }
+ }
+
+ for (int i = 0; i < mActiveAnimations.size(); i++) {
+ AnimationDriver animation = mActiveAnimations.get(i);
+ animation.runAnimationStep(frameTimeNanos);
+ AnimatedNode valueNode = animation.mAnimatedValue;
+ if (valueNode.mBFSColor != mAnimatedGraphBFSColor) {
+ valueNode.mBFSColor = mAnimatedGraphBFSColor;
+ activeNodesCount++;
+ nodesQueue.add(valueNode);
+ }
+ if (animation.mHasFinished) {
+ hasFinishedAnimations = true;
+ }
+ }
+
+ while (!nodesQueue.isEmpty()) {
+ AnimatedNode nextNode = nodesQueue.poll();
+ if (nextNode.mChildren != null) {
+ for (int i = 0; i < nextNode.mChildren.size(); i++) {
+ AnimatedNode child = nextNode.mChildren.get(i);
+ child.mActiveIncomingNodes++;
+ if (child.mBFSColor != mAnimatedGraphBFSColor) {
+ child.mBFSColor = mAnimatedGraphBFSColor;
+ activeNodesCount++;
+ nodesQueue.add(child);
+ }
+ }
+ }
+ }
+
+ // STEP 2
+ // BFS over the graph of active nodes in topological order -> visit node only when all its
+ // "predecessors" in the graph have already been visited. It is important to visit nodes in that
+ // order as they may often use values of their predecessors in order to calculate "next state"
+ // of their own. We start by determining the starting set of nodes by looking for nodes with
+ // `mActiveIncomingNodes = 0` (those can only be the ones that we start BFS in the previous
+ // step). We store number of visited nodes in this step in `updatedNodesCount`
+
+ mAnimatedGraphBFSColor++;
+ if (mAnimatedGraphBFSColor == AnimatedNode.INITIAL_BFS_COLOR) {
+ // see reasoning for this check a few lines above
+ mAnimatedGraphBFSColor++;
+ }
+
+ // find nodes with zero "incoming nodes", those can be either nodes from `mUpdatedNodes` or
+ // ones connected to active animations
+ for (int i = 0; i < mUpdatedNodes.size(); i++) {
+ AnimatedNode node = mUpdatedNodes.get(i);
+ if (node.mActiveIncomingNodes == 0 && node.mBFSColor != mAnimatedGraphBFSColor) {
+ node.mBFSColor = mAnimatedGraphBFSColor;
+ updatedNodesCount++;
+ nodesQueue.add(node);
+ }
+ }
+ for (int i = 0; i < mActiveAnimations.size(); i++) {
+ AnimationDriver animation = mActiveAnimations.get(i);
+ AnimatedNode valueNode = animation.mAnimatedValue;
+ if (valueNode.mActiveIncomingNodes == 0 && valueNode.mBFSColor != mAnimatedGraphBFSColor) {
+ valueNode.mBFSColor = mAnimatedGraphBFSColor;
+ updatedNodesCount++;
+ nodesQueue.add(valueNode);
+ }
+ }
+
+ // Run main "update" loop
+ while (!nodesQueue.isEmpty()) {
+ AnimatedNode nextNode = nodesQueue.poll();
+ nextNode.update();
+ if (nextNode instanceof PropsAnimatedNode) {
+ // Send property updates to native view manager
+ ((PropsAnimatedNode) nextNode).updateView(mUIImplementation);
+ }
+ if (nextNode instanceof ValueAnimatedNode) {
+ // Potentially send events to JS when the node's value is updated
+ ((ValueAnimatedNode) nextNode).onValueUpdate();
+ }
+ if (nextNode.mChildren != null) {
+ for (int i = 0; i < nextNode.mChildren.size(); i++) {
+ AnimatedNode child = nextNode.mChildren.get(i);
+ child.mActiveIncomingNodes--;
+ if (child.mBFSColor != mAnimatedGraphBFSColor && child.mActiveIncomingNodes == 0) {
+ child.mBFSColor = mAnimatedGraphBFSColor;
+ updatedNodesCount++;
+ nodesQueue.add(child);
+ }
+ }
+ }
+ }
+
+ // Verify that we've visited *all* active nodes. Throw otherwise as this would mean there is a
+ // cycle in animated node graph. We also take advantage of the fact that all active nodes are
+ // visited in the step above so that all the nodes properties `mActiveIncomingNodes` are set to
+ // zero
+ if (activeNodesCount != updatedNodesCount) {
+ throw new IllegalStateException("Looks like animated nodes graph has cycles, there are "
+ + activeNodesCount + " but toposort visited only " + updatedNodesCount);
+ }
+
+ // Clean mUpdatedNodes queue
+ mUpdatedNodes.clear();
+
+ // Cleanup finished animations. Iterate over the array of animations and override ones that has
+ // finished, then resize `mActiveAnimations`.
+ if (hasFinishedAnimations) {
+ int dest = 0;
+ for (int i = 0; i < mActiveAnimations.size(); i++) {
+ AnimationDriver animation = mActiveAnimations.get(i);
+ if (!animation.mHasFinished) {
+ mActiveAnimations.set(dest++, animation);
+ } else {
+ WritableMap endCallbackResponse = Arguments.createMap();
+ endCallbackResponse.putBoolean("finished", true);
+ animation.mEndCallback.invoke(endCallbackResponse);
+ }
+ }
+ for (int i = mActiveAnimations.size() - 1; i >= dest; i--) {
+ mActiveAnimations.remove(i);
+ }
+ }
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/animated/PropsAnimatedNode.java b/android/ReactAndroid/src/main/java/com/facebook/react/animated/PropsAnimatedNode.java
new file mode 100644
index 00000000000000..d0c9f09e047697
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/animated/PropsAnimatedNode.java
@@ -0,0 +1,75 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.animated;
+
+import com.facebook.react.bridge.JavaOnlyMap;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableMapKeySetIterator;
+import com.facebook.react.uimanager.NativeViewHierarchyManager;
+import com.facebook.react.uimanager.ReactStylesDiffMap;
+import com.facebook.react.uimanager.UIImplementation;
+import com.facebook.react.uimanager.UIManagerModule;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.annotation.Nullable;
+
+/**
+ * Animated node that represents view properties. There is a special handling logic implemented for
+ * the nodes of this type in {@link NativeAnimatedNodesManager} that is responsible for extracting
+ * a map of updated properties, which can be then passed down to the view.
+ */
+/*package*/ class PropsAnimatedNode extends AnimatedNode {
+
+ /*package*/ int mConnectedViewTag = -1;
+
+ private final NativeAnimatedNodesManager mNativeAnimatedNodesManager;
+ private final Map mPropMapping;
+
+ PropsAnimatedNode(ReadableMap config, NativeAnimatedNodesManager nativeAnimatedNodesManager) {
+ ReadableMap props = config.getMap("props");
+ ReadableMapKeySetIterator iter = props.keySetIterator();
+ mPropMapping = new HashMap<>();
+ while (iter.hasNextKey()) {
+ String propKey = iter.nextKey();
+ int nodeIndex = props.getInt(propKey);
+ mPropMapping.put(propKey, nodeIndex);
+ }
+ mNativeAnimatedNodesManager = nativeAnimatedNodesManager;
+ }
+
+ public final void updateView(UIImplementation uiImplementation) {
+ if (mConnectedViewTag == -1) {
+ throw new IllegalStateException("Node has not been attached to a view");
+ }
+ JavaOnlyMap propsMap = new JavaOnlyMap();
+ for (Map.Entry entry : mPropMapping.entrySet()) {
+ @Nullable AnimatedNode node = mNativeAnimatedNodesManager.getNodeById(entry.getValue());
+ if (node == null) {
+ throw new IllegalArgumentException("Mapped property node does not exists");
+ } else if (node instanceof StyleAnimatedNode) {
+ ((StyleAnimatedNode) node).collectViewUpdates(propsMap);
+ } else if (node instanceof ValueAnimatedNode) {
+ propsMap.putDouble(entry.getKey(), ((ValueAnimatedNode) node).mValue);
+ } else {
+ throw new IllegalArgumentException("Unsupported type of node used in property node " +
+ node.getClass());
+ }
+ }
+ // TODO: Reuse propsMap and stylesDiffMap objects - note that in subsequent animation steps
+ // for a given node most of the time we will be creating the same set of props (just with
+ // different values). We can take advantage on that and optimize the way we allocate property
+ // maps (we also know that updating view props doesn't retain a reference to the styles object).
+ uiImplementation.synchronouslyUpdateViewOnUIThread(
+ mConnectedViewTag,
+ new ReactStylesDiffMap(propsMap));
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/animated/SpringAnimation.java b/android/ReactAndroid/src/main/java/com/facebook/react/animated/SpringAnimation.java
new file mode 100644
index 00000000000000..7cb14d109f62e3
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/animated/SpringAnimation.java
@@ -0,0 +1,218 @@
+package com.facebook.react.animated;
+
+import com.facebook.react.bridge.ReadableMap;
+
+/**
+ * Implementation of {@link AnimationDriver} providing support for spring animations. The
+ * implementation has been copied from android implementation of Rebound library (see
+ * http://facebook.github.io/rebound/)
+ */
+/*package*/ class SpringAnimation extends AnimationDriver {
+
+ // maximum amount of time to simulate per physics iteration in seconds (4 frames at 60 FPS)
+ private static final double MAX_DELTA_TIME_SEC = 0.064;
+ // fixed timestep to use in the physics solver in seconds
+ private static final double SOLVER_TIMESTEP_SEC = 0.001;
+
+ // storage for the current and prior physics state while integration is occurring
+ private static class PhysicsState {
+ double position;
+ double velocity;
+ }
+
+ private long mLastTime;
+ private boolean mSpringStarted;
+
+ // configuration
+ private double mSpringFriction;
+ private double mSpringTension;
+ private boolean mOvershootClampingEnabled;
+
+ // all physics simulation objects are final and reused in each processing pass
+ private final PhysicsState mCurrentState = new PhysicsState();
+ private final PhysicsState mPreviousState = new PhysicsState();
+ private final PhysicsState mTempState = new PhysicsState();
+ private double mStartValue;
+ private double mEndValue;
+ // thresholds for determining when the spring is at rest
+ private double mRestSpeedThreshold;
+ private double mDisplacementFromRestThreshold;
+ private double mTimeAccumulator = 0;
+
+ SpringAnimation(ReadableMap config) {
+ mSpringFriction = config.getDouble("friction");
+ mSpringTension = config.getDouble("tension");
+ mCurrentState.velocity = config.getDouble("initialVelocity");
+ mEndValue = config.getDouble("toValue");
+ mRestSpeedThreshold = config.getDouble("restSpeedThreshold");
+ mDisplacementFromRestThreshold = config.getDouble("restDisplacementThreshold");
+ mOvershootClampingEnabled = config.getBoolean("overshootClamping");
+ }
+
+ @Override
+ public void runAnimationStep(long frameTimeNanos) {
+ long frameTimeMillis = frameTimeNanos / 1000000;
+ if (!mSpringStarted) {
+ mStartValue = mCurrentState.position = mAnimatedValue.mValue;
+ mLastTime = frameTimeMillis;
+ mSpringStarted = true;
+ }
+ advance((frameTimeMillis - mLastTime) / 1000.0);
+ mLastTime = frameTimeMillis;
+ mAnimatedValue.mValue = mCurrentState.position;
+ mHasFinished = isAtRest();
+ }
+
+ /**
+ * get the displacement from rest for a given physics state
+ * @param state the state to measure from
+ * @return the distance displaced by
+ */
+ private double getDisplacementDistanceForState(PhysicsState state) {
+ return Math.abs(mEndValue - state.position);
+ }
+
+ /**
+ * check if the current state is at rest
+ * @return is the spring at rest
+ */
+ private boolean isAtRest() {
+ return Math.abs(mCurrentState.velocity) <= mRestSpeedThreshold &&
+ (getDisplacementDistanceForState(mCurrentState) <= mDisplacementFromRestThreshold ||
+ mSpringTension == 0);
+ }
+
+ /**
+ * Check if the spring is overshooting beyond its target.
+ * @return true if the spring is overshooting its target
+ */
+ private boolean isOvershooting() {
+ return mSpringTension > 0 &&
+ ((mStartValue < mEndValue && mCurrentState.position > mEndValue) ||
+ (mStartValue > mEndValue && mCurrentState.position < mEndValue));
+ }
+
+ /**
+ * linear interpolation between the previous and current physics state based on the amount of
+ * timestep remaining after processing the rendering delta time in timestep sized chunks.
+ * @param alpha from 0 to 1, where 0 is the previous state, 1 is the current state
+ */
+ private void interpolate(double alpha) {
+ mCurrentState.position = mCurrentState.position * alpha + mPreviousState.position *(1-alpha);
+ mCurrentState.velocity = mCurrentState.velocity * alpha + mPreviousState.velocity *(1-alpha);
+ }
+
+ /**
+ * advance the physics simulation in SOLVER_TIMESTEP_SEC sized chunks to fulfill the required
+ * realTimeDelta.
+ * The math is inlined inside the loop since it made a huge performance impact when there are
+ * several springs being advanced.
+ * @param time clock time
+ * @param realDeltaTime clock drift
+ */
+ private void advance(double realDeltaTime) {
+
+ if (isAtRest()) {
+ return;
+ }
+
+ // clamp the amount of realTime to simulate to avoid stuttering in the UI. We should be able
+ // to catch up in a subsequent advance if necessary.
+ double adjustedDeltaTime = realDeltaTime;
+ if (realDeltaTime > MAX_DELTA_TIME_SEC) {
+ adjustedDeltaTime = MAX_DELTA_TIME_SEC;
+ }
+
+ mTimeAccumulator += adjustedDeltaTime;
+
+ double tension = mSpringTension;
+ double friction = mSpringFriction;
+
+ double position = mCurrentState.position;
+ double velocity = mCurrentState.velocity;
+ double tempPosition = mTempState.position;
+ double tempVelocity = mTempState.velocity;
+
+ double aVelocity, aAcceleration;
+ double bVelocity, bAcceleration;
+ double cVelocity, cAcceleration;
+ double dVelocity, dAcceleration;
+
+ double dxdt, dvdt;
+
+ // iterate over the true time
+ while (mTimeAccumulator >= SOLVER_TIMESTEP_SEC) {
+ /* begin debug
+ iterations++;
+ end debug */
+ mTimeAccumulator -= SOLVER_TIMESTEP_SEC;
+
+ if (mTimeAccumulator < SOLVER_TIMESTEP_SEC) {
+ // This will be the last iteration. Remember the previous state in case we need to
+ // interpolate
+ mPreviousState.position = position;
+ mPreviousState.velocity = velocity;
+ }
+
+ // Perform an RK4 integration to provide better detection of the acceleration curve via
+ // sampling of Euler integrations at 4 intervals feeding each derivative into the calculation
+ // of the next and taking a weighted sum of the 4 derivatives as the final output.
+
+ // This math was inlined since it made for big performance improvements when advancing several
+ // springs in one pass of the BaseSpringSystem.
+
+ // The initial derivative is based on the current velocity and the calculated acceleration
+ aVelocity = velocity;
+ aAcceleration = (tension * (mEndValue - tempPosition)) - friction * velocity;
+
+ // Calculate the next derivatives starting with the last derivative and integrating over the
+ // timestep
+ tempPosition = position + aVelocity * SOLVER_TIMESTEP_SEC * 0.5;
+ tempVelocity = velocity + aAcceleration * SOLVER_TIMESTEP_SEC * 0.5;
+ bVelocity = tempVelocity;
+ bAcceleration = (tension * (mEndValue - tempPosition)) - friction * tempVelocity;
+
+ tempPosition = position + bVelocity * SOLVER_TIMESTEP_SEC * 0.5;
+ tempVelocity = velocity + bAcceleration * SOLVER_TIMESTEP_SEC * 0.5;
+ cVelocity = tempVelocity;
+ cAcceleration = (tension * (mEndValue - tempPosition)) - friction * tempVelocity;
+
+ tempPosition = position + cVelocity * SOLVER_TIMESTEP_SEC;
+ tempVelocity = velocity + cAcceleration * SOLVER_TIMESTEP_SEC;
+ dVelocity = tempVelocity;
+ dAcceleration = (tension * (mEndValue - tempPosition)) - friction * tempVelocity;
+
+ // Take the weighted sum of the 4 derivatives as the final output.
+ dxdt = 1.0/6.0 * (aVelocity + 2.0 * (bVelocity + cVelocity) + dVelocity);
+ dvdt = 1.0/6.0 * (aAcceleration + 2.0 * (bAcceleration + cAcceleration) + dAcceleration);
+
+ position += dxdt * SOLVER_TIMESTEP_SEC;
+ velocity += dvdt * SOLVER_TIMESTEP_SEC;
+ }
+
+ mTempState.position = tempPosition;
+ mTempState.velocity = tempVelocity;
+
+ mCurrentState.position = position;
+ mCurrentState.velocity = velocity;
+
+ if (mTimeAccumulator > 0) {
+ interpolate(mTimeAccumulator / SOLVER_TIMESTEP_SEC);
+ }
+
+ // End the spring immediately if it is overshooting and overshoot clamping is enabled.
+ // Also make sure that if the spring was considered within a resting threshold that it's now
+ // snapped to its end value.
+ if (isAtRest() || (mOvershootClampingEnabled && isOvershooting())) {
+ // Don't call setCurrentValue because that forces a call to onSpringUpdate
+ if (tension > 0) {
+ mStartValue = mEndValue;
+ mCurrentState.position = mEndValue;
+ } else {
+ mEndValue = mCurrentState.position;
+ mStartValue = mEndValue;
+ }
+ mCurrentState.velocity = 0;
+ }
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/animated/StyleAnimatedNode.java b/android/ReactAndroid/src/main/java/com/facebook/react/animated/StyleAnimatedNode.java
new file mode 100644
index 00000000000000..f23cf248adc0d8
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/animated/StyleAnimatedNode.java
@@ -0,0 +1,56 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.animated;
+
+import com.facebook.react.bridge.JavaOnlyMap;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableMapKeySetIterator;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.annotation.Nullable;
+
+/**
+ * Native counterpart of style animated node (see AnimatedStyle class in AnimatedImplementation.js)
+ */
+/*package*/ class StyleAnimatedNode extends AnimatedNode {
+
+ private final NativeAnimatedNodesManager mNativeAnimatedNodesManager;
+ private final Map mPropMapping;
+
+ StyleAnimatedNode(ReadableMap config, NativeAnimatedNodesManager nativeAnimatedNodesManager) {
+ ReadableMap style = config.getMap("style");
+ ReadableMapKeySetIterator iter = style.keySetIterator();
+ mPropMapping = new HashMap<>();
+ while (iter.hasNextKey()) {
+ String propKey = iter.nextKey();
+ int nodeIndex = style.getInt(propKey);
+ mPropMapping.put(propKey, nodeIndex);
+ }
+ mNativeAnimatedNodesManager = nativeAnimatedNodesManager;
+ }
+
+ public void collectViewUpdates(JavaOnlyMap propsMap) {
+ for (Map.Entry entry : mPropMapping.entrySet()) {
+ @Nullable AnimatedNode node = mNativeAnimatedNodesManager.getNodeById(entry.getValue());
+ if (node == null) {
+ throw new IllegalArgumentException("Mapped style node does not exists");
+ } else if (node instanceof TransformAnimatedNode) {
+ ((TransformAnimatedNode) node).collectViewUpdates(propsMap);
+ } else if (node instanceof ValueAnimatedNode) {
+ propsMap.putDouble(entry.getKey(), ((ValueAnimatedNode) node).mValue);
+ } else {
+ throw new IllegalArgumentException("Unsupported type of node used in property node " +
+ node.getClass());
+ }
+ }
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/animated/TransformAnimatedNode.java b/android/ReactAndroid/src/main/java/com/facebook/react/animated/TransformAnimatedNode.java
new file mode 100644
index 00000000000000..89bd2c26f74175
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/animated/TransformAnimatedNode.java
@@ -0,0 +1,122 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.animated;
+
+import com.facebook.react.bridge.JavaOnlyArray;
+import com.facebook.react.bridge.JavaOnlyMap;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableMapKeySetIterator;
+import com.facebook.react.bridge.ReadableType;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.uimanager.MatrixMathHelper;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Native counterpart of transform animated node (see AnimatedTransform class in AnimatedImplementation.js)
+ */
+/* package */ class TransformAnimatedNode extends AnimatedNode {
+
+ private final NativeAnimatedNodesManager mNativeAnimatedNodesManager;
+ private final Map mPropMapping;
+
+ TransformAnimatedNode(ReadableMap config, NativeAnimatedNodesManager nativeAnimatedNodesManager) {
+ ReadableMap transforms = config.getMap("animated");
+ ReadableMapKeySetIterator iter = transforms.keySetIterator();
+ mPropMapping = new HashMap<>();
+ while (iter.hasNextKey()) {
+ String propKey = iter.nextKey();
+ int nodeIndex = transforms.getInt(propKey);
+ mPropMapping.put(propKey, nodeIndex);
+ }
+ ReadableMap statics = config.getMap("statics");
+ iter = statics.keySetIterator();
+ while (iter.hasNextKey()) {
+ String propKey = iter.nextKey();
+ switch (statics.getType(propKey)) {
+ case Number:
+ mPropMapping.put(propKey, statics.getDouble(propKey));
+ break;
+ case String:
+ mPropMapping.put(
+ propKey,
+ NativeAnimatedHelper.parseAngle(statics.getString(propKey)));
+ break;
+ }
+
+ }
+ mNativeAnimatedNodesManager = nativeAnimatedNodesManager;
+ }
+
+ public void collectViewUpdates(JavaOnlyMap propsMap) {
+ double[] matrix = MatrixMathHelper.createIdentity();
+
+ // Convert each transform to a matrix and multiply them together.
+ for (Map.Entry entry : mPropMapping.entrySet()) {
+ Object entryValue = entry.getValue();
+ String entryKey = entry.getKey();
+
+ // Get the current value of the transform. Animated nodes will be an Integer
+ // representing the node id and static values will be a Double.
+ double transformValue = -1;
+ if (entryValue instanceof Integer) {
+ AnimatedNode node = mNativeAnimatedNodesManager.getNodeById((Integer) entryValue);
+ if (node == null) {
+ throw new IllegalArgumentException("Mapped style node does not exists");
+ } else if (node instanceof ValueAnimatedNode) {
+ transformValue = ((ValueAnimatedNode) node).mValue;
+ } else {
+ throw new IllegalArgumentException("Unsupported type of node used as a transform child " +
+ "node " + node.getClass());
+ }
+ } else {
+ transformValue = (double) entryValue;
+ }
+
+ // TODO: Optimise these matrix maths to avoid allocations for each transform.
+ switch(entryKey) {
+ case "scaleX":
+ matrix = MatrixMathHelper.multiply(
+ MatrixMathHelper.createScale3d(transformValue, 1, 1), matrix);
+ break;
+ case "scaleY":
+ matrix = MatrixMathHelper.multiply(
+ MatrixMathHelper.createScale3d(1, transformValue, 1), matrix);
+ break;
+ case "scale":
+ matrix = MatrixMathHelper.multiply(
+ MatrixMathHelper.createScale3d(transformValue, transformValue, 1), matrix);
+ break;
+ case "translateX":
+ matrix = MatrixMathHelper.multiply(
+ MatrixMathHelper.createTranslate3d(transformValue, 0, 0), matrix);
+ break;
+ case "translateY":
+ matrix = MatrixMathHelper.multiply(
+ MatrixMathHelper.createTranslate3d(0, transformValue, 0), matrix);
+ break;
+ case "rotate":
+ matrix = MatrixMathHelper.multiply(
+ MatrixMathHelper.createRotateZ(transformValue), matrix);
+ }
+ }
+
+ // Box the double array to allow passing it as a JavaOnlyArray.
+ ArrayList matrixList = new ArrayList<>(16);
+ for (double ele : matrix) {
+ matrixList.add(ele);
+ }
+
+ propsMap.putArray("transform", JavaOnlyArray.from(matrixList));
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/animated/ValueAnimatedNode.java b/android/ReactAndroid/src/main/java/com/facebook/react/animated/ValueAnimatedNode.java
new file mode 100644
index 00000000000000..4d8a42d5fcb7b6
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/animated/ValueAnimatedNode.java
@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.animated;
+
+import com.facebook.react.bridge.ReadableMap;
+
+import javax.annotation.Nullable;
+
+/**
+ * Basic type of animated node that maps directly from {@code Animated.Value(x)} of Animated.js
+ * library.
+ */
+/*package*/ class ValueAnimatedNode extends AnimatedNode {
+ /*package*/ double mValue = Double.NaN;
+ private @Nullable AnimatedNodeValueListener mValueListener;
+
+ public ValueAnimatedNode() {
+ // empty constructor that can be used by subclasses
+ }
+
+ public ValueAnimatedNode(ReadableMap config) {
+ mValue = config.getDouble("value");
+ }
+
+ public void onValueUpdate() {
+ if (mValueListener == null) {
+ return;
+ }
+ mValueListener.onValueUpdate(mValue);
+ }
+
+ public void setValueListener(@Nullable AnimatedNodeValueListener listener) {
+ mValueListener = listener;
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/animation/AbstractFloatPairPropertyUpdater.java b/android/ReactAndroid/src/main/java/com/facebook/react/animation/AbstractFloatPairPropertyUpdater.java
new file mode 100644
index 00000000000000..0ef9cc9e6a93bf
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/animation/AbstractFloatPairPropertyUpdater.java
@@ -0,0 +1,64 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.animation;
+
+import android.view.View;
+
+/**
+ * Base class for {@link AnimationPropertyUpdater} subclasses that updates a pair of float property
+ * values. It helps to handle convertion from animation progress to the actual values as
+ * well as the quite common case when no starting value is provided.
+ */
+public abstract class AbstractFloatPairPropertyUpdater implements AnimationPropertyUpdater {
+
+ private final float[] mFromValues = new float[2];
+ private final float[] mToValues = new float[2];
+ private final float[] mUpdateValues = new float[2];
+ private boolean mFromSource;
+
+ protected AbstractFloatPairPropertyUpdater(float toFirst, float toSecond) {
+ mToValues[0] = toFirst;
+ mToValues[1] = toSecond;
+ mFromSource = true;
+ }
+
+ protected AbstractFloatPairPropertyUpdater(
+ float fromFirst,
+ float fromSecond,
+ float toFirst,
+ float toSecond) {
+ this(toFirst, toSecond);
+ mFromValues[0] = fromFirst;
+ mFromValues[1] = fromSecond;
+ mFromSource = false;
+ }
+
+ protected abstract void getProperty(View view, float[] returnValues);
+ protected abstract void setProperty(View view, float[] propertyValues);
+
+ @Override
+ public void prepare(View view) {
+ if (mFromSource) {
+ getProperty(view, mFromValues);
+ }
+ }
+
+ @Override
+ public void onUpdate(View view, float progress) {
+ mUpdateValues[0] = mFromValues[0] + (mToValues[0] - mFromValues[0]) * progress;
+ mUpdateValues[1] = mFromValues[1] + (mToValues[1] - mFromValues[1]) * progress;
+ setProperty(view, mUpdateValues);
+ }
+
+ @Override
+ public void onFinish(View view) {
+ setProperty(view, mToValues);
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/animation/AbstractSingleFloatProperyUpdater.java b/android/ReactAndroid/src/main/java/com/facebook/react/animation/AbstractSingleFloatProperyUpdater.java
new file mode 100644
index 00000000000000..e50bbfeaf402ca
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/animation/AbstractSingleFloatProperyUpdater.java
@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.animation;
+
+import android.view.View;
+
+/**
+ * Base class for {@link AnimationPropertyUpdater} subclasses that updates a single float property
+ * value. It helps to handle convertion from animation progress to the actual value as well as the
+ * quite common case when no starting value is provided.
+ */
+public abstract class AbstractSingleFloatProperyUpdater implements AnimationPropertyUpdater {
+
+ private float mFromValue, mToValue;
+ private boolean mFromSource;
+
+ protected AbstractSingleFloatProperyUpdater(float toValue) {
+ mToValue = toValue;
+ mFromSource = true;
+ }
+
+ protected AbstractSingleFloatProperyUpdater(float fromValue, float toValue) {
+ this(toValue);
+ mFromValue = fromValue;
+ mFromSource = false;
+ }
+
+ protected abstract float getProperty(View view);
+ protected abstract void setProperty(View view, float propertyValue);
+
+ @Override
+ public final void prepare(View view) {
+ if (mFromSource) {
+ mFromValue = getProperty(view);
+ }
+ }
+
+ @Override
+ public final void onUpdate(View view, float progress) {
+ setProperty(view, mFromValue + (mToValue - mFromValue) * progress);
+ }
+
+ @Override
+ public void onFinish(View view) {
+ setProperty(view, mToValue);
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/animation/Animation.java b/android/ReactAndroid/src/main/java/com/facebook/react/animation/Animation.java
new file mode 100644
index 00000000000000..37a6d2a1969997
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/animation/Animation.java
@@ -0,0 +1,107 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.animation;
+
+import javax.annotation.Nullable;
+
+import android.view.View;
+
+import com.facebook.infer.annotation.Assertions;
+
+/**
+ * Base class for various catalyst animation engines. Subclasses of this class should implement
+ * {@link #run} method which should bootstrap the animation. Then in each animation frame we expect
+ * animation engine to call {@link #onUpdate} with a float progress which then will be transferred
+ * to the underlying {@link AnimationPropertyUpdater} instance.
+ *
+ * Animation engine should support animation cancelling by monitoring the returned value of
+ * {@link #onUpdate}. In case of returning false, animation should be considered cancelled and
+ * engine should not attempt to call {@link #onUpdate} again.
+ */
+public abstract class Animation {
+
+ private final int mAnimationID;
+ private final AnimationPropertyUpdater mPropertyUpdater;
+ private volatile boolean mCancelled = false;
+ private volatile boolean mIsFinished = false;
+ private @Nullable AnimationListener mAnimationListener;
+ private @Nullable View mAnimatedView;
+
+ public Animation(int animationID, AnimationPropertyUpdater propertyUpdater) {
+ mAnimationID = animationID;
+ mPropertyUpdater = propertyUpdater;
+ }
+
+ public void setAnimationListener(AnimationListener animationListener) {
+ mAnimationListener = animationListener;
+ }
+
+ public final void start(View view) {
+ mAnimatedView = view;
+ mPropertyUpdater.prepare(view);
+ run();
+ }
+
+ public abstract void run();
+
+ /**
+ * Animation engine should call this method for every animation frame passing animation progress
+ * value as a parameter. Animation progress should be within the range 0..1 (the exception here
+ * would be a spring animation engine which may slightly exceed start and end progress values).
+ *
+ * This method will return false if the animation has been cancelled. In that case animation
+ * engine should not attempt to call this method again. Otherwise this method will return true
+ */
+ protected final boolean onUpdate(float value) {
+ Assertions.assertCondition(!mIsFinished, "Animation must not already be finished!");
+ if (!mCancelled) {
+ mPropertyUpdater.onUpdate(Assertions.assertNotNull(mAnimatedView), value);
+ }
+ return !mCancelled;
+ }
+
+ /**
+ * Animation engine should call this method when the animation is finished. Should be called only
+ * once
+ */
+ protected final void finish() {
+ Assertions.assertCondition(!mIsFinished, "Animation must not already be finished!");
+ mIsFinished = true;
+ if (!mCancelled) {
+ if (mAnimatedView != null) {
+ mPropertyUpdater.onFinish(mAnimatedView);
+ }
+ if (mAnimationListener != null) {
+ mAnimationListener.onFinished();
+ }
+ }
+ }
+
+ /**
+ * Cancels the animation.
+ *
+ * It is possible for this to be called after finish() and should handle that gracefully.
+ */
+ public final void cancel() {
+ if (mIsFinished || mCancelled) {
+ // If we were already finished, ignore
+ return;
+ }
+
+ mCancelled = true;
+ if (mAnimationListener != null) {
+ mAnimationListener.onCancel();
+ }
+ }
+
+ public int getAnimationID() {
+ return mAnimationID;
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/animation/AnimationListener.java b/android/ReactAndroid/src/main/java/com/facebook/react/animation/AnimationListener.java
new file mode 100644
index 00000000000000..a3678ed91ff26c
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/animation/AnimationListener.java
@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.animation;
+
+/**
+ * Interface for getting animation lifecycle updates. It is guaranteed that for a given animation,
+ * only one of onFinished and onCancel will be called, and it will be called exactly once.
+ */
+public interface AnimationListener {
+
+ /**
+ * Called once animation is finished
+ */
+ public void onFinished();
+
+ /**
+ * Called in case when animation was cancelled
+ */
+ public void onCancel();
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/animation/AnimationPropertyUpdater.java b/android/ReactAndroid/src/main/java/com/facebook/react/animation/AnimationPropertyUpdater.java
new file mode 100644
index 00000000000000..3cbdbf3327df85
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/animation/AnimationPropertyUpdater.java
@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.animation;
+
+import android.view.View;
+
+/**
+ * Interface used to update particular property types during animation. While animation is in
+ * progress {@link Animation} instance will call {@link #onUpdate} several times with a value
+ * representing animation progress. Normally value will be from 0..1 range, but for spring animation
+ * it can slightly exceed that limit due to bounce effect at the start/end of animation.
+ */
+public interface AnimationPropertyUpdater {
+
+ /**
+ * This method will be called before animation starts.
+ *
+ * @param view view that will be animated
+ */
+ public void prepare(View view);
+
+ /**
+ * This method will be called for each animation frame
+ *
+ * @param view view to update property
+ * @param progress animation progress from 0..1 range (may slightly exceed that limit in case of
+ * spring engine) retrieved from {@link Animation} engine.
+ */
+ public void onUpdate(View view, float progress);
+
+ /**
+ * This method will be called at the end of animation. It should be used to set the final values
+ * for animated properties in order to avoid floating point inacurracy calculated in
+ * {@link #onUpdate} by passing value close to 1.0 or in a case some frames got dropped.
+ *
+ * @param view view to update property
+ */
+ public void onFinish(View view);
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/animation/AnimationRegistry.java b/android/ReactAndroid/src/main/java/com/facebook/react/animation/AnimationRegistry.java
new file mode 100644
index 00000000000000..74f0bedf47ef59
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/animation/AnimationRegistry.java
@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.animation;
+
+import android.util.SparseArray;
+
+import com.facebook.react.bridge.UiThreadUtil;
+
+/**
+ * Coordinates catalyst animations driven by {@link UIManagerModule} and
+ * {@link AnimationManagerModule}
+ */
+public class AnimationRegistry {
+
+ private final SparseArray mRegistry = new SparseArray();
+
+ public void registerAnimation(Animation animation) {
+ UiThreadUtil.assertOnUiThread();
+ mRegistry.put(animation.getAnimationID(), animation);
+ }
+
+ public Animation getAnimation(int animationID) {
+ UiThreadUtil.assertOnUiThread();
+ return mRegistry.get(animationID);
+ }
+
+ public Animation removeAnimation(int animationID) {
+ UiThreadUtil.assertOnUiThread();
+ Animation animation = mRegistry.get(animationID);
+ if (animation != null) {
+ mRegistry.delete(animationID);
+ }
+ return animation;
+ }
+
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/animation/BUCK b/android/ReactAndroid/src/main/java/com/facebook/react/animation/BUCK
new file mode 100644
index 00000000000000..6a3307d027a7e6
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/animation/BUCK
@@ -0,0 +1,18 @@
+include_defs('//ReactAndroid/DEFS')
+
+android_library(
+ name = 'animation',
+ srcs = glob(['**/*.java']),
+ deps = [
+ react_native_target('java/com/facebook/react/bridge:bridge'),
+ react_native_dep('third-party/java/infer-annotations:infer-annotations'),
+ react_native_dep('third-party/java/jsr-305:jsr-305'),
+ ],
+ visibility = [
+ 'PUBLIC'
+ ],
+)
+
+project_config(
+ src_target = ':animation',
+)
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/animation/ImmediateAnimation.java b/android/ReactAndroid/src/main/java/com/facebook/react/animation/ImmediateAnimation.java
new file mode 100644
index 00000000000000..da72250548190e
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/animation/ImmediateAnimation.java
@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.animation;
+
+/**
+ * Ignores duration and immediately jump to the end of animation. This is a temporal solution for
+ * the lack of real animation engines implemented.
+ */
+public class ImmediateAnimation extends Animation {
+
+ public ImmediateAnimation(int animationID, AnimationPropertyUpdater propertyUpdater) {
+ super(animationID, propertyUpdater);
+ }
+
+ @Override
+ public void run() {
+ onUpdate(1.0f);
+ finish();
+ }
+
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/animation/NoopAnimationPropertyUpdater.java b/android/ReactAndroid/src/main/java/com/facebook/react/animation/NoopAnimationPropertyUpdater.java
new file mode 100644
index 00000000000000..83dbe3d9aebc11
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/animation/NoopAnimationPropertyUpdater.java
@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.animation;
+
+import android.view.View;
+
+/**
+ * Empty {@link AnimationPropertyUpdater} that can be used as a stub for unsupported property types
+ */
+public class NoopAnimationPropertyUpdater implements AnimationPropertyUpdater {
+
+ @Override
+ public void prepare(View view) {
+ }
+
+ @Override
+ public void onUpdate(View view, float value) {
+ }
+
+ @Override
+ public void onFinish(View view) {
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/animation/OpacityAnimationPropertyUpdater.java b/android/ReactAndroid/src/main/java/com/facebook/react/animation/OpacityAnimationPropertyUpdater.java
new file mode 100644
index 00000000000000..d1acf3da59174d
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/animation/OpacityAnimationPropertyUpdater.java
@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.animation;
+
+import android.view.View;
+
+/**
+ * Subclass of {@link AnimationPropertyUpdater} for animating view's opacity
+ */
+public class OpacityAnimationPropertyUpdater extends AbstractSingleFloatProperyUpdater {
+
+ public OpacityAnimationPropertyUpdater(float toOpacity) {
+ super(toOpacity);
+ }
+
+ public OpacityAnimationPropertyUpdater(float fromOpacity, float toOpacity) {
+ super(fromOpacity, toOpacity);
+ }
+
+ @Override
+ protected float getProperty(View view) {
+ return view.getAlpha();
+ }
+
+ @Override
+ protected void setProperty(View view, float propertyValue) {
+ view.setAlpha(propertyValue);
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/animation/PositionAnimationPairPropertyUpdater.java b/android/ReactAndroid/src/main/java/com/facebook/react/animation/PositionAnimationPairPropertyUpdater.java
new file mode 100644
index 00000000000000..b90740c5172c25
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/animation/PositionAnimationPairPropertyUpdater.java
@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.animation;
+
+import android.view.View;
+
+/**
+ * Subclass of {@link AnimationPropertyUpdater} for animating center position of a view
+ */
+public class PositionAnimationPairPropertyUpdater extends AbstractFloatPairPropertyUpdater {
+
+ public PositionAnimationPairPropertyUpdater(float toFirst, float toSecond) {
+ super(toFirst, toSecond);
+ }
+
+ public PositionAnimationPairPropertyUpdater(
+ float fromFirst,
+ float fromSecond,
+ float toFirst,
+ float toSecond) {
+ super(fromFirst, fromSecond, toFirst, toSecond);
+ }
+
+ @Override
+ protected void getProperty(View view, float[] returnValues) {
+ returnValues[0] = view.getX() + 0.5f * view.getWidth();
+ returnValues[1] = view.getY() + 0.5f * view.getHeight();
+ }
+
+ @Override
+ protected void setProperty(View view, float[] propertyValues) {
+ view.setX(propertyValues[0] - 0.5f * view.getWidth());
+ view.setY(propertyValues[1] - 0.5f * view.getHeight());
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/animation/RotationAnimationPropertyUpdater.java b/android/ReactAndroid/src/main/java/com/facebook/react/animation/RotationAnimationPropertyUpdater.java
new file mode 100644
index 00000000000000..214c84f6671e11
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/animation/RotationAnimationPropertyUpdater.java
@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.animation;
+
+import android.view.View;
+
+/**
+ * Subclass of {@link AnimationPropertyUpdater} for animating view's rotation
+ */
+public class RotationAnimationPropertyUpdater extends AbstractSingleFloatProperyUpdater {
+
+ public RotationAnimationPropertyUpdater(float toValue) {
+ super(toValue);
+ }
+
+ @Override
+ protected float getProperty(View view) {
+ return view.getRotation();
+ }
+
+ @Override
+ protected void setProperty(View view, float propertyValue) {
+ view.setRotation((float) Math.toDegrees(propertyValue));
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/animation/ScaleXAnimationPropertyUpdater.java b/android/ReactAndroid/src/main/java/com/facebook/react/animation/ScaleXAnimationPropertyUpdater.java
new file mode 100644
index 00000000000000..9eb5567557a048
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/animation/ScaleXAnimationPropertyUpdater.java
@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.animation;
+
+import android.view.View;
+
+/**
+ * Subclass of {@link AnimationPropertyUpdater} for animating view's X scale
+ */
+public class ScaleXAnimationPropertyUpdater extends AbstractSingleFloatProperyUpdater {
+
+ public ScaleXAnimationPropertyUpdater(float toValue) {
+ super(toValue);
+ }
+
+ public ScaleXAnimationPropertyUpdater(float fromValue, float toValue) {
+ super(fromValue, toValue);
+ }
+
+ @Override
+ protected float getProperty(View view) {
+ return view.getScaleX();
+ }
+
+ @Override
+ protected void setProperty(View view, float propertyValue) {
+ view.setScaleX(propertyValue);
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/animation/ScaleXYAnimationPairPropertyUpdater.java b/android/ReactAndroid/src/main/java/com/facebook/react/animation/ScaleXYAnimationPairPropertyUpdater.java
new file mode 100644
index 00000000000000..3ca9429d01928b
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/animation/ScaleXYAnimationPairPropertyUpdater.java
@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.animation;
+
+import android.view.View;
+
+/**
+ * Subclass of {@link AnimationPropertyUpdater} for animating view's X and Y scale
+ */
+public class ScaleXYAnimationPairPropertyUpdater extends AbstractFloatPairPropertyUpdater {
+
+ public ScaleXYAnimationPairPropertyUpdater(float toFirst, float toSecond) {
+ super(toFirst, toSecond);
+ }
+
+ public ScaleXYAnimationPairPropertyUpdater(
+ float fromFirst,
+ float fromSecond,
+ float toFirst,
+ float toSecond) {
+ super(fromFirst, fromSecond, toFirst, toSecond);
+ }
+
+ @Override
+ protected void getProperty(View view, float[] returnValues) {
+ returnValues[0] = view.getScaleX();
+ returnValues[1] = view.getScaleY();
+ }
+
+ @Override
+ protected void setProperty(View view, float[] propertyValues) {
+ view.setScaleX(propertyValues[0]);
+ view.setScaleY(propertyValues[1]);
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/animation/ScaleYAnimationPropertyUpdater.java b/android/ReactAndroid/src/main/java/com/facebook/react/animation/ScaleYAnimationPropertyUpdater.java
new file mode 100644
index 00000000000000..25b02f2d0d9b09
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/animation/ScaleYAnimationPropertyUpdater.java
@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.animation;
+
+import android.view.View;
+
+/**
+ * Subclass of {@link AnimationPropertyUpdater} for animating view's Y scale
+ */
+public class ScaleYAnimationPropertyUpdater extends AbstractSingleFloatProperyUpdater {
+
+ public ScaleYAnimationPropertyUpdater(float toValue) {
+ super(toValue);
+ }
+
+ public ScaleYAnimationPropertyUpdater(float fromValue, float toValue) {
+ super(fromValue, toValue);
+ }
+
+ @Override
+ protected float getProperty(View view) {
+ return view.getScaleY();
+ }
+
+ @Override
+ protected void setProperty(View view, float propertyValue) {
+ view.setScaleY(propertyValue);
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/bridge/ActivityEventListener.java b/android/ReactAndroid/src/main/java/com/facebook/react/bridge/ActivityEventListener.java
new file mode 100644
index 00000000000000..888a66a0ee74e5
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/bridge/ActivityEventListener.java
@@ -0,0 +1,21 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+package com.facebook.react.bridge;
+
+import android.content.Intent;
+
+/**
+ * Listener for receiving activity events.
+ */
+public interface ActivityEventListener {
+
+ /**
+ * Called when host (activity/service) receives an {@link Activity#onActivityResult} call.
+ */
+ void onActivityResult(int requestCode, int resultCode, Intent data);
+
+ /**
+ * Called when a new intent is passed to the activity
+ */
+ void onNewIntent(Intent intent);
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/bridge/Arguments.java b/android/ReactAndroid/src/main/java/com/facebook/react/bridge/Arguments.java
new file mode 100644
index 00000000000000..866104fb1963d6
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/bridge/Arguments.java
@@ -0,0 +1,189 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.bridge;
+
+import javax.annotation.Nullable;
+
+import android.os.Bundle;
+
+public class Arguments {
+
+ /**
+ * This method should be used when you need to stub out creating NativeArrays in unit tests.
+ */
+ public static WritableArray createArray() {
+ return new WritableNativeArray();
+ }
+
+ /**
+ * This method should be used when you need to stub out creating NativeMaps in unit tests.
+ */
+ public static WritableMap createMap() {
+ return new WritableNativeMap();
+ }
+
+ public static WritableNativeArray fromJavaArgs(Object[] args) {
+ WritableNativeArray arguments = new WritableNativeArray();
+ for (int i = 0; i < args.length; i++) {
+ Object argument = args[i];
+ if (argument == null) {
+ arguments.pushNull();
+ continue;
+ }
+
+ Class argumentClass = argument.getClass();
+ if (argumentClass == Boolean.class) {
+ arguments.pushBoolean(((Boolean) argument).booleanValue());
+ } else if (argumentClass == Integer.class) {
+ arguments.pushDouble(((Integer) argument).doubleValue());
+ } else if (argumentClass == Double.class) {
+ arguments.pushDouble(((Double) argument).doubleValue());
+ } else if (argumentClass == Float.class) {
+ arguments.pushDouble(((Float) argument).doubleValue());
+ } else if (argumentClass == String.class) {
+ arguments.pushString(argument.toString());
+ } else if (argumentClass == WritableNativeMap.class) {
+ arguments.pushMap((WritableNativeMap) argument);
+ } else if (argumentClass == WritableNativeArray.class) {
+ arguments.pushArray((WritableNativeArray) argument);
+ } else {
+ throw new RuntimeException("Cannot convert argument of type " + argumentClass);
+ }
+ }
+ return arguments;
+ }
+
+ /**
+ * Convert an array to a {@link WritableArray}.
+ *
+ * @param array the array to convert. Supported types are: {@code String[]}, {@code Bundle[]},
+ * {@code int[]}, {@code float[]}, {@code double[]}, {@code boolean[]}.
+ *
+ * @return the converted {@link WritableArray}
+ * @throws IllegalArgumentException if the passed object is none of the above types
+ */
+ public static WritableArray fromArray(Object array) {
+ WritableArray catalystArray = createArray();
+ if (array instanceof String[]) {
+ for (String v: (String[]) array) {
+ catalystArray.pushString(v);
+ }
+ } else if (array instanceof Bundle[]) {
+ for (Bundle v: (Bundle[]) array) {
+ catalystArray.pushMap(fromBundle(v));
+ }
+ } else if (array instanceof int[]) {
+ for (int v: (int[]) array) {
+ catalystArray.pushInt(v);
+ }
+ } else if (array instanceof float[]) {
+ for (float v: (float[]) array) {
+ catalystArray.pushDouble(v);
+ }
+ } else if (array instanceof double[]) {
+ for (double v: (double[]) array) {
+ catalystArray.pushDouble(v);
+ }
+ } else if (array instanceof boolean[]) {
+ for (boolean v: (boolean[]) array) {
+ catalystArray.pushBoolean(v);
+ }
+ } else {
+ throw new IllegalArgumentException("Unknown array type " + array.getClass());
+ }
+ return catalystArray;
+ }
+
+ /**
+ * Convert a {@link Bundle} to a {@link WritableMap}. Supported key types in the bundle
+ * are:
+ *
+ *
+ * - primitive types: int, float, double, boolean
+ * - arrays supported by {@link #fromArray(Object)}
+ * - {@link Bundle} objects that are recursively converted to maps
+ *
+ *
+ * @param bundle the {@link Bundle} to convert
+ * @return the converted {@link WritableMap}
+ * @throws IllegalArgumentException if there are keys of unsupported types
+ */
+ public static WritableMap fromBundle(Bundle bundle) {
+ WritableMap map = createMap();
+ for (String key: bundle.keySet()) {
+ Object value = bundle.get(key);
+ if (value == null) {
+ map.putNull(key);
+ } else if (value.getClass().isArray()) {
+ map.putArray(key, fromArray(value));
+ } else if (value instanceof String) {
+ map.putString(key, (String) value);
+ } else if (value instanceof Number) {
+ if (value instanceof Integer) {
+ map.putInt(key, (Integer) value);
+ } else {
+ map.putDouble(key, ((Number) value).doubleValue());
+ }
+ } else if (value instanceof Boolean) {
+ map.putBoolean(key, (Boolean) value);
+ } else if (value instanceof Bundle) {
+ map.putMap(key, fromBundle((Bundle) value));
+ } else {
+ throw new IllegalArgumentException("Could not convert " + value.getClass());
+ }
+ }
+ return map;
+ }
+
+ /**
+ * Convert a {@link WritableMap} to a {@link Bundle}.
+ * @param readableMap the {@link WritableMap} to convert.
+ * @return the converted {@link Bundle}.
+ */
+ @Nullable
+ public static Bundle toBundle(@Nullable ReadableMap readableMap) {
+ if (readableMap == null) {
+ return null;
+ }
+
+ ReadableMapKeySetIterator iterator = readableMap.keySetIterator();
+
+ Bundle bundle = new Bundle();
+ while (iterator.hasNextKey()) {
+ String key = iterator.nextKey();
+ ReadableType readableType = readableMap.getType(key);
+ switch (readableType) {
+ case Null:
+ bundle.putString(key, null);
+ break;
+ case Boolean:
+ bundle.putBoolean(key, readableMap.getBoolean(key));
+ break;
+ case Number:
+ // Can be int or double.
+ bundle.putDouble(key, readableMap.getDouble(key));
+ break;
+ case String:
+ bundle.putString(key, readableMap.getString(key));
+ break;
+ case Map:
+ bundle.putBundle(key, toBundle(readableMap.getMap(key)));
+ break;
+ case Array:
+ // TODO t8873322
+ throw new UnsupportedOperationException("Arrays aren't supported yet.");
+ default:
+ throw new IllegalArgumentException("Could not convert object with key: " + key + ".");
+ }
+ }
+
+ return bundle;
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/bridge/AssertionException.java b/android/ReactAndroid/src/main/java/com/facebook/react/bridge/AssertionException.java
new file mode 100644
index 00000000000000..fa574cc3e93aa3
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/bridge/AssertionException.java
@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.bridge;
+
+/**
+ * Like {@link AssertionError} but extends RuntimeException so that it may be caught by a
+ * {@link NativeModuleCallExceptionHandler}. See that class for more details. Used in
+ * conjunction with {@link SoftAssertions}.
+ */
+public class AssertionException extends RuntimeException {
+
+ public AssertionException(String detailMessage) {
+ super(detailMessage);
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/bridge/BUCK b/android/ReactAndroid/src/main/java/com/facebook/react/bridge/BUCK
new file mode 100644
index 00000000000000..6164c32a8bc8a0
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/bridge/BUCK
@@ -0,0 +1,42 @@
+include_defs('//ReactAndroid/DEFS')
+
+# We package the JS files from the bundler and local directory into what we
+# pretend is an ordinary JAR file. By putting them under the assets/ directory
+# within the zip file and relying on Buck to merge its contents into the APK,
+# our JS bundles arrive in a place accessible by the AssetManager at runtime.
+
+python_binary(
+ name = 'package_js',
+ main = 'package_js.py',
+ visibility = [
+ 'PUBLIC',
+ ],
+)
+
+android_library(
+ name = 'bridge',
+ srcs = glob(['**/*.java']),
+ exported_deps = [
+ react_native_dep('java/com/facebook/jni:jni'),
+ react_native_dep('java/com/facebook/proguard/annotations:annotations'),
+ ],
+ deps = [
+ react_native_dep('java/com/facebook/systrace:systrace'),
+ react_native_dep('libraries/fbcore/src/main/java/com/facebook/common/logging:logging'),
+ react_native_dep('libraries/soloader/java/com/facebook/soloader:soloader'),
+ react_native_dep('third-party/java/infer-annotations:infer-annotations'),
+ react_native_dep('third-party/java/jackson:core'),
+ react_native_dep('third-party/java/jsr-305:jsr-305'),
+ react_native_dep('third-party/java/okhttp:okhttp3'),
+ react_native_dep('third-party/java/okhttp:okhttp3-ws'),
+ react_native_dep('third-party/java/okio:okio'),
+ react_native_target('java/com/facebook/react/common:common'),
+ ],
+ visibility = [
+ 'PUBLIC',
+ ],
+)
+
+project_config(
+ src_target = ':bridge',
+)
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/bridge/BaseActivityEventListener.java b/android/ReactAndroid/src/main/java/com/facebook/react/bridge/BaseActivityEventListener.java
new file mode 100644
index 00000000000000..6a5740ea3f606c
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/bridge/BaseActivityEventListener.java
@@ -0,0 +1,17 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+
+package com.facebook.react.bridge;
+
+import android.content.Intent;
+
+/**
+ * An empty implementation of {@link ActivityEventListener}
+ */
+public class BaseActivityEventListener implements ActivityEventListener {
+
+ @Override
+ public void onActivityResult(int requestCode, int resultCode, Intent data) { }
+
+ @Override
+ public void onNewIntent(Intent intent) { }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/bridge/BaseJavaModule.java b/android/ReactAndroid/src/main/java/com/facebook/react/bridge/BaseJavaModule.java
new file mode 100644
index 00000000000000..7da66012a7ccd9
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/bridge/BaseJavaModule.java
@@ -0,0 +1,551 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.bridge;
+
+import com.facebook.infer.annotation.Assertions;
+import com.facebook.systrace.Systrace;
+import com.facebook.systrace.SystraceMessage;
+
+import javax.annotation.Nullable;
+
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.Map;
+
+import static com.facebook.infer.annotation.Assertions.assertNotNull;
+import static com.facebook.systrace.Systrace.TRACE_TAG_REACT_JAVA_BRIDGE;
+
+/**
+ * Base class for Catalyst native modules whose implementations are written in Java. Default
+ * implementations for {@link #initialize} and {@link #onCatalystInstanceDestroy} are provided for
+ * convenience. Subclasses which override these don't need to call {@code super} in case of
+ * overriding those methods as implementation of those methods is empty.
+ *
+ * BaseJavaModules can be linked to Fragments' lifecycle events, {@link CatalystInstance} creation
+ * and destruction, by being called on the appropriate method when a life cycle event occurs.
+ *
+ * Native methods can be exposed to JS with {@link ReactMethod} annotation. Those methods may
+ * only use limited number of types for their arguments:
+ * 1/ primitives (boolean, int, float, double
+ * 2/ {@link String} mapped from JS string
+ * 3/ {@link ReadableArray} mapped from JS Array
+ * 4/ {@link ReadableMap} mapped from JS Object
+ * 5/ {@link Callback} mapped from js function and can be used only as a last parameter or in the
+ * case when it express success & error callback pair as two last arguments respecively.
+ *
+ * All methods exposed as native to JS with {@link ReactMethod} annotation must return
+ * {@code void}.
+ *
+ * Please note that it is not allowed to have multiple methods annotated with {@link ReactMethod}
+ * with the same name.
+ */
+public abstract class BaseJavaModule implements NativeModule {
+ // taken from Libraries/Utilities/MessageQueue.js
+ static final public String METHOD_TYPE_REMOTE = "remote";
+ static final public String METHOD_TYPE_REMOTE_ASYNC = "remoteAsync";
+ static final public String METHOD_TYPE_SYNC_HOOK = "syncHook";
+
+ private static abstract class ArgumentExtractor {
+ public int getJSArgumentsNeeded() {
+ return 1;
+ }
+
+ public abstract @Nullable T extractArgument(
+ CatalystInstance catalystInstance, ExecutorToken executorToken, ReadableNativeArray jsArguments, int atIndex);
+ }
+
+ static final private ArgumentExtractor ARGUMENT_EXTRACTOR_BOOLEAN =
+ new ArgumentExtractor() {
+ @Override
+ public Boolean extractArgument(
+ CatalystInstance catalystInstance, ExecutorToken executorToken, ReadableNativeArray jsArguments, int atIndex) {
+ return jsArguments.getBoolean(atIndex);
+ }
+ };
+
+ static final private ArgumentExtractor ARGUMENT_EXTRACTOR_DOUBLE =
+ new ArgumentExtractor() {
+ @Override
+ public Double extractArgument(
+ CatalystInstance catalystInstance, ExecutorToken executorToken, ReadableNativeArray jsArguments, int atIndex) {
+ return jsArguments.getDouble(atIndex);
+ }
+ };
+
+ static final private ArgumentExtractor ARGUMENT_EXTRACTOR_FLOAT =
+ new ArgumentExtractor() {
+ @Override
+ public Float extractArgument(
+ CatalystInstance catalystInstance, ExecutorToken executorToken, ReadableNativeArray jsArguments, int atIndex) {
+ return (float) jsArguments.getDouble(atIndex);
+ }
+ };
+
+ static final private ArgumentExtractor ARGUMENT_EXTRACTOR_INTEGER =
+ new ArgumentExtractor() {
+ @Override
+ public Integer extractArgument(
+ CatalystInstance catalystInstance, ExecutorToken executorToken, ReadableNativeArray jsArguments, int atIndex) {
+ return (int) jsArguments.getDouble(atIndex);
+ }
+ };
+
+ static final private ArgumentExtractor ARGUMENT_EXTRACTOR_STRING =
+ new ArgumentExtractor() {
+ @Override
+ public String extractArgument(
+ CatalystInstance catalystInstance, ExecutorToken executorToken, ReadableNativeArray jsArguments, int atIndex) {
+ return jsArguments.getString(atIndex);
+ }
+ };
+
+ static final private ArgumentExtractor ARGUMENT_EXTRACTOR_ARRAY =
+ new ArgumentExtractor() {
+ @Override
+ public ReadableNativeArray extractArgument(
+ CatalystInstance catalystInstance, ExecutorToken executorToken, ReadableNativeArray jsArguments, int atIndex) {
+ return jsArguments.getArray(atIndex);
+ }
+ };
+
+ static final private ArgumentExtractor ARGUMENT_EXTRACTOR_MAP =
+ new ArgumentExtractor() {
+ @Override
+ public ReadableMap extractArgument(
+ CatalystInstance catalystInstance, ExecutorToken executorToken, ReadableNativeArray jsArguments, int atIndex) {
+ return jsArguments.getMap(atIndex);
+ }
+ };
+
+ static final private ArgumentExtractor ARGUMENT_EXTRACTOR_CALLBACK =
+ new ArgumentExtractor() {
+ @Override
+ public @Nullable Callback extractArgument(
+ CatalystInstance catalystInstance, ExecutorToken executorToken, ReadableNativeArray jsArguments, int atIndex) {
+ if (jsArguments.isNull(atIndex)) {
+ return null;
+ } else {
+ int id = (int) jsArguments.getDouble(atIndex);
+ return new CallbackImpl(catalystInstance, executorToken, id);
+ }
+ }
+ };
+
+ static final private ArgumentExtractor ARGUMENT_EXTRACTOR_PROMISE =
+ new ArgumentExtractor() {
+ @Override
+ public int getJSArgumentsNeeded() {
+ return 2;
+ }
+
+ @Override
+ public Promise extractArgument(
+ CatalystInstance catalystInstance, ExecutorToken executorToken, ReadableNativeArray jsArguments, int atIndex) {
+ Callback resolve = ARGUMENT_EXTRACTOR_CALLBACK
+ .extractArgument(catalystInstance, executorToken, jsArguments, atIndex);
+ Callback reject = ARGUMENT_EXTRACTOR_CALLBACK
+ .extractArgument(catalystInstance, executorToken, jsArguments, atIndex + 1);
+ return new PromiseImpl(resolve, reject);
+ }
+ };
+
+ public class JavaMethod implements NativeMethod {
+
+ private Method mMethod;
+ private final ArgumentExtractor[] mArgumentExtractors;
+ private final String mSignature;
+ private final Object[] mArguments;
+ private String mType = METHOD_TYPE_REMOTE;
+ private final int mJSArgumentsNeeded;
+ private final String mTraceName;
+
+ public JavaMethod(Method method) {
+ mMethod = method;
+ Class[] parameterTypes = method.getParameterTypes();
+ mArgumentExtractors = buildArgumentExtractors(parameterTypes);
+ mSignature = buildSignature(parameterTypes);
+ // Since native methods are invoked from a message queue executed on a single thread, it is
+ // save to allocate only one arguments object per method that can be reused across calls
+ mArguments = new Object[parameterTypes.length];
+ mJSArgumentsNeeded = calculateJSArgumentsNeeded();
+ mTraceName = BaseJavaModule.this.getName() + "." + mMethod.getName();
+ }
+
+ public Method getMethod() {
+ return mMethod;
+ }
+
+ public String getSignature() {
+ return mSignature;
+ }
+
+ private String buildSignature(Class[] paramTypes) {
+ StringBuilder builder = new StringBuilder(paramTypes.length);
+ builder.append("v.");
+ for (int i = 0; i < paramTypes.length; i++) {
+ Class paramClass = paramTypes[i];
+ if (paramClass == ExecutorToken.class) {
+ if (!BaseJavaModule.this.supportsWebWorkers()) {
+ throw new RuntimeException(
+ "Module " + BaseJavaModule.this + " doesn't support web workers, but " +
+ mMethod.getName() +
+ " takes an ExecutorToken.");
+ }
+ } else if (paramClass == Promise.class) {
+ Assertions.assertCondition(
+ i == paramTypes.length - 1, "Promise must be used as last parameter only");
+ mType = METHOD_TYPE_REMOTE_ASYNC;
+ }
+ builder.append(paramTypeToChar(paramClass));
+ }
+
+ // Modules that support web workers are expected to take an ExecutorToken as the first
+ // parameter to all their @ReactMethod-annotated methods.
+ if (BaseJavaModule.this.supportsWebWorkers()) {
+ if (builder.charAt(2) != 'T') {
+ throw new RuntimeException(
+ "Module " + BaseJavaModule.this + " supports web workers, but " + mMethod.getName() +
+ "does not take an ExecutorToken as its first parameter.");
+ }
+ }
+
+ return builder.toString();
+ }
+
+ private ArgumentExtractor[] buildArgumentExtractors(Class[] paramTypes) {
+ // Modules that support web workers are expected to take an ExecutorToken as the first
+ // parameter to all their @ReactMethod-annotated methods. We compensate for that here.
+ int executorTokenOffset = 0;
+ if (BaseJavaModule.this.supportsWebWorkers()) {
+ if (paramTypes[0] != ExecutorToken.class) {
+ throw new RuntimeException(
+ "Module " + BaseJavaModule.this + " supports web workers, but " + mMethod.getName() +
+ "does not take an ExecutorToken as its first parameter.");
+ }
+ executorTokenOffset = 1;
+ }
+
+ ArgumentExtractor[] argumentExtractors = new ArgumentExtractor[paramTypes.length - executorTokenOffset];
+ for (int i = 0; i < paramTypes.length - executorTokenOffset; i += argumentExtractors[i].getJSArgumentsNeeded()) {
+ int paramIndex = i + executorTokenOffset;
+ Class argumentClass = paramTypes[paramIndex];
+ if (argumentClass == Boolean.class || argumentClass == boolean.class) {
+ argumentExtractors[i] = ARGUMENT_EXTRACTOR_BOOLEAN;
+ } else if (argumentClass == Integer.class || argumentClass == int.class) {
+ argumentExtractors[i] = ARGUMENT_EXTRACTOR_INTEGER;
+ } else if (argumentClass == Double.class || argumentClass == double.class) {
+ argumentExtractors[i] = ARGUMENT_EXTRACTOR_DOUBLE;
+ } else if (argumentClass == Float.class || argumentClass == float.class) {
+ argumentExtractors[i] = ARGUMENT_EXTRACTOR_FLOAT;
+ } else if (argumentClass == String.class) {
+ argumentExtractors[i] = ARGUMENT_EXTRACTOR_STRING;
+ } else if (argumentClass == Callback.class) {
+ argumentExtractors[i] = ARGUMENT_EXTRACTOR_CALLBACK;
+ } else if (argumentClass == Promise.class) {
+ argumentExtractors[i] = ARGUMENT_EXTRACTOR_PROMISE;
+ Assertions.assertCondition(
+ paramIndex == paramTypes.length - 1, "Promise must be used as last parameter only");
+ mType = METHOD_TYPE_REMOTE_ASYNC;
+ } else if (argumentClass == ReadableMap.class) {
+ argumentExtractors[i] = ARGUMENT_EXTRACTOR_MAP;
+ } else if (argumentClass == ReadableArray.class) {
+ argumentExtractors[i] = ARGUMENT_EXTRACTOR_ARRAY;
+ } else {
+ throw new RuntimeException(
+ "Got unknown argument class: " + argumentClass.getSimpleName());
+ }
+ }
+ return argumentExtractors;
+ }
+
+ private int calculateJSArgumentsNeeded() {
+ int n = 0;
+ for (ArgumentExtractor extractor : mArgumentExtractors) {
+ n += extractor.getJSArgumentsNeeded();
+ }
+ return n;
+ }
+
+ private String getAffectedRange(int startIndex, int jsArgumentsNeeded) {
+ return jsArgumentsNeeded > 1 ?
+ "" + startIndex + "-" + (startIndex + jsArgumentsNeeded - 1) : "" + startIndex;
+ }
+
+ @Override
+ public void invoke(CatalystInstance catalystInstance, ExecutorToken executorToken, ReadableNativeArray parameters) {
+ SystraceMessage.beginSection(TRACE_TAG_REACT_JAVA_BRIDGE, "callJavaModuleMethod")
+ .arg("method", mTraceName)
+ .flush();
+ try {
+ if (mJSArgumentsNeeded != parameters.size()) {
+ throw new NativeArgumentsParseException(
+ BaseJavaModule.this.getName() + "." + mMethod.getName() + " got " +
+ parameters.size() + " arguments, expected " + mJSArgumentsNeeded);
+ }
+
+ // Modules that support web workers are expected to take an ExecutorToken as the first
+ // parameter to all their @ReactMethod-annotated methods. We compensate for that here.
+ int i = 0, jsArgumentsConsumed = 0;
+ int executorTokenOffset = 0;
+ if (BaseJavaModule.this.supportsWebWorkers()) {
+ mArguments[0] = executorToken;
+ executorTokenOffset = 1;
+ }
+ try {
+ for (; i < mArgumentExtractors.length; i++) {
+ mArguments[i + executorTokenOffset] = mArgumentExtractors[i].extractArgument(
+ catalystInstance, executorToken, parameters, jsArgumentsConsumed);
+ jsArgumentsConsumed += mArgumentExtractors[i].getJSArgumentsNeeded();
+ }
+ } catch (UnexpectedNativeTypeException e) {
+ throw new NativeArgumentsParseException(
+ e.getMessage() + " (constructing arguments for " + BaseJavaModule.this.getName() +
+ "." + mMethod.getName() + " at argument index " +
+ getAffectedRange(jsArgumentsConsumed, mArgumentExtractors[i].getJSArgumentsNeeded()) +
+ ")",
+ e);
+ }
+
+ try {
+ mMethod.invoke(BaseJavaModule.this, mArguments);
+ } catch (IllegalArgumentException ie) {
+ throw new RuntimeException(
+ "Could not invoke " + BaseJavaModule.this.getName() + "." + mMethod.getName(), ie);
+ } catch (IllegalAccessException iae) {
+ throw new RuntimeException(
+ "Could not invoke " + BaseJavaModule.this.getName() + "." + mMethod.getName(), iae);
+ } catch (InvocationTargetException ite) {
+ // Exceptions thrown from native module calls end up wrapped in InvocationTargetException
+ // which just make traces harder to read and bump out useful information
+ if (ite.getCause() instanceof RuntimeException) {
+ throw (RuntimeException) ite.getCause();
+ }
+ throw new RuntimeException(
+ "Could not invoke " + BaseJavaModule.this.getName() + "." + mMethod.getName(), ite);
+ }
+ } finally {
+ Systrace.endSection(TRACE_TAG_REACT_JAVA_BRIDGE);
+ }
+ }
+
+ /**
+ * Determines how the method is exported in JavaScript:
+ * METHOD_TYPE_REMOTE for regular methods
+ * METHOD_TYPE_REMOTE_ASYNC for methods that return a promise object to the caller.
+ */
+ @Override
+ public String getType() {
+ return mType;
+ }
+ }
+
+ public class SyncJavaHook implements SyncNativeHook {
+
+ private Method mMethod;
+ private final String mSignature;
+
+ public SyncJavaHook(Method method) {
+ mMethod = method;
+ mSignature = buildSignature(method);
+ }
+
+ public Method getMethod() {
+ return mMethod;
+ }
+
+ public String getSignature() {
+ return mSignature;
+ }
+
+ private String buildSignature(Method method) {
+ Class[] paramTypes = method.getParameterTypes();
+ StringBuilder builder = new StringBuilder(paramTypes.length + 2);
+
+ builder.append(returnTypeToChar(method.getReturnType()));
+ builder.append('.');
+
+ for (int i = 0; i < paramTypes.length; i++) {
+ Class paramClass = paramTypes[i];
+ if (paramClass == ExecutorToken.class) {
+ if (!BaseJavaModule.this.supportsWebWorkers()) {
+ throw new RuntimeException(
+ "Module " + BaseJavaModule.this + " doesn't support web workers, but " +
+ mMethod.getName() +
+ " takes an ExecutorToken.");
+ }
+ } else if (paramClass == Promise.class) {
+ Assertions.assertCondition(
+ i == paramTypes.length - 1, "Promise must be used as last parameter only");
+ }
+ builder.append(paramTypeToChar(paramClass));
+ }
+
+ return builder.toString();
+ }
+ }
+
+ private @Nullable Map mMethods;
+ private @Nullable Map mHooks;
+
+ private void findMethods() {
+ if (mMethods == null) {
+ Systrace.beginSection(TRACE_TAG_REACT_JAVA_BRIDGE, "findMethods");
+ mMethods = new HashMap<>();
+ mHooks = new HashMap<>();
+
+ Method[] targetMethods = getClass().getDeclaredMethods();
+ for (Method targetMethod : targetMethods) {
+ if (targetMethod.getAnnotation(ReactMethod.class) != null) {
+ String methodName = targetMethod.getName();
+ if (mHooks.containsKey(methodName) || mMethods.containsKey(methodName)) {
+ // We do not support method overloading since js sees a function as an object regardless
+ // of number of params.
+ throw new IllegalArgumentException(
+ "Java Module " + getName() + " sync method name already registered: " + methodName);
+ }
+ mMethods.put(methodName, new JavaMethod(targetMethod));
+ }
+ if (targetMethod.getAnnotation(ReactSyncHook.class) != null) {
+ String methodName = targetMethod.getName();
+ if (mHooks.containsKey(methodName) || mMethods.containsKey(methodName)) {
+ // We do not support method overloading since js sees a function as an object regardless
+ // of number of params.
+ throw new IllegalArgumentException(
+ "Java Module " + getName() + " sync method name already registered: " + methodName);
+ }
+ mHooks.put(methodName, new SyncJavaHook(targetMethod));
+ }
+ }
+ Systrace.endSection(TRACE_TAG_REACT_JAVA_BRIDGE);
+ }
+ }
+
+ @Override
+ public final Map getMethods() {
+ findMethods();
+ return assertNotNull(mMethods);
+ }
+
+ /**
+ * @return a map of constants this module exports to JS. Supports JSON types.
+ */
+ public @Nullable Map getConstants() {
+ return null;
+ }
+
+ public final Map getSyncHooks() {
+ findMethods();
+ return assertNotNull(mHooks);
+ }
+
+ @Override
+ public final void writeConstantsField(JsonWriter writer, String fieldName) throws IOException {
+ Map constants = getConstants();
+ if (constants == null || constants.isEmpty()) {
+ return;
+ }
+
+ writer.name(fieldName).beginObject();
+ for (Map.Entry constant : constants.entrySet()) {
+ writer.name(constant.getKey());
+ JsonWriterHelper.value(writer, constant.getValue());
+ }
+ writer.endObject();
+ }
+
+ @Override
+ public void initialize() {
+ // do nothing
+ }
+
+ @Override
+ public boolean canOverrideExistingModule() {
+ return false;
+ }
+
+ @Override
+ public void onReactBridgeInitialized(ReactBridge bridge) {
+ // do nothing
+ }
+
+ @Override
+ public void onCatalystInstanceDestroy() {
+ // do nothing
+ }
+
+ @Override
+ public boolean supportsWebWorkers() {
+ return false;
+ }
+
+ private static char paramTypeToChar(Class paramClass) {
+ char tryCommon = commonTypeToChar(paramClass);
+ if (tryCommon != '\0') {
+ return tryCommon;
+ }
+ if (paramClass == ExecutorToken.class) {
+ return 'T';
+ } else if (paramClass == Callback.class) {
+ return 'X';
+ } else if (paramClass == Promise.class) {
+ return 'P';
+ } else if (paramClass == ReadableMap.class) {
+ return 'M';
+ } else if (paramClass == ReadableArray.class) {
+ return 'A';
+ } else {
+ throw new RuntimeException(
+ "Got unknown param class: " + paramClass.getSimpleName());
+ }
+ }
+
+ private static char returnTypeToChar(Class returnClass) {
+ char tryCommon = commonTypeToChar(returnClass);
+ if (tryCommon != '\0') {
+ return tryCommon;
+ }
+ if (returnClass == void.class) {
+ return 'v';
+ } else if (returnClass == WritableMap.class) {
+ return 'M';
+ } else if (returnClass == WritableArray.class) {
+ return 'A';
+ } else {
+ throw new RuntimeException(
+ "Got unknown return class: " + returnClass.getSimpleName());
+ }
+ }
+
+ private static char commonTypeToChar(Class typeClass) {
+ if (typeClass == boolean.class) {
+ return 'z';
+ } else if (typeClass == Boolean.class) {
+ return 'Z';
+ } else if (typeClass == int.class) {
+ return 'i';
+ } else if (typeClass == Integer.class) {
+ return 'I';
+ } else if (typeClass == double.class) {
+ return 'd';
+ } else if (typeClass == Double.class) {
+ return 'D';
+ } else if (typeClass == float.class) {
+ return 'f';
+ } else if (typeClass == Float.class) {
+ return 'F';
+ } else if (typeClass == String.class) {
+ return 'S';
+ } else {
+ return '\0';
+ }
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/bridge/Callback.java b/android/ReactAndroid/src/main/java/com/facebook/react/bridge/Callback.java
new file mode 100644
index 00000000000000..ab72c46ba27565
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/bridge/Callback.java
@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.bridge;
+
+/**
+ * Interface that represent javascript callback function which can be passed to the native module
+ * as a method parameter.
+ */
+public interface Callback {
+
+ /**
+ * Schedule javascript function execution represented by this {@link Callback} instance
+ *
+ * @param args arguments passed to javascript callback method via bridge
+ */
+ public void invoke(Object... args);
+
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/bridge/CallbackImpl.java b/android/ReactAndroid/src/main/java/com/facebook/react/bridge/CallbackImpl.java
new file mode 100644
index 00000000000000..a7bc858026eece
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/bridge/CallbackImpl.java
@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.bridge;
+
+/**
+ * Implementation of javascript callback function that use Bridge to schedule method execution
+ */
+public final class CallbackImpl implements Callback {
+
+ private final CatalystInstance mCatalystInstance;
+ private final ExecutorToken mExecutorToken;
+ private final int mCallbackId;
+
+ public CallbackImpl(CatalystInstance bridge, ExecutorToken executorToken, int callbackId) {
+ mCatalystInstance = bridge;
+ mExecutorToken = executorToken;
+ mCallbackId = callbackId;
+ }
+
+ @Override
+ public void invoke(Object... args) {
+ mCatalystInstance.invokeCallback(mExecutorToken, mCallbackId, Arguments.fromJavaArgs(args));
+ }
+}
diff --git a/android/ReactAndroid/src/main/java/com/facebook/react/bridge/CatalystInstance.java b/android/ReactAndroid/src/main/java/com/facebook/react/bridge/CatalystInstance.java
new file mode 100644
index 00000000000000..46235d2230b209
--- /dev/null
+++ b/android/ReactAndroid/src/main/java/com/facebook/react/bridge/CatalystInstance.java
@@ -0,0 +1,78 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.react.bridge;
+
+import java.util.Collection;
+
+import com.facebook.react.bridge.queue.ReactQueueConfiguration;
+import com.facebook.react.common.annotations.VisibleForTesting;
+import com.facebook.proguard.annotations.DoNotStrip;
+
+/**
+ * A higher level API on top of the asynchronous JSC bridge. This provides an
+ * environment allowing the invocation of JavaScript methods and lets a set of
+ * Java APIs be invokable from JavaScript as well.
+ */
+@DoNotStrip
+public interface CatalystInstance extends MemoryPressureListener {
+ void runJSBundle();
+ // This is called from java code, so it won't be stripped anyway, but proguard will rename it,
+ // which this prevents.
+ @DoNotStrip
+ void invokeCallback(ExecutorToken executorToken, final int callbackID, final NativeArray arguments);
+ @DoNotStrip
+ void callFunction(
+ ExecutorToken executorToken,
+ String module,
+ String method,
+ NativeArray arguments);
+ /**
+ * Destroys this catalyst instance, waiting for any other threads in ReactQueueConfiguration
+ * (besides the UI thread) to finish running. Must be called from the UI thread so that we can
+ * fully shut down other threads.
+ */
+ void destroy();
+ boolean isDestroyed();
+
+ /**
+ * Initialize all the native modules
+ */
+ @VisibleForTesting
+ void initialize();
+
+ ReactQueueConfiguration getReactQueueConfiguration();
+
+ T getJSModule(Class