Wait for render android (#3517)

This commit introduces an option to control the way components are pushed into the stack.
When pushing components into a stack, they are pushed the moment they are measured.
If `waitForRender` is true, components will be pushed only after the initial render.

api:

```js
options: {
  animations: {
    push: {
      waitForRender: true
    },
    showModal: {
      waitForRender: true
    }
  }
}
```

lib/android/app/src/main/java/com/reactnativenavigation/NavigationActivity.java

 import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.viewcontrollers.ChildControllersRegistry;
 import com.reactnativenavigation.viewcontrollers.Navigator;
+import com.reactnativenavigation.viewcontrollers.modal.ModalStack;
 
 public class NavigationActivity extends AppCompatActivity implements DefaultHardwareBackBtnHandler, PermissionAwareActivity, JsDevReloadHandler.ReloadListener {
     @Nullable
     @Override
     protected void onCreate(@Nullable Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
-        navigator = new Navigator(this, new ChildControllersRegistry(), new OverlayManager());
+        navigator = new Navigator(this, new ChildControllersRegistry(), new ModalStack(this), new OverlayManager());
         getReactGateway().onActivityCreated(this);
         navigator.getView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN);
         setContentView(navigator.getView());

lib/android/app/src/main/java/com/reactnativenavigation/parse/AnimationOptions.java

         AnimationOptions options = new AnimationOptions();
         if (json == null) return options;
 
-        options.hasValue = true;
         for (Iterator<String> it = json.keys(); it.hasNext(); ) {
             String key = it.next();
             switch (key) {
                 case "enable":
                     options.enable = BoolParser.parse(json, key);
                     break;
+                case "waitForRender":
+                    options.waitForRender = BoolParser.parse(json, key);
+                    break;
                 default:
                     options.valueOptions.add(ValueAnimationOptions.parse(json.optJSONObject(key), getAnimProp(key)));
             }
         return options;
     }
 
-    private boolean hasValue = false;
-
     public Text id = new NullText();
     public Bool enable = new NullBool();
+    public Bool waitForRender = new NullBool();
     private HashSet<ValueAnimationOptions> valueOptions = new HashSet<>();
 
     void mergeWith(AnimationOptions other) {
-        if (other.hasValue()) {
-            hasValue = true;
-            id = other.id;
-            valueOptions = other.valueOptions;
-        }
+        if (other.id.hasValue()) id = other.id;
+        if (other.enable.hasValue()) enable = other.enable;
+        if (other.waitForRender.hasValue()) waitForRender = other.waitForRender;
+        if (!other.valueOptions.isEmpty()) valueOptions = other.valueOptions;
     }
 
     void mergeWithDefault(AnimationOptions defaultOptions) {
-        if (defaultOptions.hasValue()) {
-            hasValue = true;
-            id = defaultOptions.id;
-            valueOptions = defaultOptions.valueOptions;
-        }
+        if (!id.hasValue()) id = defaultOptions.id;
+        if (!enable.hasValue()) enable = defaultOptions.enable;
+        if (!waitForRender.hasValue()) waitForRender = defaultOptions.waitForRender;
+        if (valueOptions.isEmpty()) valueOptions = defaultOptions.valueOptions;
     }
 
     public boolean hasValue() {
-        return hasValue;
+        return id.hasValue() || enable.hasValue() || waitForRender.hasValue();
     }
 
     public AnimatorSet getAnimation(View view) {
     }
 
     public AnimatorSet getAnimation(View view, AnimatorSet defaultAnimation) {
-        if (!hasValue()) return defaultAnimation;
+        if (!hasAnimation()) return defaultAnimation;
         AnimatorSet animationSet = new AnimatorSet();
         List<Animator> animators = new ArrayList<>();
         for (ValueAnimationOptions options : valueOptions) {
         }
         throw new IllegalArgumentException("This animation is not supported: " + key);
     }
+
+    public boolean hasAnimation() {
+        return !valueOptions.isEmpty();
+    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/parse/NestedAnimationsOptions.java

         options.bottomTabs = AnimationOptions.parse(json.optJSONObject("bottomTabs"));
         options.topBar = AnimationOptions.parse(json.optJSONObject("topBar"));
         options.enable = BoolParser.parse(json, "enable");
+        options.waitForRender = BoolParser.parse(json, "waitForRender");
 
         return options;
     }
 
     public Bool enable = new NullBool();
+    public Bool waitForRender = new NullBool();
     public AnimationOptions content = new AnimationOptions();
     public AnimationOptions bottomTabs = new AnimationOptions();
     public AnimationOptions topBar = new AnimationOptions();
         content.mergeWith(other.content);
         bottomTabs.mergeWith(other.bottomTabs);
         if (other.enable.hasValue()) enable = other.enable;
+        if (other.waitForRender.hasValue()) waitForRender = other.waitForRender;
     }
 
     void mergeWithDefault(NestedAnimationsOptions defaultOptions) {
         bottomTabs.mergeWithDefault(defaultOptions.bottomTabs);
         topBar.mergeWithDefault(defaultOptions.topBar);
         if (!enable.hasValue()) enable = defaultOptions.enable;
+        if (!waitForRender.hasValue()) waitForRender = defaultOptions.waitForRender;
     }
 
     public boolean hasValue() {
-        return topBar.hasValue() || content.hasValue() || bottomTabs.hasValue();
+        return topBar.hasValue() || content.hasValue() || bottomTabs.hasValue() || waitForRender.hasValue();
     }
 }

