Add waitForRender options for setRoot animation and TopBar components

When set, the ui will become visible only after the root screen and TopBar components have been rendered.

Usage
Add the following to the root layout’s options, or to its child
```
animations: {
  setRoot: {
    waitForRender: true
  }
}
```

TopBar components (Title, background, buttons) can be synced as well by adding `waitForRender: true`, for example:
```
component: {
  name: 'navigation.playground.CustomTopBar',
  alignment: 'center',
  waitForRender: true,
}
```

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

 package com.reactnativenavigation.parse;
 
+import com.reactnativenavigation.parse.params.Bool;
+import com.reactnativenavigation.parse.params.NullBool;
 import com.reactnativenavigation.parse.params.NullText;
 import com.reactnativenavigation.parse.params.Text;
+import com.reactnativenavigation.parse.parsers.BoolParser;
 import com.reactnativenavigation.parse.parsers.TextParser;
 
 import org.json.JSONObject;
         result.name = TextParser.parse(json, "name");
         result.componentId = TextParser.parse(json, "componentId");
         result.alignment = Alignment.fromString(TextParser.parse(json, "alignment").get(""));
+        result.waitForRender = BoolParser.parse(json, "waitForRender");
 
         return result;
     }
     public Text name = new NullText();
     public Text componentId = new NullText();
     public Alignment alignment = Alignment.Default;
+    public Bool waitForRender = new NullBool();
 
     void mergeWith(Component other) {
         if (other.componentId.hasValue()) componentId = other.componentId;
         if (other.name.hasValue()) name = other.name;
+        if (other.waitForRender.hasValue()) waitForRender = other.waitForRender;
         if (other.alignment != Alignment.Default) alignment = other.alignment;
     }
 
     public void mergeWithDefault(Component defaultOptions) {
         if (!componentId.hasValue()) componentId = defaultOptions.componentId;
         if (!name.hasValue()) name = defaultOptions.name;
+        if (!waitForRender.hasValue()) waitForRender = defaultOptions.waitForRender;
         if (alignment == Alignment.Default) alignment = defaultOptions.alignment;
     }
 

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

 import com.reactnativenavigation.presentation.BottomTabsPresenter;
 import com.reactnativenavigation.presentation.ComponentPresenter;
 import com.reactnativenavigation.presentation.Presenter;
+import com.reactnativenavigation.presentation.RenderChecker;
 import com.reactnativenavigation.presentation.SideMenuPresenter;
 import com.reactnativenavigation.presentation.StackPresenter;
 import com.reactnativenavigation.react.EventEmitter;
 import com.reactnativenavigation.utils.TypefaceLoader;
 import com.reactnativenavigation.viewcontrollers.ChildControllersRegistry;
 import com.reactnativenavigation.viewcontrollers.ComponentViewController;
-import com.reactnativenavigation.viewcontrollers.sidemenu.SideMenuController;
 import com.reactnativenavigation.viewcontrollers.ViewController;
 import com.reactnativenavigation.viewcontrollers.bottomtabs.BottomTabsController;
 import com.reactnativenavigation.viewcontrollers.externalcomponent.ExternalComponentCreator;
 import com.reactnativenavigation.viewcontrollers.externalcomponent.ExternalComponentViewController;
+import com.reactnativenavigation.viewcontrollers.sidemenu.SideMenuController;
 import com.reactnativenavigation.viewcontrollers.stack.StackControllerBuilder;
-import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import com.reactnativenavigation.viewcontrollers.toptabs.TopTabsController;
 import com.reactnativenavigation.views.ComponentViewCreator;
         return new StackControllerBuilder(activity)
                 .setChildren(createChildren(node.children))
                 .setChildRegistry(childRegistry)
-                .setTopBarButtonCreator(new TitleBarButtonCreator(reactInstanceManager))
-                .setTopBarBackgroundViewController(new TopBarBackgroundViewController(activity, new TopBarBackgroundViewCreator(reactInstanceManager)))
                 .setTopBarController(new TopBarController())
                 .setId(node.id)
                 .setInitialOptions(parse(typefaceManager, node.getOptions()))
-                .setStackPresenter(new StackPresenter(activity, new TitleBarReactViewCreator(reactInstanceManager), new TitleBarButtonCreator(reactInstanceManager), new ImageLoader(), defaultOptions))
+                .setStackPresenter(new StackPresenter(activity,
+                        new TitleBarReactViewCreator(reactInstanceManager),
+                        new TopBarBackgroundViewCreator(reactInstanceManager),
+                        new TitleBarButtonCreator(reactInstanceManager),
+                        new ImageLoader(),
+                        new RenderChecker(),
+                        defaultOptions
+                ))
                 .setPresenter(new Presenter(activity, defaultOptions))
                 .build();
 	}

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

 
 import android.graphics.Color;
 
+import com.reactnativenavigation.parse.params.Bool;
 import com.reactnativenavigation.parse.params.Colour;
+import com.reactnativenavigation.parse.params.NullBool;
 import com.reactnativenavigation.parse.params.NullColor;
+import com.reactnativenavigation.parse.parsers.BoolParser;
 import com.reactnativenavigation.parse.parsers.ColorParser;
 
 import org.json.JSONObject;
 
         options.color = ColorParser.parse(json, "color");
         options.component = Component.parse(json.optJSONObject("component"));
+        options.waitForRender = BoolParser.parse(json, "waitForRender");
 
         if (options.component.hasValue()) {
             options.color = new Colour(Color.TRANSPARENT);
 
     public Colour color = new NullColor();
     public Component component = new Component();
+    public Bool waitForRender = new NullBool();
 
     void mergeWith(final TopBarBackgroundOptions other) {
         if (other.color.hasValue()) color = other.color;
+        if (other.waitForRender.hasValue()) waitForRender = other.waitForRender;
         component.mergeWith(other.component);
     }
 
     void mergeWithDefault(TopBarBackgroundOptions defaultOptions) {
         if (!color.hasValue()) color = defaultOptions.color;
+        if (!waitForRender.hasValue()) waitForRender = defaultOptions.waitForRender;
         component.mergeWithDefault(defaultOptions.component);
     }
 }

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

             }
         }
     }
-
 }

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

+package com.reactnativenavigation.presentation;
+
+import com.reactnativenavigation.viewcontrollers.ViewController;
+
+import java.util.Collection;
+
+import static com.reactnativenavigation.utils.CollectionUtils.reduce;
+
+public class RenderChecker {
+    public boolean areRendered(Collection<ViewController> components) {
+        return reduce(components, true, ViewController::isRendered);
+    }
+}

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

 import android.view.View;
 import android.view.ViewGroup.LayoutParams;
 import android.view.ViewGroup.MarginLayoutParams;
+import android.widget.FrameLayout;
+import android.widget.RelativeLayout;
 
 import com.reactnativenavigation.parse.Alignment;
 import com.reactnativenavigation.parse.AnimationsOptions;
 import com.reactnativenavigation.parse.params.Colour;
 import com.reactnativenavigation.utils.ButtonPresenter;
 import com.reactnativenavigation.utils.ImageLoader;
+import com.reactnativenavigation.utils.ObjectUtils;
 import com.reactnativenavigation.utils.UiUtils;
 import com.reactnativenavigation.viewcontrollers.IReactView;
 import com.reactnativenavigation.viewcontrollers.ReactViewCreator;
 import com.reactnativenavigation.viewcontrollers.TitleBarButtonController;
 import com.reactnativenavigation.viewcontrollers.TitleBarReactViewController;