lib/android/app/src/main/java/com/reactnativenavigation/presentation/StackOptionsPresenter.java

         this.defaultOptions = defaultOptions;
     }
 
+    public Options getDefaultOptions() {
+        return defaultOptions;
+    }
+
     public void bindView(TopBar topBar) {
         this.topBar = topBar;
     }

lib/android/app/src/main/java/com/reactnativenavigation/react/ReactView.java

         jsTouchDispatcher.handleTouchEvent(event, getEventDispatcher());
     }
 
+    @Override
+    public boolean isRendered() {
+        return getChildCount() >= 1;
+    }
+
     public EventDispatcher getEventDispatcher() {
         ReactContext reactContext = reactInstanceManager.getCurrentReactContext();
         return reactContext == null ? null : reactContext.getNativeModule(UIManagerModule.class).getEventDispatcher();

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/IReactView.java

     ScrollEventListener getScrollEventListener();
 
     void dispatchTouchEventToJs(MotionEvent event);
+
+    boolean isRendered();
 }

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/Navigator.java

 import android.view.ViewGroup;
 import android.widget.FrameLayout;
 
-import com.reactnativenavigation.anim.ModalAnimator;
 import com.reactnativenavigation.anim.NavigationAnimator;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.presentation.OptionsPresenter;
 import com.reactnativenavigation.utils.CommandListener;
 import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.utils.CompatUtils;
-import com.reactnativenavigation.viewcontrollers.modal.ModalPresenter;
 import com.reactnativenavigation.viewcontrollers.modal.ModalStack;
 import com.reactnativenavigation.viewcontrollers.stack.StackController;
 
     @Override
     public void setDefaultOptions(Options defaultOptions) {
         this.defaultOptions = defaultOptions;
-        if (root != null) root.setDefaultOptions(defaultOptions);
+        if (root != null) {
+            root.setDefaultOptions(defaultOptions);
+            modalStack.setDefaultOptions(defaultOptions);
+        }
     }
 
     public Options getDefaultOptions() {
         return defaultOptions;
     }
 