+import com.reactnativenavigation.viewcontrollers.ViewController;
 import com.reactnativenavigation.viewcontrollers.button.NavigationIconResolver;
+import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
 import com.reactnativenavigation.views.Component;
 import com.reactnativenavigation.views.titlebar.TitleBarReactViewCreator;
 import com.reactnativenavigation.views.topbar.TopBar;
+import com.reactnativenavigation.views.topbar.TopBarBackgroundViewCreator;
 
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 
+import static com.reactnativenavigation.utils.CollectionUtils.filter;
 import static com.reactnativenavigation.utils.CollectionUtils.forEach;
 import static com.reactnativenavigation.utils.CollectionUtils.keyBy;
 import static com.reactnativenavigation.utils.CollectionUtils.merge;
+import static com.reactnativenavigation.utils.ObjectUtils.perform;
 
 public class StackPresenter {
     private static final int DEFAULT_TITLE_COLOR = Color.BLACK;
     private final TitleBarReactViewCreator titleViewCreator;
     private TitleBarButtonController.OnClickListener onClickListener;
     private final ImageLoader imageLoader;
+    private final RenderChecker renderChecker;
+    private final TopBarBackgroundViewCreator topBarBackgroundViewCreator;
     private final ReactViewCreator buttonCreator;
     private Options defaultOptions;
-    private Map<Component, TitleBarReactViewController> titleComponentViewControllers = new HashMap<>();
-    private Map<Component, Map<String, TitleBarButtonController>> componentRightButtons = new HashMap<>();
-    private Map<Component, Map<String, TitleBarButtonController>> componentLeftButtons = new HashMap<>();
-
-    public StackPresenter(Activity activity, TitleBarReactViewCreator titleViewCreator, ReactViewCreator buttonCreator, ImageLoader imageLoader, Options defaultOptions) {
+    private Map<Component, TitleBarReactViewController> titleControllers = new HashMap();
+    private Map<Component, TopBarBackgroundViewController> backgroundControllers = new HashMap();
+    private Map<Component, Map<String, TitleBarButtonController>> componentRightButtons = new HashMap();
+    private Map<Component, Map<String, TitleBarButtonController>> componentLeftButtons = new HashMap();
+
+    public StackPresenter(Activity activity,
+                          TitleBarReactViewCreator titleViewCreator,
+                          TopBarBackgroundViewCreator topBarBackgroundViewCreator,
+                          ReactViewCreator buttonCreator,
+                          ImageLoader imageLoader,
+                          RenderChecker renderChecker,
+                          Options defaultOptions) {
         this.activity = activity;
         this.titleViewCreator = titleViewCreator;
+        this.topBarBackgroundViewCreator = topBarBackgroundViewCreator;
         this.buttonCreator = buttonCreator;
         this.imageLoader = imageLoader;
+        this.renderChecker = renderChecker;
         this.defaultOptions = defaultOptions;
         defaultTitleFontSize = UiUtils.dpToSp(activity, 18);
         defaultSubtitleFontSize = UiUtils.dpToSp(activity, 14);
         return defaultOptions;
     }
 
-    public List<TitleBarButtonController> getComponentButtons(Component child) {
-        return merge(getRightButtons(child), getLeftButtons(child), Collections.EMPTY_LIST);
-    }
-
-    public List<TitleBarButtonController> getComponentButtons(Component child, List<TitleBarButtonController> defaultValue) {
-        return merge(getRightButtons(child), getLeftButtons(child), defaultValue);
-    }
-
-    private List<TitleBarButtonController> getRightButtons(Component child) {
-        return componentRightButtons.containsKey(child) ? new ArrayList<>(componentRightButtons.get(child).values()) : null;
-    }
-
-    private List<TitleBarButtonController> getLeftButtons(Component child) {
-        return componentLeftButtons.containsKey(child) ? new ArrayList<>(componentLeftButtons.get(child).values()) : null;
-    }
-
     public void bindView(TopBar topBar) {
         this.topBar = topBar;
     }
 
+    public boolean isRendered(Component component) {
+        ArrayList<ViewController> controllers = new ArrayList<>(perform(componentRightButtons.get(component), new ArrayList<>(), Map::values));
+        controllers.add(backgroundControllers.get(component));
+        controllers.add(titleControllers.get(component));
+        return renderChecker.areRendered(filter(controllers, ObjectUtils::notNull));
+    }
+
     public void applyLayoutParamsOptions(Options options, View view) {
         Options withDefault = options.copy().withDefaultOptions(defaultOptions);
         if (view instanceof Component) {
     }
 
     public void onChildDestroyed(Component child) {
-        TitleBarReactViewController removed = titleComponentViewControllers.remove(child);
-        if (removed != null) {
-            removed.destroy();
-        }
+        perform(titleControllers.remove(child), TitleBarReactViewController::destroy);
+        perform(backgroundControllers.remove(child), TopBarBackgroundViewController::destroy);
         destroyButtons(componentRightButtons.get(child));
         destroyButtons(componentLeftButtons.get(child));
         componentRightButtons.remove(child);
         componentLeftButtons.remove(child);
     }
 
-    private void destroyButtons(Map<String, TitleBarButtonController> buttons) {
-        if (buttons != null) {
-            for (TitleBarButtonController button : buttons.values()) {
-                button.destroy();
-            }
-        }
+    private void destroyButtons(@Nullable Map<String, TitleBarButtonController> buttons) {
+        if (buttons != null) forEach(buttons.values(), ViewController::destroy);
     }
 
     private void applyTopBarOptions(TopBarOptions options, AnimationsOptions animationOptions, Component component, Options componentOptions) {
         topBar.setTitle(options.title.text.get(""));
 
         if (options.title.component.hasValue()) {
-            if (titleComponentViewControllers.containsKey(component)) {
-                topBar.setTitleComponent(titleComponentViewControllers.get(component).getView());
+            if (titleControllers.containsKey(component)) {
+                topBar.setTitleComponent(titleControllers.get(component).getView());
             } else {
                 TitleBarReactViewController controller = new TitleBarReactViewController(activity, titleViewCreator);
-                titleComponentViewControllers.put(component, controller);
+                controller.setWaitForRender(options.title.component.waitForRender);
+                titleControllers.put(component, controller);
                 controller.setComponent(options.title.component);
                 controller.getView().setLayoutParams(getComponentLayoutParams(options.title.component));
                 topBar.setTitleComponent(controller.getView());
         topBar.setBorderColor(options.borderColor.get(DEFAULT_BORDER_COLOR));
 
         topBar.setBackgroundColor(options.background.color.get(Color.WHITE));
-        topBar.setBackgroundComponent(options.background.component);
+
+        if (options.background.component.hasValue()) {
+            if (backgroundControllers.containsKey(component)) {
+                topBar.setBackgroundComponent(backgroundControllers.get(component).getView());
+            } else {
+                TopBarBackgroundViewController controller = new TopBarBackgroundViewController(activity, topBarBackgroundViewCreator);
+                controller.setWaitForRender(options.background.waitForRender);
+                backgroundControllers.put(component, controller);
+                controller.setComponent(options.background.component);
+                controller.getView().setLayoutParams(new RelativeLayout.LayoutParams(FrameLayout.LayoutParams.MATCH_PARENT, FrameLayout.LayoutParams.MATCH_PARENT));
+                topBar.setBackgroundComponent(controller.getView());
+            }
+        }
+
         if (options.testId.hasValue()) topBar.setTestId(options.testId.get());
         applyTopBarVisibility(options, animationOptions, componentOptions);
         if (options.drawBehind.isTrue() && !componentOptions.layout.topMargin.hasValue()) {
     }
 
     private TitleBarButtonController createButtonController(Button button) {
-        return new TitleBarButtonController(activity,
+        TitleBarButtonController controller = new TitleBarButtonController(activity,
                 new NavigationIconResolver(activity, imageLoader),
                 imageLoader,
                 new ButtonPresenter(topBar.getTitleBar(), button),
                 buttonCreator,
                 onClickListener
         );
+        controller.setWaitForRender(button.component.waitForRender);
+        return controller;
     }
 
     private void applyTopTabsOptions(TopTabsOptions options) {
         if (options.title.text.hasValue()) topBar.setTitle(options.title.text.get());
 
         if (options.title.component.hasValue()) {
-            if (titleComponentViewControllers.containsKey(component)) {
-                topBar.setTitleComponent(titleComponentViewControllers.get(component).getView());
+            if (titleControllers.containsKey(component)) {
+                topBar.setTitleComponent(titleControllers.get(component).getView());
             } else {
                 TitleBarReactViewController controller = new TitleBarReactViewController(activity, titleViewCreator);
-                titleComponentViewControllers.put(component, controller);
+                titleControllers.put(component, controller);
                 controller.setComponent(options.title.component);
                 controller.getView().setLayoutParams(getComponentLayoutParams(options.title.component));
                 topBar.setTitleComponent(controller.getView());
         if (options.subtitle.fontFamily != null) topBar.setSubtitleFontFamily(options.subtitle.fontFamily);
 
         if (options.background.color.hasValue()) topBar.setBackgroundColor(options.background.color.get());
-        if (options.background.component.hasValue()) topBar.setBackgroundComponent(options.background.component);
+
+        if (options.background.component.hasValue()) {
+            if (backgroundControllers.containsKey(component)) {
+                topBar.setBackgroundComponent(backgroundControllers.get(component).getView());
+            } else {
+                TopBarBackgroundViewController controller = new TopBarBackgroundViewController(activity, topBarBackgroundViewCreator);
+                backgroundControllers.put(component, controller);
+                controller.setComponent(options.background.component);
+                controller.getView().setLayoutParams(new RelativeLayout.LayoutParams(FrameLayout.LayoutParams.MATCH_PARENT, FrameLayout.LayoutParams.MATCH_PARENT));
+                topBar.setBackgroundComponent(controller.getView());
+            }
+        }
 
         if (options.testId.hasValue()) topBar.setTestId(options.testId.get());
 
 
     @RestrictTo(RestrictTo.Scope.TESTS)
     public Map<Component, TitleBarReactViewController> getTitleComponents() {
-        return titleComponentViewControllers;
+        return titleControllers;
+    }
+
+    @RestrictTo(RestrictTo.Scope.TESTS)
+    public Map<Component, TopBarBackgroundViewController> getBackgroundComponents() {
+        return backgroundControllers;
+    }
+
+    @RestrictTo(RestrictTo.Scope.TESTS)
+    public List<TitleBarButtonController> getComponentButtons(Component child) {
+        return merge(getRightButtons(child), getLeftButtons(child), Collections.EMPTY_LIST);
+    }
+
+    @RestrictTo(RestrictTo.Scope.TESTS)
+    public List<TitleBarButtonController> getComponentButtons(Component child, List<TitleBarButtonController> defaultValue) {
+        return merge(getRightButtons(child), getLeftButtons(child), defaultValue);
+    }
+
+    private List<TitleBarButtonController> getRightButtons(Component child) {
+        return componentRightButtons.containsKey(child) ? new ArrayList<>(componentRightButtons.get(child).values()) : null;
+    }
+
+    private List<TitleBarButtonController> getLeftButtons(Component child) {
+        return componentLeftButtons.containsKey(child) ? new ArrayList<>(componentLeftButtons.get(child).values()) : null;
     }
 }

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

 import com.facebook.react.uimanager.events.EventDispatcher;
 import com.reactnativenavigation.interfaces.ScrollEventListener;
 import com.reactnativenavigation.viewcontrollers.IReactView;
+import com.reactnativenavigation.views.Renderable;
 import com.reactnativenavigation.views.element.Element;
 
 import java.util.ArrayList;
 import java.util.List;
 
 @SuppressLint("ViewConstructor")
-public class ReactView extends ReactRootView implements IReactView {
+public class ReactView extends ReactRootView implements IReactView, Renderable {
 
 	private final ReactInstanceManager reactInstanceManager;
 	private final String componentId;

lib/android/app/src/main/java/com/reactnativenavigation/utils/CollectionUtils.java

 
     public static <T> List<T> merge(@Nullable Collection<T> a, @Nullable Collection<T> b) {
         if (a == null && b == null) return null;
-        List<T> result = new ArrayList<>(get(a));
+        List<T> result = new ArrayList(get(a));
         result.addAll(get(b));
         return result;
     }
         return items.remove(items.size() - 1);
     }
 
-    private static @NonNull <T> Collection<T> get(@Nullable Collection<T> t) {
+    public interface Reducer<S, T> {
+        S reduce(T item, S currentValue);
+    }
+
+    public static <S, T> S reduce(Collection<T> items, S initialValue, Reducer<S, T> reducer) {
+        S currentValue = initialValue;
+        for (T item : items) {
+            currentValue = reducer.reduce(item, currentValue);
+        }
+        return currentValue;
+    }
+
+    public static <T> Boolean reduce(@Nullable Collection<T> items, boolean initialValue, Functions.FuncR1<T, Boolean> reducer) {
+        boolean currentValue = initialValue;
+        if (CollectionUtils.isNullOrEmpty(items)) return currentValue;
+        for (T item : items) {
+            currentValue &= reducer.run(item);
+            if (!currentValue) return false;
+        }
+        return currentValue;
+    }
+
+    public static @NonNull <T> Collection<T> get(@Nullable Collection<T> t) {
         return t == null ? Collections.EMPTY_LIST : t;
     }
+
+    public static @NonNull <T> Collection<T> get(@Nullable Map<?, T> t) {
+        return t == null ? Collections.EMPTY_LIST : t.values();
+    }
+
 }

lib/android/app/src/main/java/com/reactnativenavigation/utils/Functions.java

     public interface Func1<T> {
         void run(T param);
     }
+
+    public interface FuncR1<T, S> {
+        S run(T param);
+    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/utils/ObjectUtils.java

 
 import android.support.annotation.Nullable;
 
+import com.reactnativenavigation.utils.Functions.Func1;
+import com.reactnativenavigation.utils.Functions.FuncR1;
+
 public class ObjectUtils {
-    public interface Action<T> {
-        void performOn(T obj);
+    public static <T> void perform(@Nullable T obj, Func1<T> action) {
+        if (obj != null) action.run(obj);
+    }
+
+    public static <T, S> S perform(@Nullable T obj, S defaultValue, FuncR1<T, S> action) {
+        return obj == null ? defaultValue : action.run(obj);
     }
 
-    public static <T> void perform(@Nullable T obj, Action<T> action) {
-        if (obj != null) action.performOn(obj);
+    public static boolean notNull(Object o) {
+        return o != null;
     }
 }

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

     @SuppressLint("MissingSuperCall")
     @Override
     public void onViewAppeared() {
-        view.sendComponentStart();
+        getView().sendComponentStart();
     }
 
     @SuppressLint("MissingSuperCall")
     @Override
     public void onViewDisappear() {
-        view.sendComponentStop();
+        getView().sendComponentStop();
+    }
+
+    @Override
+    public boolean isRendered() {
+        return !button.component.componentId.hasValue() || super.isRendered();
     }
 
     @Override

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

     public void onViewAppeared() {
         super.onViewAppeared();
         runOnPreDraw(view -> view.setLayoutParams(view.getLayoutParams()));
-        view.sendComponentStart();
+        getView().sendComponentStart();
     }
 
     @Override
     public void onViewDisappear() {
-        view.sendComponentStop();
+        getView().sendComponentStop();
         super.onViewDisappear();
     }
 

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

 import com.reactnativenavigation.utils.UiUtils;
 import com.reactnativenavigation.viewcontrollers.stack.StackController;
 import com.reactnativenavigation.views.Component;
+import com.reactnativenavigation.views.Renderable;
 import com.reactnativenavigation.views.element.Element;
 
 import java.util.Collections;
     public boolean isRendered() {
         return view != null && (
                 waitForRender.isFalseOrUndefined() ||
-                !(view instanceof Component) ||
-                ((Component) view).isRendered()
+                !(view instanceof Renderable) ||
+                ((Renderable) view).isRendered()
         );
     }
 

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

 import com.reactnativenavigation.presentation.Presenter;
 import com.reactnativenavigation.react.EventEmitter;
 import com.reactnativenavigation.utils.CommandListener;
+import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.utils.CompatUtils;
 import com.reactnativenavigation.utils.Functions.Func1;
 import com.reactnativenavigation.viewcontrollers.ChildControllersRegistry;
 
     public void setRoot(final ViewController viewController, CommandListener commandListener) {
         destroyRoot();
-        if (isRootNotCreated()) {
-            removePreviousContentView();
-            getView();
-        }
+        final boolean removeSplashView = isRootNotCreated();
+        if (isRootNotCreated()) getView();
         root = viewController;
-        rootPresenter.setRoot(root, defaultOptions, commandListener);
+        rootPresenter.setRoot(root, defaultOptions, new CommandListenerAdapter(commandListener) {
+            @Override
+            public void onSuccess(String childId) {
+                if (removeSplashView) removePreviousContentView();
+                super.onSuccess(childId);
+            }
+        });
     }
 
     private void removePreviousContentView() {

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/navigator/RootPresenter.java

     private NavigationAnimator animator;
     private FrameLayout rootLayout;
 
-    public void setRootContainer(FrameLayout rootLayout) {
+    void setRootContainer(FrameLayout rootLayout) {
         this.rootLayout = rootLayout;
     }
 
         this.animator = animator;
     }
 
-    public void setRoot(ViewController root, Options defaultOptions, CommandListener listener) {
+    void setRoot(ViewController root, Options defaultOptions, CommandListener listener) {
         rootLayout.addView(root.getView());
         Options options = root.resolveCurrentOptions(defaultOptions);
+        root.setWaitForRender(options.animations.setRoot.waitForRender);
+        if (options.animations.setRoot.waitForRender.isTrue()) {
+            root.getView().setAlpha(0);
+            root.setOnAppearedListener(() -> {
+                root.getView().setAlpha(1);
+                animateSetRootAndReportSuccess(root, listener, options);
+            });
+        } else {
+            animateSetRootAndReportSuccess(root, listener, options);
+        }
+    }
+
+    private void animateSetRootAndReportSuccess(ViewController root, CommandListener listener, Options options) {
         if (options.animations.setRoot.hasAnimation()) {
             animator.setRoot(root.getView(), options.animations.setRoot, () -> listener.onSuccess(root.getId()));
         } else {

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

 import com.reactnativenavigation.viewcontrollers.IdStack;
 import com.reactnativenavigation.viewcontrollers.ParentController;
 import com.reactnativenavigation.viewcontrollers.ViewController;
-import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import com.reactnativenavigation.views.Component;
 import com.reactnativenavigation.views.ReactComponent;
 
     private final IdStack<ViewController> stack = new IdStack<>();
     private final NavigationAnimator animator;
-    private TopBarBackgroundViewController topBarBackgroundViewController;
     private TopBarController topBarController;
     private BackButtonHelper backButtonHelper;
     private final StackPresenter presenter;
 
-    public StackController(Activity activity, List<ViewController> children, ChildControllersRegistry childRegistry, TopBarBackgroundViewController topBarBackgroundViewController, TopBarController topBarController, NavigationAnimator animator, String id, Options initialOptions, BackButtonHelper backButtonHelper, StackPresenter stackPresenter, Presenter presenter) {
+    public StackController(Activity activity, List<ViewController> children, ChildControllersRegistry childRegistry, TopBarController topBarController, NavigationAnimator animator, String id, Options initialOptions, BackButtonHelper backButtonHelper, StackPresenter stackPresenter, Presenter presenter) {
         super(activity, childRegistry, id, presenter, initialOptions);
         this.topBarController = topBarController;
-        this.topBarBackgroundViewController = topBarBackgroundViewController;
         this.animator = animator;
         this.backButtonHelper = backButtonHelper;
         this.presenter = stackPresenter;
         }
     }
 
+    @Override
+    public boolean isRendered() {
+        if (isEmpty()) return false;
+        ViewGroup currentChild = getCurrentChild().getView();
+        if (currentChild instanceof Component) {
+            return super.isRendered() && presenter.isRendered((Component) currentChild);
+        }
+        return super.isRendered();
+    }
+
     @Override
     public void setDefaultOptions(Options defaultOptions) {
         super.setDefaultOptions(defaultOptions);
         pop(mergeOptions, listener);
     }
 
-    private void removeAndDestroyController(ViewController controller) {
-        stack.remove(controller.getId());
-        controller.destroy();
-    }
-
     ViewController peek() {
         return stack.peek();
     }
     @NonNull
     @Override
     protected StackLayout createView() {
-        StackLayout stackLayout = new StackLayout(getActivity(),
-                topBarBackgroundViewController,
-                topBarController,
-                getId()
-        );
+        StackLayout stackLayout = new StackLayout(getActivity(), topBarController, getId());
         presenter.bindView(topBarController.getView());
         addInitialChild(stackLayout);
         return stackLayout;

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

 import com.reactnativenavigation.presentation.Presenter;
 import com.reactnativenavigation.presentation.StackPresenter;
 import com.reactnativenavigation.viewcontrollers.ChildControllersRegistry;
-import com.reactnativenavigation.viewcontrollers.ReactViewCreator;
 import com.reactnativenavigation.viewcontrollers.ViewController;
-import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import com.reactnativenavigation.views.element.ElementTransitionManager;
 
 public class StackControllerBuilder {
     private Activity activity;
     private ChildControllersRegistry childRegistry;
-    private ReactViewCreator topBarButtonCreator;
-    private TopBarBackgroundViewController topBarBackgroundViewController;
     private TopBarController topBarController;
     private String id;
     private Options initialOptions = new Options();
         return this;
     }
 
-    public StackControllerBuilder setTopBarButtonCreator(ReactViewCreator topBarButtonCreator) {
-        this.topBarButtonCreator = topBarButtonCreator;
-        return this;
-    }
-
-    public StackControllerBuilder setTopBarBackgroundViewController(TopBarBackgroundViewController topBarBackgroundViewController) {
-        this.topBarBackgroundViewController = topBarBackgroundViewController;
-        return this;
-    }
-
     public StackControllerBuilder setTopBarController(TopBarController topBarController) {
         this.topBarController = topBarController;
         return this;
         return this;
     }
 
-    public StackControllerBuilder setBackButtonHelper(BackButtonHelper backButtonHelper) {
+    StackControllerBuilder setBackButtonHelper(BackButtonHelper backButtonHelper) {
         this.backButtonHelper = backButtonHelper;
         return this;
     }
         return new StackController(activity,
                 children,
                 childRegistry,
-                topBarBackgroundViewController,
                 topBarController,
                 animator,
                 id,

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/topbar/TopBarBackgroundViewController.java

         this.viewCreator = viewCreator;
     }
 
-    public TopBarBackgroundViewController(TopBarBackgroundViewController controller) {
-        super(controller.getActivity(), controller.getId(), new YellowBoxDelegate(), controller.options);
-        this.viewCreator = controller.viewCreator;
-    }
-
     @Override
     protected TopBarBackgroundView createView() {
         return viewCreator.create(getActivity(), component.componentId.get(), component.name.get());
     @Override
     public void onViewAppeared() {
         super.onViewAppeared();
-        view.sendComponentStart();
+        getView().sendComponentStart();
     }
 
     @Override
     public void onViewDisappear() {
-        view.sendComponentStop();
+        getView().sendComponentStop();
         super.onViewDisappear();
     }
 

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/topbar/TopBarController.java

 public class TopBarController {
     private TopBar topBar;
 
-    public View createView(Context context, TopBarBackgroundViewController topBarBackgroundViewController, StackLayout stackLayout) {
+    public View createView(Context context, StackLayout stackLayout) {
         if (topBar == null) {
-            topBar = createTopBar(context, topBarBackgroundViewController, stackLayout);
+            topBar = createTopBar(context, stackLayout);
             topBar.setId(CompatUtils.generateViewId());
         }
         return topBar;
     }
 
-    protected TopBar createTopBar(Context context, TopBarBackgroundViewController topBarBackgroundViewController, StackLayout stackLayout) {
-        return new TopBar(context, topBarBackgroundViewController, stackLayout);
+    protected TopBar createTopBar(Context context, StackLayout stackLayout) {
+        return new TopBar(context, stackLayout);
     }
 
     public void clear() {

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

 
 import com.reactnativenavigation.views.topbar.TopBar;
 
-public interface Component {
+public interface Component extends Renderable {
     void drawBehindTopBar();
 
     void drawBelowTopBar(TopBar topBar);
-
-    boolean isRendered();
 }

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

+package com.reactnativenavigation.views;
+
+public interface Renderable {
+    boolean isRendered();
+}

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

 import android.widget.RelativeLayout;
 
 import com.reactnativenavigation.utils.UiUtils;
-import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import com.reactnativenavigation.views.topbar.TopBar;
 
 public class StackLayout extends RelativeLayout implements Component {
     private String stackId;
 
-    public StackLayout(Context context, TopBarBackgroundViewController topBarBackgroundViewController, TopBarController topBarController, String stackId) {
+    public StackLayout(Context context, TopBarController topBarController, String stackId) {
         super(context);
         this.stackId = stackId;
-        createLayout(topBarBackgroundViewController, topBarController);
+        createLayout(topBarController);
         setContentDescription("StackLayout");
     }
 
-    private void createLayout(TopBarBackgroundViewController topBarBackgroundViewController, TopBarController topBarController) {
-        addView(topBarController.createView(getContext(), topBarBackgroundViewController, this),
+    private void createLayout(TopBarController topBarController) {
+        addView(topBarController.createView(getContext(), this),
                 MATCH_PARENT,
                 UiUtils.getTopBarHeight(getContext())
         );

lib/android/app/src/main/java/com/reactnativenavigation/views/topbar/TopBar.java

 import com.reactnativenavigation.interfaces.ScrollEventListener;
 import com.reactnativenavigation.parse.Alignment;
 import com.reactnativenavigation.parse.AnimationOptions;
-import com.reactnativenavigation.parse.Component;
 import com.reactnativenavigation.parse.params.Colour;
 import com.reactnativenavigation.parse.params.Number;
 import com.reactnativenavigation.utils.CompatUtils;
 import com.reactnativenavigation.utils.UiUtils;
 import com.reactnativenavigation.viewcontrollers.TitleBarButtonController;
-import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
 import com.reactnativenavigation.views.StackLayout;
 import com.reactnativenavigation.views.titlebar.TitleBar;
 import com.reactnativenavigation.views.toptabs.TopTabs;
     private TopBarAnimator animator;
     private TopTabs topTabs;
     private FrameLayout root;
-    private TopBarBackgroundViewController topBarBackgroundViewController;
     private View border;
+    private View component;
 
-    public TopBar(final Context context, TopBarBackgroundViewController topBarBackgroundViewController, StackLayout parentView) {
+    public TopBar(final Context context, StackLayout parentView) {
         super(context);
         context.setTheme(R.style.TopBar);
         collapsingBehavior = new TopBarCollapseBehavior(this);
-        this.topBarBackgroundViewController = topBarBackgroundViewController;
         topTabs = new TopTabs(getContext());
         animator = new TopBarAnimator(this, parentView.getStackId());
         createLayout();
         titleBar.setComponent(component);
     }
 
-    public void setBackgroundComponent(Component component) {
-        if (component.hasValue()) {
-            topBarBackgroundViewController.setComponent(component);
-            RelativeLayout.LayoutParams lp = new RelativeLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT);
-            root.addView(topBarBackgroundViewController.getView(), 0, lp);
-        }
+    public void setBackgroundComponent(View component) {
+        this.component = component;
+        root.addView(component, 0);
     }
 
     public void setTopTabFontFamily(int tabIndex, Typeface fontFamily) {
     }
 
     public void clear() {
-        topBarBackgroundViewController.destroy();
-        topBarBackgroundViewController = new TopBarBackgroundViewController(topBarBackgroundViewController);
+        if (component != null) {
+            root.removeView(component);
+            component = null;
+        }
         titleBar.clear();
     }
 

lib/android/app/src/test/java/com/reactnativenavigation/TestUtils.java

 import com.reactnativenavigation.mocks.TopBarButtonCreatorMock;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.params.Bool;
+import com.reactnativenavigation.presentation.RenderChecker;
 import com.reactnativenavigation.presentation.StackPresenter;
 import com.reactnativenavigation.utils.ImageLoader;
 import com.reactnativenavigation.utils.UiUtils;
 import com.reactnativenavigation.viewcontrollers.ChildControllersRegistry;
 import com.reactnativenavigation.viewcontrollers.ViewController;
 import com.reactnativenavigation.viewcontrollers.stack.StackControllerBuilder;
-import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import com.reactnativenavigation.views.StackLayout;
 import com.reactnativenavigation.views.topbar.TopBar;
         return new StackControllerBuilder(activity)
                 .setId("stack")
                 .setChildRegistry(new ChildControllersRegistry())
-                .setTopBarButtonCreator(new TopBarButtonCreatorMock())
-                .setTopBarBackgroundViewController(new TopBarBackgroundViewController(activity, new TopBarBackgroundViewCreatorMock()))
                 .setTopBarController(new TopBarController() {
                     @Override
-                    protected TopBar createTopBar(Context context, TopBarBackgroundViewController topBarBackgroundViewController, StackLayout stackLayout) {
-                        TopBar topBar = super.createTopBar(context, topBarBackgroundViewController, stackLayout);
+                    protected TopBar createTopBar(Context context, StackLayout stackLayout) {
+                        TopBar topBar = super.createTopBar(context, stackLayout);
                         topBar.layout(0, 0, 1000, UiUtils.getTopBarHeight(context));
                         return topBar;
                     }
                 })
-                .setStackPresenter(new StackPresenter(activity, new TitleBarReactViewCreatorMock(), new TopBarButtonCreatorMock(), new ImageLoader(), new Options())                )
+                .setStackPresenter(new StackPresenter(activity, new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), new TopBarButtonCreatorMock(), new ImageLoader(), new RenderChecker(), new Options()))
                 .setInitialOptions(new Options());
     }
 

lib/android/app/src/test/java/com/reactnativenavigation/presentation/RenderCheckerTest.java

+package com.reactnativenavigation.presentation;
+
+import com.reactnativenavigation.BaseTest;
+import com.reactnativenavigation.viewcontrollers.ViewController;
+
+import org.junit.Test;
+import org.mockito.Mockito;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+import static com.reactnativenavigation.utils.CollectionUtils.forEach;
+import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+public class RenderCheckerTest extends BaseTest {
+    private RenderChecker uut;
+
+    @Override
+    public void beforeEach() {
+        uut = new RenderChecker();
+    }
+
+    @Test
+    public void areRendered() {
+        Collection<ViewController> items = Arrays.asList(
+                renderedComponent(),
+                renderedComponent(),
+                renderedComponent()
+        );
+        assertThat(uut.areRendered(items)).isTrue();
+        forEach(items, i -> verify(i).isRendered());
+    }
+
+    @Test
+    public void areRendered_reduce() {
+        Collection<ViewController> items = Arrays.asList(
+                renderedComponent(),
+                notRenderedComponent(),
+                renderedComponent()
+        );
+        assertThat(uut.areRendered(items)).isFalse();
+
+    }
+
+    private ViewController renderedComponent() {
+        ViewController mock = Mockito.mock(ViewController.class);
+        when(mock.isRendered()).then(__ -> true);
+        return mock;
+    }
+
+    private ViewController notRenderedComponent() {
+        ViewController mock = Mockito.mock(ViewController.class);
+        when(mock.isRendered()).then(__ -> false);
+        return mock;
+    }
+}

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

 import com.reactnativenavigation.parse.params.Text;
 import com.reactnativenavigation.presentation.ComponentPresenter;
 import com.reactnativenavigation.presentation.Presenter;
+import com.reactnativenavigation.presentation.RenderChecker;
 import com.reactnativenavigation.presentation.StackPresenter;
 import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.utils.ImageLoader;
 import com.reactnativenavigation.viewcontrollers.stack.StackController;
 import com.reactnativenavigation.viewcontrollers.stack.StackControllerBuilder;
-import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import com.reactnativenavigation.views.StackLayout;
 import com.reactnativenavigation.views.topbar.TopBar;
         };
         TopBarController topBarController = new TopBarController() {
             @Override
-            protected TopBar createTopBar(Context context, TopBarBackgroundViewController topBarBackgroundViewController, StackLayout stackLayout) {
-                topBar = spy(super.createTopBar(context, topBarBackgroundViewController, stackLayout));
+            protected TopBar createTopBar(Context context, StackLayout stackLayout) {
+                topBar = spy(super.createTopBar(context, stackLayout));
                 return topBar;
             }
         };
         uut.options.topBar.title.text = new Text("the title");
         StackController stackController =
                 new StackControllerBuilder(activity)
-                        .setTopBarButtonCreator(new TopBarButtonCreatorMock())
-                        .setTopBarBackgroundViewController(new TopBarBackgroundViewController(activity, new TopBarBackgroundViewCreatorMock()))
                         .setTopBarController(new TopBarController())
                         .setId("stackId")
                         .setInitialOptions(new Options())
-                        .setStackPresenter(new StackPresenter(activity, new TitleBarReactViewCreatorMock(), new TopBarButtonCreatorMock(), new ImageLoader(), new Options()))
+                        .setStackPresenter(new StackPresenter(activity, new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), new TopBarButtonCreatorMock(), new ImageLoader(), new RenderChecker(), new Options()))
                         .build();
         stackController.ensureViewIsCreated();
         stackController.push(uut, new CommandListenerAdapter());

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

 import com.reactnativenavigation.mocks.TestComponentLayout;
 import com.reactnativenavigation.mocks.TestReactView;
 import com.reactnativenavigation.mocks.TitleBarReactViewCreatorMock;
+import com.reactnativenavigation.mocks.TopBarBackgroundViewCreatorMock;
 import com.reactnativenavigation.mocks.TopBarButtonCreatorMock;
 import com.reactnativenavigation.parse.Alignment;
 import com.reactnativenavigation.parse.Component;
 import com.reactnativenavigation.parse.params.Fraction;
 import com.reactnativenavigation.parse.params.Number;
 import com.reactnativenavigation.parse.params.Text;
+import com.reactnativenavigation.presentation.RenderChecker;
 import com.reactnativenavigation.presentation.StackPresenter;
 import com.reactnativenavigation.utils.TitleBarHelper;
 import com.reactnativenavigation.views.titlebar.TitleBarReactView;
 import org.mockito.ArgumentCaptor;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 
     private TestComponentLayout otherChild;
     private Activity activity;
     private TopBar topBar;
+    private RenderChecker renderChecker;
 
     private Button textBtn1 = TitleBarHelper.textualButton("btn1");
     private Button textBtn2 = TitleBarHelper.textualButton("btn2");
                 return spy(super.create(activity, componentId, componentName));
             }
         };
-        uut = spy(new StackPresenter(activity, titleViewCreator, new TopBarButtonCreatorMock(), ImageLoaderMock.mock(), new Options()));
+        renderChecker = spy(new RenderChecker());
+        uut = spy(new StackPresenter(activity, titleViewCreator, new TopBarBackgroundViewCreatorMock(), new TopBarButtonCreatorMock(), ImageLoaderMock.mock(), renderChecker, new Options()));
         topBar = mockTopBar();
         uut.bindView(topBar);
         uut.setButtonOnClickListener(onClickListener);
         otherChild = new TestComponentLayout(activity, new TestReactView(activity));
     }
 
+    @Test
+    public void isRendered() {
+        Options o1 = new Options();
+        o1.topBar.title.component = component(Alignment.Default);
+        o1.topBar.background.component = component(Alignment.Default);
+        o1.topBar.buttons.right = new ArrayList(Collections.singletonList(componentBtn1));
+        uut.applyChildOptions(o1, child);
+
+        uut.isRendered(child);
+        ArgumentCaptor<Collection<ViewController>> controllers = ArgumentCaptor.forClass(Collection.class);
+        verify(renderChecker).areRendered(controllers.capture());
+        ArrayList<ViewController> items = new ArrayList(controllers.getValue());
+        assertThat(items.contains(uut.getComponentButtons(child).get(0))).isTrue();
+        assertThat(items.contains(uut.getTitleComponents().get(child))).isTrue();
+        assertThat(items.contains(uut.getBackgroundComponents().get(child))).isTrue();
+        assertThat(items.size()).isEqualTo(3);
+    }
+
     @Test
     public void applyChildOptions_setTitleComponent() {
         Options options = new Options();

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

 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 
+@SuppressWarnings("MagicNumber")
 public class TopBarButtonControllerTest extends BaseTest {
 
     private TitleBarButtonController uut;
         final Activity activity = newActivity();
 
         TopBarButtonCreatorMock buttonCreatorMock = new TopBarButtonCreatorMock();
-        stackController = spy(
-                TestUtils.newStackController(activity)
-                        .setTopBarButtonCreator(buttonCreatorMock)
-                        .build()
-        );
+        stackController = spy(TestUtils.newStackController(activity).build());
         stackController.getView().layout(0, 0, 1080, 1920);
         stackController.getTopBar().layout(0, 0, 1080, 200);
         getTitleBar().layout(0, 0, 1080, 200);

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

 import android.support.annotation.NonNull;
 
 import com.reactnativenavigation.BaseTest;
-import com.reactnativenavigation.mocks.TopBarBackgroundViewCreatorMock;
-import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import com.reactnativenavigation.views.StackLayout;
 import com.reactnativenavigation.views.titlebar.TitleBar;
         uut = new TopBarController() {
             @NonNull
             @Override
-            protected TopBar createTopBar(Context context, TopBarBackgroundViewController topBarBackgroundViewController, StackLayout stackLayout) {
-                return new TopBar(context, topBarBackgroundViewController, stackLayout) {
+            protected TopBar createTopBar(Context context, StackLayout stackLayout) {
+                return new TopBar(context, stackLayout) {
                     @Override
                     protected TitleBar createTitleBar(Context context) {
                         titleBar[0] = spy(super.createTitleBar(context));
             }
         };
         Activity activity = newActivity();
-        uut.createView(activity, new TopBarBackgroundViewController(activity, new TopBarBackgroundViewCreatorMock()), Mockito.mock(StackLayout.class));
+        uut.createView(activity, Mockito.mock(StackLayout.class));
         uut.clear();
         verify(titleBar[0], times(1)).clear();
     }

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

 import com.reactnativenavigation.views.BottomTabs;
 
 import org.junit.Test;
+import org.mockito.ArgumentCaptor;
 import org.mockito.Mockito;
 import org.robolectric.android.controller.ActivityController;
 import org.robolectric.annotation.Config;
 
 import static org.assertj.core.api.Java6Assertions.assertThat;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
     public void setRoot_delegatesToRootPresenter() {
         CommandListenerAdapter listener = new CommandListenerAdapter();
         uut.setRoot(child1, listener);
-        verify(rootPresenter).setRoot(child1, uut.getDefaultOptions(), listener);
+        ArgumentCaptor<CommandListenerAdapter> captor = ArgumentCaptor.forClass(CommandListenerAdapter.class);
+        verify(rootPresenter).setRoot(eq(child1), eq(uut.getDefaultOptions()), captor.capture());
+        assertThat(captor.getValue().getListener()).isEqualTo(listener);
     }
 
     @Test
     public void setRoot_clearsSplashLayout() {
-        disableModalAnimations(child1);
-
         FrameLayout content = activity.findViewById(android.R.id.content);
         assertThat(content.getChildCount()).isEqualTo(4); // 3 frame layouts and the default splash layout
 

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/navigator/RootPresenterTest.java

 import com.reactnativenavigation.mocks.SimpleViewController;
 import com.reactnativenavigation.parse.AnimationOptions;
 import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.parse.params.Bool;
 import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.viewcontrollers.ChildControllersRegistry;
 import com.reactnativenavigation.viewcontrollers.ViewController;
 import com.reactnativenavigation.views.element.ElementTransitionManager;
 
 import org.junit.Test;
+import org.mockito.ArgumentCaptor;
 
 import static org.assertj.core.api.Java6Assertions.assertThat;
 import static org.mockito.ArgumentMatchers.any;
         verify(listener).onSuccess(spy.getId());
     }
 
+    @Test
+    public void setRoot_waitForRenderIsSet() {
+        root.options.animations.setRoot.waitForRender = new Bool(true);
+        ViewController spy = spy(root);
+
+        uut.setRoot(spy, defaultOptions, new CommandListenerAdapter());
+
+        ArgumentCaptor<Bool> captor = ArgumentCaptor.forClass(Bool.class);
+        verify(spy).setWaitForRender(captor.capture());
+        assertThat(captor.getValue().get()).isTrue();
+    }
+
+    @Test
+    public void setRoot_waitForRender() {
+        root.options.animations.setRoot.waitForRender = new Bool(true);
+
+        ViewController spy = spy(root);
+        CommandListenerAdapter listener = spy(new CommandListenerAdapter());
+        uut.setRoot(spy, defaultOptions, listener);
+        verify(spy).setOnAppearedListener(any());
+        assertThat(spy.getView().getAlpha()).isZero();
+        verifyZeroInteractions(listener);
+
+        spy.onViewAppeared();
+        assertThat(spy.getView().getAlpha()).isOne();
+        verify(listener).onSuccess(spy.getId());
+    }
+
     @NonNull
     private NavigationAnimator createAnimator(Activity activity) {
         return new NavigationAnimator(activity, mock(ElementTransitionManager.class)) {

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

 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.params.Bool;
 import com.reactnativenavigation.parse.params.Text;
+import com.reactnativenavigation.presentation.RenderChecker;
 import com.reactnativenavigation.presentation.StackPresenter;
 import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.utils.ImageLoader;
 import com.reactnativenavigation.viewcontrollers.ChildControllersRegistry;
 import com.reactnativenavigation.viewcontrollers.ParentController;
 import com.reactnativenavigation.viewcontrollers.ViewController;
-import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import com.reactnativenavigation.views.Component;
 import com.reactnativenavigation.views.ReactComponent;
     private TopBarController topBarController;
     private StackPresenter presenter;
     private BackButtonHelper backButtonHelper;
+    private RenderChecker renderChecker;
 
     @Override
     public void beforeEach() {
         activity = newActivity();
         animator = spy(new NavigationAnimator(activity, Mockito.mock(ElementTransitionManager.class)));
         childRegistry = new ChildControllersRegistry();
-        presenter = spy(new StackPresenter(activity, new TitleBarReactViewCreatorMock(), new TopBarButtonCreatorMock(), ImageLoaderMock.mock(), new Options()));
+        renderChecker = spy(new RenderChecker());
+        presenter = spy(new StackPresenter(activity, new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), new TopBarButtonCreatorMock(), ImageLoaderMock.mock(), renderChecker, new Options()));
         child1 = spy(new SimpleViewController(activity, childRegistry, "child1", new Options()));
         child2 = spy(new SimpleViewController(activity, childRegistry, "child2", new Options()));
         child3 = spy(new SimpleViewController(activity, childRegistry, "child3", new Options()));
         assertContainsOnlyId(child1.getId(), child2.getId(), child3.getId());
     }
 
+    @Test
+    public void isRendered_falseIfStackIsEmpty() {
+        assertThat(uut.size()).isZero();
+        assertThat(uut.isRendered()).isFalse();
+    }
+
+    @Test
+    public void isRendered() {
+        disablePushAnimation(child1);
+
+        uut.push(child1, new CommandListenerAdapter());
+        verify(presenter).isRendered((Component) child1.getView());
+        verify(renderChecker).areRendered(any());
+        assertThat(uut.isRendered()).isTrue();
+
+        child1.setWaitForRender(new Bool(true));
+        assertThat(uut.isRendered()).isFalse();
+
+        child1.getView().addView(new View(activity));
+        assertThat(uut.isRendered()).isTrue();
+
+        Mockito.when(presenter.isRendered((Component) child1.getView())).then(ignored -> false);
+        assertThat(uut.isRendered()).isFalse();
+    }
+
     @Test
     public void push() {
         assertThat(uut.isEmpty()).isTrue();
     @Test
     public void pop_layoutHandlesChildWillDisappear() {
         uut = new StackControllerBuilder(activity)
-                        .setTopBarButtonCreator(new TopBarButtonCreatorMock())
-                        .setTopBarBackgroundViewController(new TopBarBackgroundViewController(activity, new TopBarBackgroundViewCreatorMock()))
                         .setTopBarController(new TopBarController())
                         .setId("uut")
                         .setInitialOptions(new Options())
-                        .setStackPresenter(new StackPresenter(activity, new TitleBarReactViewCreatorMock(), new TopBarButtonCreatorMock(), new ImageLoader(), new Options()))
+                        .setStackPresenter(new StackPresenter(activity, new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), new TopBarButtonCreatorMock(), new ImageLoader(), new RenderChecker(), new Options()))
                         .build();
         uut.ensureViewIsCreated();
         uut.push(child1, new CommandListenerAdapter());
     @Test
     public void mergeChildOptions_updatesViewWithNewOptions() {
         StackController uut = spy(new StackControllerBuilder(activity)
-                        .setTopBarButtonCreator(new TopBarButtonCreatorMock())
-                        .setTopBarBackgroundViewController(new TopBarBackgroundViewController(activity, new TopBarBackgroundViewCreatorMock()))
                         .setTopBarController(new TopBarController())
                         .setId("stack")
                         .setInitialOptions(new Options())
-                        .setStackPresenter(new StackPresenter(activity, new TitleBarReactViewCreatorMock(), new TopBarButtonCreatorMock(), new ImageLoader(), new Options()))
+                        .setStackPresenter(new StackPresenter(activity, new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), new TitleBarReactViewCreatorMock(), ImageLoaderMock.mock(), new RenderChecker(), Options.EMPTY))
                         .build());
         Options optionsToMerge = new Options();
         Component component = mock(Component.class);
     @Test
     public void mergeChildOptions_updatesParentControllerWithNewOptions() {
         StackController uut = new StackControllerBuilder(activity)
-                        .setTopBarButtonCreator(new TopBarButtonCreatorMock())
-                        .setTopBarBackgroundViewController(new TopBarBackgroundViewController(activity, new TopBarBackgroundViewCreatorMock()))
                         .setTopBarController(new TopBarController())
                         .setId("stack")
                         .setInitialOptions(new Options())
-                        .setStackPresenter(new StackPresenter(activity, new TitleBarReactViewCreatorMock(), new TopBarButtonCreatorMock(), new ImageLoader(), new Options()))
+                        .setStackPresenter(new StackPresenter(activity, new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), new TitleBarReactViewCreatorMock(), ImageLoaderMock.mock(), new RenderChecker(), Options.EMPTY))
                         .build();
         ParentController parentController = Mockito.mock(ParentController.class);
         uut.setParentController(parentController);
     private void createTopBarController() {
         topBarController = spy(new TopBarController() {
             @Override
-            protected TopBar createTopBar(Context context, TopBarBackgroundViewController topBarBackgroundViewController, StackLayout stackLayout) {
-                TopBar spy = spy(super.createTopBar(context, topBarBackgroundViewController, stackLayout));
+            protected TopBar createTopBar(Context context, StackLayout stackLayout) {
+                TopBar spy = spy(super.createTopBar(context, stackLayout));
                 spy.layout(0, 0, 1000, UiUtils.getTopBarHeight(activity));
                 return spy;
             }

lib/android/app/src/test/java/com/reactnativenavigation/views/TopBarBackgroundComponentTest.java

-package com.reactnativenavigation.views;
-
-import android.app.Activity;
-import android.view.View;
-import android.view.ViewGroup;
-
-import com.reactnativenavigation.BaseTest;
-import com.reactnativenavigation.R;
-import com.reactnativenavigation.mocks.TopBarBackgroundViewCreatorMock;
-import com.reactnativenavigation.parse.Component;
-import com.reactnativenavigation.parse.params.Text;
-import com.reactnativenavigation.utils.ViewUtils;
-import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
-import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
-import com.reactnativenavigation.views.topbar.TopBar;
-import com.reactnativenavigation.views.topbar.TopBarBackgroundView;
-
-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;
-
-public class TopBarBackgroundComponentTest extends BaseTest {
-    private TopBar uut;
-    private TopBarBackgroundViewController topBarBackgroundViewController;
-
-    @SuppressWarnings("Convert2Lambda")
-    @Override
-    public void beforeEach() {
-        Activity activity = newActivity();
-        topBarBackgroundViewController = spy(new TopBarBackgroundViewController(activity, new TopBarBackgroundViewCreatorMock()));
-        StackLayout parent = new StackLayout(activity, topBarBackgroundViewController, new TopBarController(), null);
-        uut = new TopBar(activity, topBarBackgroundViewController, parent);
-        parent.addView(uut);
-    }
-
-    @Test
-    public void setBackgroundComponent() {
-        uut.getLayoutParams().height = 100;
-        Component component = new Component();
-        component.name = new Text("someComponent");
-        component.componentId = new Text("id");
-        uut.setBackgroundComponent(component);
-        TopBarBackgroundView background = (TopBarBackgroundView) ViewUtils.findChildrenByClassRecursive(uut, TopBarBackgroundView.class).get(0);
-        assertThat(background).isNotNull();
-        assertThat(background.getLayoutParams().width).isEqualTo(ViewGroup.LayoutParams.MATCH_PARENT);
-        assertThat(background.getLayoutParams().height).isEqualTo(ViewGroup.LayoutParams.MATCH_PARENT);
-    }
-
-    @Test
-    public void setBackgroundComponent_doesNotSetIfNoComponentIsDefined() {
-        Component component = new Component();
-        component.name = new Text("someComponent");
-        component.componentId = new Text("id");
-        uut.setBackgroundComponent(component);
-        assertThat((View) uut.findViewById(R.id.topBarBackgroundComponent)).isNull();
-    }
-
-    @Test
-    public void clear_componentIsDestroyed() {
-        Component component = new Component();
-        component.name = new Text("someComponent");
-        component.componentId = new Text("id");
-        uut.setBackgroundComponent(component);
-        uut.clear();
-        verify(topBarBackgroundViewController, times(1)).destroy();
-    }
-}

lib/android/app/src/test/java/com/reactnativenavigation/views/TopBarTest.java

 
 import com.reactnativenavigation.BaseTest;
 import com.reactnativenavigation.anim.TopBarAnimator;
-import com.reactnativenavigation.mocks.TopBarBackgroundViewCreatorMock;
 import com.reactnativenavigation.parse.AnimationOptions;
-import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import com.reactnativenavigation.views.topbar.TopBar;
 
     @Override
     public void beforeEach() {
         Activity activity = newActivity();
-        TopBarBackgroundViewController topBarBackgroundViewController = new TopBarBackgroundViewController(activity, new TopBarBackgroundViewCreatorMock());
-        StackLayout parent = new StackLayout(activity, topBarBackgroundViewController, new TopBarController(), null);
-        uut = new TopBar(activity, topBarBackgroundViewController, parent);
+        StackLayout parent = new StackLayout(activity, new TopBarController(), null);
+        uut = new TopBar(activity, parent);
         animator = spy(new TopBarAnimator(uut));
         uut.setAnimator(animator);
         parent.addView(uut);