-    public Navigator(final Activity activity, ChildControllersRegistry childRegistry, OverlayManager overlayManager) {
+    public Navigator(final Activity activity, ChildControllersRegistry childRegistry, ModalStack modalStack, OverlayManager overlayManager) {
         super(activity, childRegistry,"navigator" + CompatUtils.generateViewId(), new OptionsPresenter(activity, new Options()), new Options());
-        modalStack = new ModalStack(new ModalPresenter(new ModalAnimator(activity)));
+        this.modalStack = modalStack;
         this.overlayManager = overlayManager;
     }
 
         destroyRoot();
         root = viewController;
         contentLayout.addView(viewController.getView());
-        if (viewController.options.animations.startApp.hasValue()) {
+        if (viewController.options.animations.startApp.hasAnimation()) {
             new NavigationAnimator(viewController.getActivity(), viewController.options.animations)
                     .animateStartApp(viewController.getView(), new AnimatorListenerAdapter() {
                         @Override

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/ParentController.java

 import android.view.ViewGroup;
 
 import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.parse.params.Bool;
 import com.reactnativenavigation.presentation.OptionsPresenter;
 import com.reactnativenavigation.utils.CollectionUtils;
 import com.reactnativenavigation.views.Component;
 		super(activity, childRegistry, id, presenter, initialOptions);
 	}
 
-	@Override
+    @Override
+    public void setWaitForRender(Bool waitForRender) {
+        super.setWaitForRender(waitForRender);
+        applyOnController(getCurrentChild(), controller -> ((ViewController) controller).setWaitForRender(waitForRender));
+    }
+
+    @Override
     public void setDefaultOptions(Options defaultOptions) {
         Collection<? extends ViewController> children = getChildControllers();
         if (!CollectionUtils.isNullOrEmpty(children)) {
     @CheckResult
     public Options resolveCurrentOptions() {
 	    if (CollectionUtils.isNullOrEmpty(getChildControllers())) return options;
-        Options o = getCurrentChild().resolveCurrentOptions();
-        return o.copy().mergeWith(options);
+        return getCurrentChild()
+                .resolveCurrentOptions()
+                .copy()
+                .mergeWith(options);
+    }
+
+    @Override
+    @CheckResult
+    public Options resolveCurrentOptions(Options defaultOptions) {
+        return resolveCurrentOptions().withDefaultOptions(defaultOptions);
     }
 
     protected abstract ViewController getCurrentChild();
     public void clearTopTabs() {
 
     }
+
+    @Override
+    public boolean isRendered() {
+        return getCurrentChild() != null && getCurrentChild().isRendered();
+    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/ViewController.java

 import android.view.ViewTreeObserver;
 
 import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.parse.params.Bool;
+import com.reactnativenavigation.parse.params.NullBool;
 import com.reactnativenavigation.presentation.FabOptionsPresenter;
 import com.reactnativenavigation.utils.CommandListener;
 import com.reactnativenavigation.utils.StringUtils;
 public abstract class ViewController<T extends ViewGroup> implements ViewTreeObserver.OnGlobalLayoutListener {
 
     private Runnable onAppearedListener;
+    private Bool waitForRender = new NullBool();
 
     public interface ViewVisibilityListener {
         /**
         options = initialOptions.copy();
     }
 
+    public void setWaitForRender(Bool waitForRender) {
+        this.waitForRender = waitForRender;
+    }
+
     public void setOnAppearedListener(Runnable onAppearedListener) {
         this.onAppearedListener = onAppearedListener;
     }
         return options;
     }
 
+    @CheckResult
+    public Options resolveCurrentOptions(Options defaultOptions) {
+        return options.copy().withDefaultOptions(defaultOptions);
+    }
+
     @CallSuper
     public void mergeOptions(Options options) {
         this.options = this.options.mergeWith(options);
     public abstract void sendOnNavigationButtonPressed(String buttonId);
 
     protected boolean isViewShown() {
-        return !isDestroyed && getView().isShown();
+        return !isDestroyed &&
+               getView().isShown() &&
+               view != null &&
+               isRendered();
+    }
+
+    public boolean isRendered() {
+        return view != null && (
+                waitForRender.isFalseOrUndefined() ||
+                !(view instanceof Component) ||
+                ((Component) view).isRendered()
+        );
+    }
+
+    void applyOnController(ViewController controller, Task<ViewController> task) {
+        if (controller != null) task.run(controller);
     }
 }

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/modal/ModalPresenter.java

 
 import com.reactnativenavigation.anim.ModalAnimator;
 import com.reactnativenavigation.parse.ModalPresentationStyle;
+import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.utils.CommandListener;
 import com.reactnativenavigation.viewcontrollers.ViewController;
 
 
     private ViewGroup content;
     private ModalAnimator animator;
+    private Options defaultOptions = new Options();
 
-    public ModalPresenter(ModalAnimator animator) {
+    ModalPresenter(ModalAnimator animator) {
         this.animator = animator;
     }
 
         this.content = contentLayout;
     }
 
+    public void setDefaultOptions(Options defaultOptions) {
+        this.defaultOptions = defaultOptions;
+    }
+
     public void showModal(ViewController toAdd, ViewController toRemove, CommandListener listener) {
+        Options options = toAdd.resolveCurrentOptions(defaultOptions);
+        toAdd.setWaitForRender(options.animations.showModal.waitForRender);
         content.addView(toAdd.getView());
-        if (toAdd.options.animations.showModal.enable.isTrueOrUndefined()) {
-            animator.show(toAdd.getView(), toAdd.options.animations.showModal, new AnimatorListenerAdapter() {
-                @Override
-                public void onAnimationEnd(Animator animation) {
-                    onShowModalEnd(toAdd, toRemove, listener);
-                }
-            });
+        if (options.animations.showModal.enable.isTrueOrUndefined()) {
+            if (options.animations.showModal.waitForRender.isTrue()) {
+                toAdd.setOnAppearedListener(() -> animateShow(toAdd, toRemove, listener, options));
+            } else {
+                animateShow(toAdd, toRemove, listener, options);
+            }
         } else {
             onShowModalEnd(toAdd, toRemove, listener);
         }
     }
 
+    private void animateShow(ViewController toAdd, ViewController toRemove, CommandListener listener, Options options) {
+        animator.show(toAdd.getView(), options.animations.showModal, new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                onShowModalEnd(toAdd, toRemove, listener);
+            }
+        });
+    }
+
     private void onShowModalEnd(ViewController toAdd, ViewController toRemove, CommandListener listener) {
         if (toAdd.options.modal.presentationStyle != ModalPresentationStyle.OverCurrentContext) {
             toRemove.detachView();

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/modal/ModalStack.java

 package com.reactnativenavigation.viewcontrollers.modal;
 
+import android.app.Activity;
+import android.support.annotation.RestrictTo;
 import android.view.ViewGroup;
 
+import com.reactnativenavigation.anim.ModalAnimator;
+import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.utils.CommandListener;
 import com.reactnativenavigation.viewcontrollers.ViewController;
 
     private List<ViewController> modals = new ArrayList<>();
     private final ModalPresenter presenter;
 
-    public ModalStack(ModalPresenter presenter) {
+    public ModalStack(Activity activity) {
+        this.presenter = new ModalPresenter(new ModalAnimator(activity));
+    }
+
+    @RestrictTo(RestrictTo.Scope.TESTS)
+    ModalStack(ModalPresenter presenter) {
         this.presenter = presenter;
     }
 
         presenter.setContentLayout(contentLayout);
     }
 
+    public void setDefaultOptions(Options defaultOptions) {
+        presenter.setDefaultOptions(defaultOptions);
+    }
+
     public void showModal(ViewController viewController, ViewController root, CommandListener listener) {
         ViewController toRemove = isEmpty() ? root : peek();
         modals.add(viewController);

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/stack/StackController.java

 import android.support.annotation.RestrictTo;
 import android.support.annotation.VisibleForTesting;
 import android.support.v4.view.ViewPager;
+import android.view.View;
 import android.view.ViewGroup;
 import android.widget.RelativeLayout;
 
         child.setParentController(this);
         stack.push(child.getId(), child);
         backButtonHelper.addToPushedChild(this, child);
-        ViewGroup childView = child.getView();
-        childView.setLayoutParams(new RelativeLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT));
-        presenter.applyLayoutParamsOptions(resolveCurrentOptions(), childView);
-        getView().addView(childView);
+        Options resolvedOptions = resolveCurrentOptions(presenter.getDefaultOptions());
+        addChildToStack(child, child.getView(), resolvedOptions);
 
         if (toRemove != null) {
             if (child.options.animations.push.enable.isTrueOrUndefined()) {
-                animator.push(child.getView(), () -> {
-                    getView().removeView(toRemove.getView());
-                    listener.onSuccess(child.getId());
-                });
+                if (resolvedOptions.animations.push.waitForRender.isTrue()) {
+                    child.setOnAppearedListener(() -> animator.push(child.getView(), () -> {
+                        getView().removeView(toRemove.getView());
+                        listener.onSuccess(child.getId());
+                    }));
+                } else {
+                    animator.push(child.getView(), () -> {
+                        getView().removeView(toRemove.getView());
+                        listener.onSuccess(child.getId());
+                    });
+                }
             } else {
                 getView().removeView(toRemove.getView());
                 listener.onSuccess(child.getId());
         }
     }
 
+    private void addChildToStack(ViewController child, View view, Options resolvedOptions) {
+        view.setLayoutParams(new RelativeLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT));
+        child.setWaitForRender(resolvedOptions.animations.push.waitForRender);
+        presenter.applyLayoutParamsOptions(resolvedOptions, view);
+        getView().addView(view);
+    }
+
     public void setRoot(ViewController child, CommandListener listener) {
         backButtonHelper.clear(child);
         push(child, new CommandListenerAdapter() {

lib/android/app/src/main/java/com/reactnativenavigation/views/Component.java

     void drawBehindTopBar();
 
     void drawBelowTopBar(TopBar topBar);
+
+    boolean isRendered();
 }

lib/android/app/src/main/java/com/reactnativenavigation/views/ComponentLayout.java

         }
     }
 
+    @Override
+    public boolean isRendered() {
+        return reactView.isRendered();
+    }
+
     @Override
     public void onPress(String buttonId) {
         reactView.sendOnNavigationButtonPressed(buttonId);

lib/android/app/src/main/java/com/reactnativenavigation/views/ExternalComponentLayout.java

             setLayoutParams(layoutParams);
         }
     }
+
+    @Override
+    public boolean isRendered() {
+        return getChildCount() >= 1;
+    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/views/StackLayout.java

 import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import com.reactnativenavigation.views.titlebar.TitleBarReactViewCreator;
+import com.reactnativenavigation.views.topbar.TopBar;
 
 import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
 import static android.view.ViewGroup.LayoutParams.WRAP_CONTENT;
 
 @SuppressLint("ViewConstructor")
-public class StackLayout extends RelativeLayout {
+public class StackLayout extends RelativeLayout implements Component {
     private String stackId;
 
     public StackLayout(Context context, ReactViewCreator topBarButtonCreator, TitleBarReactViewCreator titleBarReactViewCreator, TopBarBackgroundViewController topBarBackgroundViewController, TopBarController topBarController, TopBarButtonController.OnClickListener topBarButtonClickListener, String stackId) {
     public String getStackId() {
         return stackId;
     }
+
+    @Override
+    public void drawBehindTopBar() {
+
+    }
+
+    @Override
+    public void drawBelowTopBar(TopBar topBar) {
+
+    }
+
+    @Override
+    public boolean isRendered() {
+        return getChildCount() >= 2 &&
+               getChildAt(1) instanceof Component &&
+               ((Component) getChildAt(1)).isRendered();
+    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/views/toptabs/TopTabsViewPager.java

         setLayoutParams(layoutParams);
     }
 
+    @Override
+    public boolean isRendered() {
+        return tabs.size() != 0 && areAllTabsRendered();
+    }
+
+    private boolean areAllTabsRendered() {
+        for (ViewController tab : tabs) {
+            if (!tab.isRendered()) return false;
+        }
+        return true;
+    }
+
     public void switchToTab(int index) {
         setCurrentItem(index);
     }

lib/android/app/src/test/java/com/reactnativenavigation/mocks/SimpleOverlay.java

     public void dispatchTouchEventToJs(MotionEvent event) {
 
     }
+
+    @Override
+    public boolean isRendered() {
+        return getChildCount() >= 1;
+    }
 }

lib/android/app/src/test/java/com/reactnativenavigation/mocks/SimpleViewController.java

             }
         }
 
+        @Override
+        public boolean isRendered() {
+            return getChildCount() >= 1;
+        }
+
         @Override
         public boolean isReady() {
             return false;

lib/android/app/src/test/java/com/reactnativenavigation/mocks/TestReactView.java

     public void dispatchTouchEventToJs(MotionEvent event) {
 
     }
+
+    @Override
+    public boolean isRendered() {
+        return getChildCount() >= 1;
+    }
 }

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/NavigatorTest.java

 import com.reactnativenavigation.utils.ImageLoader;
 import com.reactnativenavigation.utils.OptionHelper;
 import com.reactnativenavigation.viewcontrollers.bottomtabs.BottomTabsController;
+import com.reactnativenavigation.viewcontrollers.modal.ModalStack;
 import com.reactnativenavigation.viewcontrollers.stack.StackController;
 
 import org.junit.Test;
     private OverlayManager overlayManager;
     private EventEmitter eventEmitter;
     private ViewController.ViewVisibilityListener parentVisibilityListener;
+    private ModalStack modalStack;
 
     @Override
     public void beforeEach() {
         imageLoaderMock = ImageLoaderMock.mock();
         activityController = newActivityController(TestActivity.class);
         activity = activityController.create().get();
-        uut = new Navigator(activity, childRegistry, overlayManager);
+        modalStack = spy(new ModalStack(activity));
+        uut = new Navigator(activity, childRegistry, modalStack, overlayManager);
         activity.setNavigator(uut);
 
         parentController = newStack();
         Options defaultOptions = new Options();
         uut.setDefaultOptions(defaultOptions);
         verify(spy, times(1)).setDefaultOptions(defaultOptions);
+        verify(modalStack).setDefaultOptions(defaultOptions);
     }
 
     @Test
     @Test
     public void hasUniqueId() {
         assertThat(uut.getId()).startsWith("navigator");
-        assertThat(new Navigator(activity, childRegistry, overlayManager).getId()).isNotEqualTo(uut.getId());
+        assertThat(new Navigator(activity, childRegistry, modalStack, overlayManager).getId()).isNotEqualTo(uut.getId());
     }
 
     @Test
 
     @Test
     public void dismissModal_onViewAppearedInvokedOnRoot() {
-        disableShowModalAnimation(child1, child2);
+        disableShowModalAnimation(child1, child2, child3);
         disableDismissModalAnimation(child1, child2);
 
         uut.setRoot(parentController, new CommandListenerAdapter());
+        parentController.push(child3, new CommandListenerAdapter());
         uut.showModal(child1, new CommandListenerAdapter());
         uut.showModal(child2, new CommandListenerAdapter());
 
 
     @Test
     public void dismissAllModals_onViewAppearedInvokedOnRoot() {
+        disablePushAnimation(child2);
         disableShowModalAnimation(child1);
 
         uut.dismissAllModals(new CommandListenerAdapter());
         verify(parentVisibilityListener, times(0)).onViewAppeared(parentController.getView());
 
         uut.setRoot(parentController, new CommandListenerAdapter());
+        parentController.push(child2, new CommandListenerAdapter());
 
         verify(parentVisibilityListener, times(1)).onViewAppeared(parentController.getView());
         uut.showModal(child1, new CommandListenerAdapter());
 
     @Test
     public void handleBack_onViewAppearedInvokedOnRoot() {
-        disableShowModalAnimation(child1, child2);
+        disableShowModalAnimation(child1, child2, child3);
 
+        parentController.push(child3, new CommandListenerAdapter());
         StackController spy = spy(parentController);
         uut.setRoot(spy, new CommandListenerAdapter());
         uut.showModal(child1, new CommandListenerAdapter());
 
     @Test
     public void destroy_destroyedRoot() {
+        disablePushAnimation(child1);
+
         StackController spy = spy(parentController);
         spy.options.animations.startApp.enable = new Bool(false);
         uut.setRoot(spy, new CommandListenerAdapter());
+        spy.push(child1, new CommandListenerAdapter());
         activityController.destroy();
         verify(spy, times(1)).destroy();
     }

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/ParentControllerTest.java

 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 
 public class ParentControllerTest extends BaseTest {
 
         uut.applyChildOptions(options, child1.getView());
         verify(presenter, times(0)).applyRootOptions(uut.getView(), options);
     }
+
+    @Test
+    public void resolveCurrentOptions_returnOptionsIfNoChildren() {
+        assertThat(uut.getChildControllers().size()).isZero();
+        assertThat(uut.resolveCurrentOptions()).isEqualTo(uut.options);
+    }
+
+    @Test
+    public void resolveCurrentOptions_mergesWithCurrentChild() {
+        ViewController child1 = Mockito.mock(ViewController.class);
+        when(child1.getView()).thenReturn(new FrameLayout(activity));
+        Options copiedChildOptions = spy(new Options());
+        Options childOptions = spy(new Options() {
+            @Override
+            public Options copy() {
+                return copiedChildOptions;
+            }
+        });
+        when(child1.resolveCurrentOptions()).thenReturn(childOptions);
+
+        children.add(child1);
+
+        uut.ensureViewIsCreated();
+        assertThat(uut.getCurrentChild()).isEqualTo(child1);
+        uut.resolveCurrentOptions();
+        verify(child1).resolveCurrentOptions();
+        verify(copiedChildOptions).mergeWith(uut.options);
+    }
+
+    @Test
+    public void resolveCurrentOptions_withDefaultOptions() {
+        SimpleViewController child1 = new SimpleViewController(activity, childRegistry, "child1", new Options());
+        children.add(child1);
+        uut.ensureViewIsCreated();
+
+        Options defaultOptions = new Options();
+        Options currentOptions = spy(new Options());
+        ParentController spy = spy(uut);
+        Mockito.when(spy.resolveCurrentOptions()).thenReturn(currentOptions);
+        spy.resolveCurrentOptions(defaultOptions);
+        verify(currentOptions).withDefaultOptions(defaultOptions);
+    }
 }

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/ViewControllerTest.java

 
 import android.app.Activity;
 import android.view.View;
+import android.view.ViewGroup;
 import android.view.ViewParent;
 import android.widget.FrameLayout;
 import android.widget.LinearLayout;
 import com.reactnativenavigation.TestUtils;
 import com.reactnativenavigation.mocks.SimpleViewController;
 import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.parse.params.Bool;
+import com.reactnativenavigation.parse.params.NullBool;
 import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.viewcontrollers.stack.StackController;
+import com.reactnativenavigation.views.Component;
 
 import org.assertj.android.api.Assertions;
 import org.junit.Test;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.withSettings;
 
 public class ViewControllerTest extends BaseTest {
 
         spy.ensureViewIsCreated();
         verify(spy, times(1)).getView();
     }
+
+    @Test
+    public void isRendered_falseIfViewIsNotCreated() {
+        uut.setWaitForRender(new Bool(true));
+        assertThat(uut.isRendered()).isFalse();
+    }
+
+    @Test
+    public void isRendered_delegatesToView() {
+        uut.setWaitForRender(new Bool(true));
+        uut.view = Mockito.mock(ViewGroup.class, withSettings().extraInterfaces(Component.class));
+        uut.isRendered();
+        verify((Component) uut.view).isRendered();
+    }
+
+    @Test
+    public void isRendered_returnsTrueForEveryViewByDefault() {
+        uut.setWaitForRender(new NullBool());
+        uut.view = Mockito.mock(ViewGroup.class);
+        assertThat(uut.isRendered()).isTrue();
+    }
 }
 

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/modal/ModalPresenterTest.java

 import com.reactnativenavigation.BaseTest;
 import com.reactnativenavigation.anim.ModalAnimator;
 import com.reactnativenavigation.mocks.SimpleViewController;
+import com.reactnativenavigation.parse.AnimationOptions;
 import com.reactnativenavigation.parse.ModalPresentationStyle;
 import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.parse.params.Bool;
 import com.reactnativenavigation.utils.CommandListener;
 import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.viewcontrollers.ChildController;
 import com.reactnativenavigation.viewcontrollers.ChildControllersRegistry;
 import com.reactnativenavigation.viewcontrollers.ViewController;
 
+import org.json.JSONException;
+import org.json.JSONObject;
 import org.junit.Test;
 
 import static org.assertj.core.api.Java6Assertions.assertThat;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyZeroInteractions;
 
 public class ModalPresenterTest extends BaseTest {
     private static final String MODAL_ID_1 = "modalId1";
     private ModalPresenter uut;
     private FrameLayout contentLayout;
     private ModalAnimator animator;
-    private ViewController rootController;
+    private ViewController root;
 
     @Override
     public void beforeEach() {
         Activity activity = newActivity();
         ChildControllersRegistry childRegistry = new ChildControllersRegistry();
 
-        rootController = spy(new SimpleViewController(activity, childRegistry, "root", new Options()));
+        root = spy(new SimpleViewController(activity, childRegistry, "root", new Options()));
         contentLayout = new FrameLayout(activity);
-        contentLayout.addView(rootController.getView());
+        contentLayout.addView(root.getView());
         activity.setContentView(contentLayout);
 
         animator = spy(new ModalAnimator(activity));
         modal2 = spy(new SimpleViewController(activity, childRegistry, MODAL_ID_2, new Options()));
     }
 
+    @Test
+    public void showModal() {
+        Options defaultOptions = new Options();
+        uut.setDefaultOptions(defaultOptions);
+        disableShowModalAnimation(modal1);
+        uut.showModal(modal1, root, new CommandListenerAdapter());
+        verify(modal1).setWaitForRender(any());
+        verify(modal1).resolveCurrentOptions(defaultOptions);
+    }
+
     @Test
     public void showModal_noAnimation() {
         disableShowModalAnimation(modal1);
                 verify(modal1, times(1)).onViewAppeared();
             }
         });
-        uut.showModal(modal1, rootController, listener);
+        uut.showModal(modal1, root, listener);
         verify(animator, times(0)).show(
                 eq(modal1.getView()),
                 eq(modal1.options.animations.showModal),
         verify(listener, times(1)).onSuccess(MODAL_ID_1);
     }
 
+    @Test
+    public void showModal_resolvesDefaultOptions() throws JSONException {
+        Options defaultOptions = new Options();
+        JSONObject disabledShowModalAnimation = new JSONObject().put("enable", false);
+        defaultOptions.animations.showModal = AnimationOptions.parse(disabledShowModalAnimation);
+
+        uut.setDefaultOptions(defaultOptions);
+        uut.showModal(modal1, root, new CommandListenerAdapter());
+        verifyZeroInteractions(animator);
+    }
+
     @Test
     public void showModal_previousModalIsRemovedFromHierarchy() {
         uut.showModal(modal1, null, new CommandListenerAdapter() {
         });
     }
 
+    @Test
+    public void showModal_waitForRender() {
+        modal1.options.animations.showModal.waitForRender = new Bool(true);
+        uut.showModal(modal1, root, new CommandListenerAdapter());
+        verify(modal1).setOnAppearedListener(any());
+        verifyZeroInteractions(animator);
+    }
+
     @Test
     public void dismissModal_animatesByDefault() {
         disableShowModalAnimation(modal1);
 
-        uut.showModal(modal1, rootController, new CommandListenerAdapter());
-        uut.dismissTopModal(modal1, rootController, new CommandListenerAdapter() {
+        uut.showModal(modal1, root, new CommandListenerAdapter());
+        uut.dismissTopModal(modal1, root, new CommandListenerAdapter() {
             @Override
             public void onSuccess(String childId) {
                 verify(modal1, times(1)).onViewDisappear();
         disableShowModalAnimation(modal1);
         disableDismissModalAnimation(modal1);
 
-        uut.showModal(modal1, rootController, new CommandListenerAdapter());
-        uut.dismissTopModal(modal1, rootController, new CommandListenerAdapter());
+        uut.showModal(modal1, root, new CommandListenerAdapter());
+        uut.dismissTopModal(modal1, root, new CommandListenerAdapter());
         verify(modal1, times(1)).onViewDisappear();
         verify(modal1, times(1)).destroy();
         verify(animator, times(0)).dismiss(any(), any());
     public void dismissModal_previousModalIsAddedBackToHierarchy() {
         disableShowModalAnimation(modal1, modal2);
 
-        uut.showModal(modal1, rootController, new CommandListenerAdapter());
+        uut.showModal(modal1, root, new CommandListenerAdapter());
         uut.showModal(modal2, modal1, new CommandListenerAdapter());
         assertThat(modal1.getView().getParent()).isNull();
         uut.dismissTopModal(modal2, modal1, new CommandListenerAdapter());
         disableShowModalAnimation(modal1, modal2);
         disableDismissModalAnimation(modal1, modal2);
 
-        uut.showModal(modal1, rootController, new CommandListenerAdapter());
+        uut.showModal(modal1, root, new CommandListenerAdapter());
         uut.showModal(modal2, modal1, new CommandListenerAdapter());
         assertThat(modal1.getView().getParent()).isNull();
-        assertThat(rootController.getView().getParent()).isNull();
+        assertThat(root.getView().getParent()).isNull();
 
         uut.dismissModal(modal1, new CommandListenerAdapter());
-        assertThat(rootController.getView().getParent()).isNull();
+        assertThat(root.getView().getParent()).isNull();
 
-        uut.dismissTopModal(modal2, rootController, new CommandListenerAdapter());
-        assertThat(rootController.getView().getParent()).isNotNull();
+        uut.dismissTopModal(modal2, root, new CommandListenerAdapter());
+        assertThat(root.getView().getParent()).isNotNull();
     }
 
     @Test
         modal1.options.modal.presentationStyle = ModalPresentationStyle.OverCurrentContext;
         disableShowModalAnimation(modal1, modal2);
 
-        uut.showModal(modal1, rootController, new CommandListenerAdapter());
-        assertThat(rootController.getView().getParent()).isNotNull();
-        verify(rootController, times(0)).onViewDisappear();
+        uut.showModal(modal1, root, new CommandListenerAdapter());
+        assertThat(root.getView().getParent()).isNotNull();
+        verify(root, times(0)).onViewDisappear();
     }
 }

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/modal/ModalStackTest.java

         verify(backHandlingModal, times(0)).onViewDisappear();
     }
 
+    @Test
+    public void setDefaultOptions() {
+        Options defaultOptions = new Options();
+        uut.setDefaultOptions(defaultOptions);
+        verify(presenter).setDefaultOptions(defaultOptions);
+    }
+
     private ViewController findModal(String id) {
         return uut.findControllerById(id);
     }

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/stack/StackControllerTest.java

         verify(child1, times(0)).mergeOptions(any());
     }
 
+    @Test
+    public void push_waitForRender() {
+        disablePushAnimation(child1);
+        uut.push(child1, new CommandListenerAdapter());
+
+        child2.options.animations.push.waitForRender = new Bool(true);
+        uut.push(child2, new CommandListenerAdapter());
+        verify(child2).setOnAppearedListener(any());
+        verify(animator, times(0)).push(eq(child1.getView()), any());
+    }
+
     @Test
     public void animateSetRoot() {
         disablePushAnimation(child1, child2, child3);

playground/src/app.js

         fontFamily: 'HelveticaNeue-Italic',
         fontSize: 13
       },
+      _animations: {
+        push: {
+          waitForRender: false,
+        }
+      },
       _animations: {
         startApp: {
           y: {

playground/src/screens/ModalScreen.js

         backgroundColor: 'transparent'
       },
       layout: {
-        orientation: ['portrait']
+        orientation: ['portrait'],
+        backgroundColor: '#f5fcff'
+      },
+      _animations: {
+        showModal: {
+          waitForRender: true
+        }
       }
     };
   }
 
   constructor(props) {
     super(props);
+    // this.simulateLongRunningTask();
     this.onClickShowModal = this.onClickShowModal.bind(this);
     this.onClickDismissModal = this.onClickDismissModal.bind(this);
     this.onClickDismissPreviousModal = this.onClickDismissPreviousModal.bind(this);
     this.onClickModalLifecycle = this.onClickModalLifecycle.bind(this);
   }
 
+  simulateLongRunningTask = () => {
+    // tslint:disable-next-line
+    for (let i = 0; i < Math.pow(2, 25); i++);
+  }
+
   render() {
     return (
       <View style={styles.root}>

playground/src/screens/PushedScreen.js

       },
       topBar: {
         testID: testIDs.TOP_BAR_ELEMENT
+      },
+      layout: {
+        backgroundColor: '#f5fcff'
       }
     };
   }
 
   constructor(props) {
     super(props);
+    if (this.props.simulateLongRunningTask) {
+      this.simulateLongRunningTask();
+    }
     this.onClickPush = this.onClickPush.bind(this);
     this.onClickPop = this.onClickPop.bind(this);
     this.onClickPopPrevious = this.onClickPopPrevious.bind(this);
     this.state = { disabled: false };
   }
 
+  simulateLongRunningTask() {
+    // tslint:disable-next-line
+    for (let i = 0; i < Math.pow(2, 25); i++);
+  }
+
   listeners = [];
 
   componentDidMount() {
         <Button title='Pop Previous' testID={testIDs.POP_PREVIOUS_BUTTON} onPress={this.onClickPopPrevious} />
         <Button title='Pop To Root' testID={testIDs.POP_TO_ROOT} onPress={this.onClickPopToRoot} />
         <Button title='Set Stack Root' testID={testIDs.SET_STACK_ROOT_BUTTON} onPress={this.onClickSetStackRoot} />
+        <Button title='Push and Wait for Render' testID={testIDs.PUSH_BUTTON_WAIT_FOR_RENDER} onPress={this.onClickPushWaitForRender} />
         {stackPosition > 2 && <Button title='Pop To Stack Position 1' testID={testIDs.POP_STACK_POSITION_ONE_BUTTON} onPress={this.onClickPopToFirstPosition} />}
         <Text style={styles.footer}>{`this.props.componentId = ${this.props.componentId}`}</Text>
       </View>
     });
   }
 
+  onClickPushWaitForRender = async () => {
+    await Navigation.push(this.props.componentId, {
+      component: {
+        name: 'navigation.playground.PushedScreen',
+        passProps: {
+          stackPosition: this.getStackPosition() + 1,
+          previousScreenIds: _.concat([], this.props.previousScreenIds || [], this.props.componentId),
+          simulateLongRunningTask: true
+        },
+        options: {
+          layout: {
+            backgroundColor: 'transparent'
+          },
+          topBar: {
+            title: {
+              text: `Pushed ${this.getStackPosition() + 1}`
+            }
+          },
+          animations: {
+            push: {
+              waitForRender: true
+            }
+          }
+        }
+      }
+    });
+  }
+
   getStackPosition() {
     return this.props.stackPosition || 1;
   }

playground/src/testIDs.js

   TOGGLE_TOP_BAR_HIDE_ON_SCROLL: `TOGGLE_TOP_BAR_HIDE_ON_SCROLL`,
   SET_TAB_BADGE_BUTTON: `SET_TAB_BADGE_BUTTON`,
   PUSH_TO_TEST_DID_DISAPPEAR_BUTTON: `PUSH_TO_TEST_DID_DISAPPEAR_BUTTON`,
+  PUSH_BUTTON_WAIT_FOR_RENDER: `PUSH_AND_WAIT_FOR_RENDER`,
   SHOW_LEFT_SIDE_MENU_BUTTON: `SHOW_LEFT_SIDE_MENU_BUTTON`,
   SHOW_RIGHT_SIDE_MENU_BUTTON: `SHOW_RIGHT_SIDE_MENU_BUTTON`,
   HIDE_LEFT_SIDE_MENU_BUTTON: `HIDE_LEFT_SIDE_MENU_BUTTON`,