Stack layout android (#2531)

* Change topBar backgroundColor to Color object

* StackLayout implementation

Unfortunately, this commit also contains a lot of refactoring and a few
bug fixes relating to styles.

* TopBar is not part of Component, instead it's a part of StackLayout
  and shared between all components pushed to the stack Similar to iOS.
* Handle ScrollEvent in ReactView instead of passing the listener down
* Implement Fraction and Text null objects for style params
* Converted a few style params to null objects. This fixes some styles
  being applied even when they were not specified explicitly.
* Stop sending null promise to commands
* Seperate push and pop into animatePush/push and animatePop/pop
  to avoid boolean param

* Adapt TopTabs to new API

lib/android/app/src/main/java/com/reactnativenavigation/anim/TopBarAnimator.java

     }
 
     void hide(float startTranslation, TimeInterpolator interpolator, int duration) {
-        ObjectAnimator topbarAnim = ObjectAnimator.ofFloat(topBar, View.TRANSLATION_Y, startTranslation, -1 * topBar.getMeasuredHeight());
-        topbarAnim.setInterpolator(interpolator);
-        topbarAnim.setDuration(duration);
+        ObjectAnimator animator = ObjectAnimator.ofFloat(topBar, View.TRANSLATION_Y, startTranslation, -1 * topBar.getMeasuredHeight());
+        animator.setInterpolator(interpolator);
+        animator.setDuration(duration);
 
-        topbarAnim.addListener(new AnimatorListenerAdapter() {
+        animator.addListener(new AnimatorListenerAdapter() {
             @Override
             public void onAnimationEnd(Animator animation) {
                 if (contentView != null) {
                 topBar.setVisibility(View.GONE);
             }
         });
-        topbarAnim.start();
+        animator.start();
     }
 }

lib/android/app/src/main/java/com/reactnativenavigation/anim/TopBarCollapseBehavior.java

     private ScrollEventListener scrollEventListener;
     private TopBarAnimator animator;
 
-    public TopBarCollapseBehavior(TopBar topBar, ScrollEventListener scrollEventListener) {
+    public TopBarCollapseBehavior(TopBar topBar) {
         this.topBar = topBar;
         this.animator = new TopBarAnimator(topBar);
-        this.scrollEventListener = scrollEventListener;
     }
 
     public void enableCollapse() {

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

 		BottomTabsOptions options = new BottomTabsOptions();
 		if (json == null) return options;
 
-		options.currentTabId = json.optString("currentTabId", NO_VALUE);
+		options.currentTabId = TextParser.parse(json, "currentTabId");
 		options.currentTabIndex = json.optInt("currentTabIndex", NO_INT_VALUE);
 		options.tabBadge = json.optInt("tabBadge", NO_INT_VALUE);
 		options.hidden = BooleanOptions.parse(json.optString("hidden"));
 		return options;
 	}
 
-	public int tabBadge = NO_INT_VALUE;
-	public BooleanOptions hidden = BooleanOptions.False;
-	public BooleanOptions animateHide = BooleanOptions.False;
+	int tabBadge = NO_INT_VALUE;
+	BooleanOptions hidden = BooleanOptions.False;
+	BooleanOptions animateHide = BooleanOptions.False;
 	public int currentTabIndex = NO_INT_VALUE;
-	public String currentTabId = NO_VALUE;
+	public Text currentTabId = new NullText();
 
 	void mergeWith(final BottomTabsOptions other) {
-		if (!NO_VALUE.equals(other.currentTabId)) {
+		if (other.currentTabId.hasValue()) {
 			currentTabId = other.currentTabId;
 		}
 		if (NO_INT_VALUE != other.currentTabIndex) {
 	}
 
     void mergeWithDefault(final BottomTabsOptions defaultOptions) {
-        if (NO_VALUE.equals(currentTabId)) {
+        if (!currentTabId.hasValue()) {
             currentTabId = defaultOptions.currentTabId;
         }
         if (NO_INT_VALUE == currentTabIndex) {

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

 
 import java.util.ArrayList;
 
-import static com.reactnativenavigation.parse.DEFAULT_VALUES.NO_VALUE;
 import static com.reactnativenavigation.parse.Options.NO_INT_VALUE;
 
 public class Button {
 	public String id;
-	public String title;
+	public Text title;
 	public Options.BooleanOptions disabled;
 	public Options.BooleanOptions disableIconTint;
 	public int showAsAction;
 	@ColorInt public int buttonColor;
 	public int buttonFontSize;
-	public String buttonFontWeight;
-	public String icon;
+	public Text buttonFontWeight;
+	public Text icon;
 
 	private static Button parseJson(JSONObject json)  {
 		Button button = new Button();
 		button.id = json.optString("id");
-		button.title = json.optString("title", NO_VALUE);
-		button.disabled = Options.BooleanOptions.parse(json.optString("disabled", NO_VALUE));
-		button.disableIconTint = Options.BooleanOptions.parse(json.optString("disableIconTint", NO_VALUE));
-		button.showAsAction = parseShowAsAction(json.optString("showAsAction", NO_VALUE));
+		button.title = TextParser.parse(json, "title");
+		button.disabled = Options.BooleanOptions.parse(json.optString("disabled", ""));
+		button.disableIconTint = Options.BooleanOptions.parse(json.optString("disableIconTint", ""));
+		button.showAsAction = parseShowAsAction(json);
 		button.buttonColor = json.optInt("buttonColor", NO_INT_VALUE);
 		button.buttonFontSize = json.optInt("buttonFontSize", NO_INT_VALUE);
-		button.buttonFontWeight = json.optString("buttonFontWeight", NO_VALUE);
+		button.buttonFontWeight = TextParser.parse(json, "buttonFontWeight");
 
-		JSONObject iconObject = json.optJSONObject("icon");
-		if (iconObject != null) {
-			button.icon = iconObject.optString("uri", NO_VALUE);
+		if (json.has("icon")) {
+			button.icon = TextParser.parse(json.optJSONObject("icon"), "uri");
 		}
 
 		return button;
 	}
 
-	public static ArrayList<Button> parseJsonArray(JSONArray jsonArray) {
+	static ArrayList<Button> parseJsonArray(JSONArray jsonArray) {
 		ArrayList<Button> buttons = new ArrayList<>();
 
 		if (jsonArray == null) {
 		return buttons;
 	}
 
-	private static int parseShowAsAction(String showAsAction) {
-		if (NO_VALUE.equals(showAsAction)) {
+	private static int parseShowAsAction(JSONObject json) {
+	    final Text showAsAction = TextParser.parse(json, "showAsAction");
+		if (!showAsAction.hasValue()) {
 			return MenuItem.SHOW_AS_ACTION_IF_ROOM;
 		}
 
-		switch (showAsAction) {
+		switch (showAsAction.get()) {
 			case "always":
 				return MenuItem.SHOW_AS_ACTION_ALWAYS;
 			case "never":

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

 package com.reactnativenavigation.parse;
 
 
-import android.graphics.Color;
-
 public interface DEFAULT_VALUES {
-	String NO_VALUE = "";
 	int NO_INT_VALUE = Integer.MIN_VALUE;
-	float NO_FLOAT_VALUE = Float.MIN_VALUE;
-	int NO_COLOR_VALUE = Color.TRANSPARENT;
 }

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

+package com.reactnativenavigation.parse;
+
+public class Fraction extends Param<Float> {
+    public Fraction(float value) {
+        super(value);
+    }
+}

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

+package com.reactnativenavigation.parse;
+
+import org.json.JSONObject;
+
+public class FractionParser {
+    public static Fraction parse(JSONObject json, String fraction) {
+        return json.has(fraction) ? new Fraction(json.optInt(fraction)) : new NullFraction();
+    }
+}

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

 import android.app.Activity;
 
 import com.facebook.react.ReactInstanceManager;
+import com.reactnativenavigation.utils.NoOpPromise;
 import com.reactnativenavigation.utils.TypefaceLoader;
 import com.reactnativenavigation.viewcontrollers.BottomTabsController;
 import com.reactnativenavigation.viewcontrollers.ComponentViewController;
 	private ViewController createStack(LayoutNode node) {
 		StackController stackController = new StackController(activity, node.id);
 		for (LayoutNode child : node.children) {
-			stackController.push(create(child), null);
+			stackController.animatePush(create(child), new NoOpPromise());
 		}
 		return stackController;
 	}
 	}
 
     private ViewController createTopTabs(LayoutNode node) {
-        final List<TopTabController> tabs = new ArrayList<>();
+        final List<ViewController> tabs = new ArrayList<>();
         for (int i = 0; i < node.children.size(); i++) {
-            TopTabController tabController = (TopTabController) create(node.children.get(i));
-            tabController.setTabIndex(i);
+            ViewController tabController = create(node.children.get(i));
+            Options options = Options.parse(typefaceManager, node.children.get(i).getNavigationOptions(), defaultOptions);
+            options.setTopTabIndex(i);
             tabs.add(tabController);
         }
         Options options = Options.parse(typefaceManager, node.getNavigationOptions(), defaultOptions);

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

+package com.reactnativenavigation.parse;
+
+public class NullFraction extends Fraction {
+    NullFraction() {
+        super(0);
+    }
+
+    @Override
+    public boolean hasValue() {
+        return false;
+    }
+}

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

 package com.reactnativenavigation.parse;
 
 public class NullNumber extends Number {
-    public NullNumber() {
+    NullNumber() {
         super(0);
     }
 

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

+package com.reactnativenavigation.parse;
+
+public class NullText extends Text {
+    public NullText() {
+        super("");
+    }
+
+    @Override
+    public boolean hasValue() {
+        return false;
+    }
+}

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

 package com.reactnativenavigation.parse;
 
 import android.support.annotation.NonNull;
+import android.text.TextUtils;
 
 import com.reactnativenavigation.utils.TypefaceLoader;
 
 		NoValue;
 
 		static BooleanOptions parse(String value) {
-			if (value != null && !value.equals("")) {
+			if (!TextUtils.isEmpty(value)) {
 				return Boolean.valueOf(value) ? True : False;
 			}
 			return NoValue;
     @NonNull public TopTabOptions topTabOptions = new TopTabOptions();
     @NonNull public BottomTabsOptions bottomTabsOptions = new BottomTabsOptions();
 
+    void setTopTabIndex(int i) {
+        topTabOptions.tabIndex = i;
+    }
+
 	public void mergeWith(final Options other) {
         topBarOptions.mergeWith(other.topBarOptions);
         topTabsOptions.mergeWith(other.topTabsOptions);

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

         throw new RuntimeException("Tried to get null value!");
     }
 
+    public T get(T defaultValue) {
+        return hasValue() ? value : defaultValue;
+    }
+
     public boolean hasValue() {
         return value != null;
     }

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

+package com.reactnativenavigation.parse;
+
+public class Text extends Param<String> {
+    public Text(String value) {
+        super(value);
+    }
+}

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

+package com.reactnativenavigation.parse;
+
+import org.json.JSONObject;
+
+public class TextParser {
+    public static Text parse(JSONObject json, String text) {
+        return json.has(text) ? new Text(json.optString(text)) : new NullText();
+    }
+}

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

 
 
 import android.graphics.Typeface;
-import android.support.annotation.ColorInt;
 import android.support.annotation.Nullable;
 
 import com.reactnativenavigation.utils.TypefaceLoader;
         TopBarOptions options = new TopBarOptions();
         if (json == null) return options;
 
-        options.title = json.optString("title", NO_VALUE);
-        options.backgroundColor = json.optInt("backgroundColor", NO_COLOR_VALUE);
-        options.textColor = json.optInt("textColor", NO_COLOR_VALUE);
-        options.textFontSize = (float) json.optDouble("textFontSize", NO_FLOAT_VALUE);
-        options.textFontFamily = typefaceManager.getTypeFace(json.optString("textFontFamily", NO_VALUE));
+        options.title = TextParser.parse(json, "title");
+        options.backgroundColor = ColorParser.parse(json, "backgroundColor");
+        options.textColor = ColorParser.parse(json, "textColor");
+        options.textFontSize = FractionParser.parse(json, "textFontSize");
+        options.textFontFamily = typefaceManager.getTypeFace(json.optString("textFontFamily", ""));
         options.hidden = Options.BooleanOptions.parse(json.optString("hidden"));
         options.animateHide = Options.BooleanOptions.parse(json.optString("animateHide"));
         options.hideOnScroll = Options.BooleanOptions.parse(json.optString("hideOnScroll"));
         return options;
     }
 
-    public String title = NO_VALUE;
-    @ColorInt public int backgroundColor = NO_COLOR_VALUE;
-    @ColorInt public int textColor = NO_COLOR_VALUE;
-    public float textFontSize = NO_FLOAT_VALUE;
+    public Text title = new NullText();
+    public Color backgroundColor = new NullColor();
+    public Color textColor = new NullColor();
+    public Fraction textFontSize = new NullFraction();
     @Nullable public Typeface textFontFamily;
     public Options.BooleanOptions hidden = Options.BooleanOptions.NoValue;
     public Options.BooleanOptions animateHide = Options.BooleanOptions.NoValue;
     public ArrayList<Button> rightButtons;
 
     void mergeWith(final TopBarOptions other) {
-        if (!NO_VALUE.equals(other.title)) title = other.title;
-        if (other.backgroundColor != NO_COLOR_VALUE)
+        if (other.title != null) title = other.title;
+        if (other.backgroundColor.hasValue())
             backgroundColor = other.backgroundColor;
-        if (other.textColor != NO_COLOR_VALUE)
+        if (other.textColor.hasValue())
             textColor = other.textColor;
-        if (other.textFontSize != NO_FLOAT_VALUE)
+        if (other.textFontSize.hasValue())
             textFontSize = other.textFontSize;
         if (other.textFontFamily != null)
             textFontFamily = other.textFontFamily;
     }
 
     void mergeWithDefault(TopBarOptions defaultOptions) {
-        if (NO_VALUE.equals(title))
+        if (title == null)
             title = defaultOptions.title;
-        if (backgroundColor == NO_COLOR_VALUE)
+        if (!backgroundColor.hasValue())
             backgroundColor = defaultOptions.backgroundColor;
-        if (textColor == NO_COLOR_VALUE)
+        if (!textColor.hasValue())
             textColor = defaultOptions.textColor;
-        if (textFontSize == NO_FLOAT_VALUE)
+        if (!textFontSize.hasValue())
             textFontSize = defaultOptions.textFontSize;
         if (textFontFamily == null)
             textFontFamily = defaultOptions.textFontFamily;

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

 import org.json.JSONObject;
 
 public class TopTabOptions implements DEFAULT_VALUES {
-    public String title = NO_VALUE;
+    public Text title = new NullText();
     @Nullable public Typeface fontFamily;
     public int tabIndex;
 
         TopTabOptions result = new TopTabOptions();
         if (json == null) return result;
 
-        result.title = json.optString("title", NO_VALUE);
+        result.title = TextParser.parse(json, "title");
         result.fontFamily = typefaceManager.getTypeFace(json.optString("titleFontFamily"));
         return result;
     }

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

 import com.reactnativenavigation.parse.TopBarOptions;
 import com.reactnativenavigation.parse.TopTabOptions;
 import com.reactnativenavigation.parse.TopTabsOptions;
-import com.reactnativenavigation.views.Component;
+import com.reactnativenavigation.views.ReactComponent;
 import com.reactnativenavigation.views.TopBar;
 
 import java.util.ArrayList;
 import static com.reactnativenavigation.parse.Options.BooleanOptions.True;
 
 public class OptionsPresenter {
-
-    private Component reactComponent;
     private TopBar topBar;
+    private ReactComponent component;
 
-    public OptionsPresenter(Component reactComponent) {
-        this.reactComponent = reactComponent;
-        this.topBar = reactComponent.getTopBar();
+    public OptionsPresenter(TopBar topBar, ReactComponent component) {
+        this.topBar = topBar;
+        this.component = component;
     }
 
     public void applyOptions(Options options) {
     }
 
     private void applyTopBarOptions(TopBarOptions options) {
-        topBar.setTitle(options.title);
+        if (options.title.hasValue()) topBar.setTitle(options.title.get());
         topBar.setBackgroundColor(options.backgroundColor);
         topBar.setTitleTextColor(options.textColor);
         topBar.setTitleFontSize(options.textFontSize);
 
         topBar.setTitleTypeface(options.textFontFamily);
-        if (options.hidden == Options.BooleanOptions.True) {
+        if (options.hidden == True) {
             topBar.hide(options.animateHide);
         }
-        if (options.hidden == Options.BooleanOptions.False) {
+        if (options.hidden == False) {
             topBar.show(options.animateHide);
         }
         if (options.drawBehind == True) {
-            reactComponent.drawBehindTopBar();
+            component.drawBehindTopBar();
         } else if (options.drawBehind == False) {
-            reactComponent.drawBelowTopBar();
+            component.drawBelowTopBar(topBar);
         }
 
         if (options.hideOnScroll == True) {

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

+package com.reactnativenavigation.utils;
+
+import com.facebook.react.bridge.Promise;
+
+import javax.annotation.Nullable;
+
+public class NoOpPromise implements Promise {
+    @Override
+    public void resolve(@Nullable Object value) {
+
+    }
+
+    @Override
+    public void reject(String code, String message) {
+
+    }
+
+    @Override
+    public void reject(String code, Throwable e) {
+
+    }
+
+    @Override
+    public void reject(String code, String message, Throwable e) {
+
+    }
+
+    @Override
+    public void reject(String message) {
+
+    }
+
+    @Override
+    public void reject(Throwable reason) {
+
+    }
+}

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

 import android.widget.RelativeLayout;
 
 import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.parse.Text;
 import com.reactnativenavigation.presentation.NavigationOptionsListener;
 import com.reactnativenavigation.utils.CompatUtils;
 
 import static android.widget.RelativeLayout.ABOVE;
 import static android.widget.RelativeLayout.ALIGN_PARENT_BOTTOM;
 import static com.reactnativenavigation.parse.DEFAULT_VALUES.NO_INT_VALUE;
-import static com.reactnativenavigation.parse.DEFAULT_VALUES.NO_VALUE;
 
 public class BottomTabsController extends ParentController
 		implements BottomNavigationView.OnNavigationItemSelectedListener, NavigationOptionsListener {
 		return true;
 	}
 
-	public void selectTabAtIndex(final int newIndex) {
+	void selectTabAtIndex(final int newIndex) {
 		tabs.get(selectedIndex).getView().setVisibility(View.GONE);
 		selectedIndex = newIndex;
 		tabs.get(selectedIndex).getView().setVisibility(View.VISIBLE);
 		getView().addView(tab.getView(), params);
 	}
 
-	public int getSelectedIndex() {
+	int getSelectedIndex() {
 		return selectedIndex;
 	}
 
 
 	@Override
 	public void mergeOptions(Options options) {
-		if (options.bottomTabsOptions != null) {
-			if (options.bottomTabsOptions.currentTabIndex != NO_INT_VALUE) {
-				selectTabAtIndex(options.bottomTabsOptions.currentTabIndex);
-			}
-			if (!NO_VALUE.equals(options.bottomTabsOptions.currentTabId)) {
-				String id = options.bottomTabsOptions.currentTabId;
-				for (ViewController controller : tabs) {
-					if (controller.getId().equals(id)) {
-						selectTabAtIndex(tabs.indexOf(controller));
-					}
-					if (controller instanceof StackController) {
-						if (hasControlWithId((StackController) controller, id)) {
-							selectTabAtIndex(tabs.indexOf(controller));
-						}
-					}
-				}
-			}
-		}
-	}
+        if (options.bottomTabsOptions.currentTabIndex != NO_INT_VALUE) {
+            selectTabAtIndex(options.bottomTabsOptions.currentTabIndex);
+        }
+        if (options.bottomTabsOptions.currentTabId.hasValue()) {
+            Text id = options.bottomTabsOptions.currentTabId;
+            for (ViewController controller : tabs) {
+                if (controller.getId().equals(id.get())) {
+                    selectTabAtIndex(tabs.indexOf(controller));
+                }
+                if (controller instanceof StackController) {
+                    if (hasControlWithId((StackController) controller, id.get())) {
+                        selectTabAtIndex(tabs.indexOf(controller));
+                    }
+                }
+            }
+        }
+    }
 
 	private boolean hasControlWithId(StackController controller, String id) {
 		for (ViewController child : controller.getChildControllers()) {

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

     private final String componentName;
 
     private final ReactViewCreator viewCreator;
-    private Options options;
     private ReactComponent component;
 
     public ComponentViewController(final Activity activity,
         super(activity, id);
         this.componentName = componentName;
         this.viewCreator = viewCreator;
-        this.options = initialNavigationOptions;
-    }
-
-    @RestrictTo(RestrictTo.Scope.TESTS)
-    TopBar getTopBar() {
-        return component.getTopBar();
+        options = initialNavigationOptions;
     }
 
     @Override
     public void onViewAppeared() {
         super.onViewAppeared();
         ensureViewIsCreated();
-        component.applyOptions(options);
+        applyOnParentStack(parentController -> {
+            parentController.clearOptions();
+            parentController.applyOptions(options, component);
+        });
         component.sendComponentStart();
     }
 
     public void mergeOptions(Options options) {
         this.options.mergeWith(options);
         component.applyOptions(this.options);
+        applyOnParentStack(parentController -> parentController.applyOptions(this.options, component));
     }
 
     Options getOptions() {

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

-package com.reactnativenavigation.viewcontrollers;
-
-import android.app.Activity;
-import android.support.annotation.NonNull;
-import android.support.annotation.RestrictTo;
-import android.view.View;
-
-import com.reactnativenavigation.parse.Options;
-import com.reactnativenavigation.presentation.NavigationOptionsListener;
-import com.reactnativenavigation.views.ReactComponent;
-import com.reactnativenavigation.views.TopBar;
-
-public class ContainerViewController extends ViewController implements NavigationOptionsListener {
-
-    public interface ReactViewCreator {
-
-        IReactView create(Activity activity, String containerId, String containerName);
-    }
-
-    public interface IReactView {
-
-        boolean isReady();
-
-        View asView();
-
-        void destroy();
-
-        void sendComponentStart();
-
-        void sendComponentStop();
-
-        void sendOnNavigationButtonPressed(String buttonId);
-    }
-
-    private final String componentName;
-
-    private final ReactViewCreator viewCreator;
-    private Options options;
-    private ReactComponent component;
-
-    public ContainerViewController(final Activity activity,
-                                   final String id,
-                                   final String componentName,
-                                   final ReactViewCreator viewCreator,
-                                   final Options initialOptions) {
-        super(activity, id);
-        this.componentName = componentName;
-        this.viewCreator = viewCreator;
-        this.options = initialOptions;
-    }
-
-    @RestrictTo(RestrictTo.Scope.TESTS)
-    TopBar getTopBar() {
-        return component.getTopBar();
-    }
-
-    @RestrictTo(RestrictTo.Scope.TESTS)
-    ReactComponent getComponent() {
-        return component;
-    }
-
-    @Override
-    public void destroy() {
-        super.destroy();
-        if (component != null) component.destroy();
-        component = null;
-    }
-
-    @Override
-    public void onViewAppeared() {
-        super.onViewAppeared();
-        ensureViewIsCreated();
-        component.applyOptions(options);
-        component.sendComponentStart();
-    }
-
-    @Override
-    public void onViewDisappear() {
-        super.onViewDisappear();
-        component.sendComponentStop();
-    }
-
-    @Override
-    protected boolean isViewShown() {
-        return super.isViewShown() && component.isReady();
-    }
-
-    @NonNull
-    @Override
-    protected View createView() {
-        component = (ReactComponent) viewCreator.create(getActivity(), getId(), componentName);
-        return component.asView();
-    }
-
-    @Override
-    public void mergeOptions(Options options) {
-        this.options.mergeWith(options);
-        component.applyOptions(this.options);
-    }
-
-    Options getOptions() {
-        return options;
-    }
-}

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

 import com.reactnativenavigation.presentation.NavigationOptionsListener;
 import com.reactnativenavigation.presentation.OverlayPresenter;
 import com.reactnativenavigation.utils.CompatUtils;
+import com.reactnativenavigation.utils.NoOpPromise;
 
 import java.util.Collection;
 import java.util.Collections;
 
 public class Navigator extends ParentController {
 
-	private final ModalStack modalStack = new ModalStack();
+    private static final NoOpPromise NO_OP = new NoOpPromise();
+    private final ModalStack modalStack = new ModalStack();
 	private ViewController root;
 	private OverlayPresenter overlayPresenter;
     private Options defaultOptions = new Options();
 		super(activity, "navigator" + CompatUtils.generateViewId());
 	}
 
-	@NonNull
+    @NonNull
 	@Override
 	protected ViewGroup createView() {
 		return new FrameLayout(getActivity());
 
 	@Override
 	public void destroy() {
-		modalStack.dismissAll(null);
+		modalStack.dismissAll(NO_OP);
 		super.destroy();
 	}
 
-	/*
-	 * Navigation methods
-	 */
-
-	void setRoot(final ViewController viewController) {
-		setRoot(viewController, null);
-	}
-
 	public void setRoot(final ViewController viewController, Promise promise) {
 		if (root != null) {
 			root.destroy();
 
 		root = viewController;
 		getView().addView(viewController.getView());
-		if (promise != null) {
-			promise.resolve(viewController.getId());
-		}
+        promise.resolve(viewController.getId());
 	}
 
     public void setDefaultOptions(Options defaultOptions) {
 		}
 	}
 
-	public void push(final String fromId, final ViewController viewController) {
-		push(fromId, viewController, null);
-	}
-
 	public void push(final String fromId, final ViewController viewController, Promise promise) {
 		ViewController from = findControllerById(fromId);
 		if (from != null) {
-		    from.performOnParentStack(stack -> stack.push(viewController, promise));
+		    from.performOnParentStack(stack -> stack.animatePush(viewController, promise));
 		}
 	}
 
-	void pop(final String fromId) {
-		pop(fromId, null);
-	}
-
 	void pop(final String fromId, Promise promise) {
 		ViewController from = findControllerById(fromId);
 		if (from != null) {
 		}
 	}
 
-	void popSpecific(final String id) {
-		popSpecific(id, null);
-	}
-
 	public void popSpecific(final String id, Promise promise) {
 		ViewController from = findControllerById(id);
 		if (from != null) {
 		}
 	}
 
-	void popToRoot(final String id) {
-		popToRoot(id, null);
-	}
-
 	public void popToRoot(final String id, Promise promise) {
 		ViewController from = findControllerById(id);
 		if (from != null) {
 		}
 	}
 
-	void popTo(final String componentId) {
-		popTo(componentId, null);
-	}
-
 	public void popTo(final String componentId, Promise promise) {
 		ViewController target = findControllerById(componentId);
 		if (target != null) {
 	}
 
 	static void rejectPromise(Promise promise) {
-		if (promise != null) {
-			promise.reject(new Throwable("Nothing to pop"));
-		}
+        promise.reject(new Throwable("Nothing to pop"));
 	}
 
     @Nullable

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

 import android.support.annotation.Nullable;
 import android.view.ViewGroup;
 
+import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.views.ReactComponent;
+
 import java.util.Collection;
 
-public abstract class ParentController extends ViewController {
+public abstract class ParentController<T extends ViewGroup> extends ViewController {
 
 	public ParentController(final Activity activity, final String id) {
 		super(activity, id);
 
 	@NonNull
 	@Override
-	public ViewGroup getView() {
-		return (ViewGroup) super.getView();
+	public T getView() {
+		return (T) super.getView();
 	}
 
 	@NonNull
 	@Override
-	protected abstract ViewGroup createView();
+	protected abstract T createView();
 
-	@NonNull
+    @NonNull
 	public abstract Collection<? extends ViewController> getChildControllers();
 
 	@Nullable
 		return null;
 	}
 
+    public void applyOptions(Options options, ReactComponent childComponent) {
+
+    }
+
 	@Override
 	public void destroy() {
 		super.destroy();
 			child.destroy();
 		}
 	}
+
+    void clearOptions() {
+
+    }
 }

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

 
 import android.app.Activity;
 import android.support.annotation.NonNull;
+import android.support.annotation.RestrictTo;
 import android.view.View;
-import android.view.ViewGroup;
-import android.widget.FrameLayout;
 
 import com.facebook.react.bridge.Promise;
 import com.reactnativenavigation.anim.NavigationAnimator;
+import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.utils.NoOpPromise;
+import com.reactnativenavigation.views.ReactComponent;
+import com.reactnativenavigation.views.StackLayout;
+import com.reactnativenavigation.views.TopBar;
 
 import java.util.Collection;
 import java.util.Iterator;
 
-public class StackController extends ParentController {
+public class StackController extends ParentController <StackLayout> {
 
-	private final IdStack<ViewController> stack = new IdStack<>();
-	private final NavigationAnimator animator;
+    private static final NoOpPromise NO_OP = new NoOpPromise();
+    private final IdStack<ViewController> stack = new IdStack<>();
+    private final NavigationAnimator animator;
+    private StackLayout stackLayout;
 
-	public StackController(final Activity activity, String id) {
-		this(activity, id, new NavigationAnimator(activity));
-	}
-
-	public StackController(final Activity activity, String id, NavigationAnimator animator) {
+    public StackController(final Activity activity, String id) {
 		super(activity, id);
-		this.animator = animator;
-	}
+        animator = new NavigationAnimator(activity);
+    }
+
+    @RestrictTo(RestrictTo.Scope.TESTS)
+    TopBar getTopBar() {
+        return stackLayout.getTopBar();
+    }
 
-	public void push(final ViewController child, final Promise promise) {
-		final ViewController previousTop = peek();
+    @Override
+    public void applyOptions(Options options, ReactComponent component) {
+        stackLayout.applyOptions(options, component);
+    }
+
+    @Override
+    void clearOptions() {
+        stackLayout.clearOptions();
+    }
+
+    public void animatePush(final ViewController child, final Promise promise) {
+		final ViewController toRemove = stack.peek();
 
 		child.setParentController(this);
 		stack.push(child.getId(), child);
 		View enteringView = child.getView();
 		getView().addView(enteringView);
 
-		if (previousTop != null) {
-			animator.animatePush(enteringView, () -> {
-                getView().removeView(previousTop.getView());
-                if (promise != null) {
-                    promise.resolve(child.getId());
-                }
+		if (toRemove != null) {
+            animator.animatePush(enteringView, () -> {
+                getView().removeView(toRemove.getView());
+                promise.resolve(child.getId());
             });
-		} else if (promise != null) {
+		} else {
 			promise.resolve(child.getId());
 		}
 	}
 
-	boolean canPop() {
-		return stack.size() > 1;
-	}
+    public void pop(final Promise promise) {
+        if (!canPop()) {
+            Navigator.rejectPromise(promise);
+            return;
+        }
 
-	void pop(Promise promise) {
-		pop(true, promise);
-	}
+        final ViewController poppedTop = stack.pop();
+        ViewController newTop = stack.peek();
+
+        View enteringView = newTop.getView();
+        final View exitingView = poppedTop.getView();
+        getView().addView(enteringView, getView().getChildCount() - 1);
 
-	private void pop(boolean animate, final Promise promise) {
+        finishPopping(exitingView, poppedTop, promise);
+    }
+
+	public void animatePop(final Promise promise) {
 		if (!canPop()) {
 			Navigator.rejectPromise(promise);
 			return;
 		}
 
 		final ViewController poppedTop = stack.pop();
-		ViewController newTop = peek();
+		ViewController newTop = stack.peek();
 
 		View enteringView = newTop.getView();
 		final View exitingView = poppedTop.getView();
 		getView().addView(enteringView, getView().getChildCount() - 1);
 
-		if (animate) {
-			animator.animatePop(exitingView, () -> finishPopping(exitingView, poppedTop, promise));
-		} else {
-			finishPopping(exitingView, poppedTop, promise);
-		}
+        animator.animatePop(exitingView, () -> finishPopping(exitingView, poppedTop, promise));
 	}
 
+    boolean canPop() {
+        return stack.size() > 1;
+    }
+
 	private void finishPopping(View exitingView, ViewController poppedTop, Promise promise) {
 		getView().removeView(exitingView);
 		poppedTop.destroy();
-		if (promise != null) {
-			promise.resolve(poppedTop.getId());
-		}
-	}
-
-	void popSpecific(final ViewController childController) {
-		popSpecific(childController, null);
+        promise.resolve(poppedTop.getId());
 	}
 
 	void popSpecific(final ViewController childController, Promise promise) {
 		if (stack.isTop(childController.getId())) {
-			pop(promise);
+			animatePop(promise);
 		} else {
 			stack.remove(childController.getId());
 			childController.destroy();
-			if (promise != null) {
-				promise.resolve(childController.getId());
-			}
+            promise.resolve(childController.getId());
 		}
 	}
 
-	void popTo(ViewController viewController) {
-		popTo(viewController, null);
-	}
-
 	void popTo(final ViewController viewController, Promise promise) {
 		if (!stack.containsId(viewController.getId())) {
 			Navigator.rejectPromise(promise);
 		while (!viewController.getId().equals(currentControlId)) {
 			String nextControlId = iterator.next();
 			boolean animate = nextControlId.equals(viewController.getId());
-			pop(animate, animate ? promise : null);
+			if (animate) {
+			    animatePop(promise);
+            } else {
+			    pop(NO_OP);
+            }
 			currentControlId = nextControlId;
 		}
 	}
 
-	void popToRoot() {
-		popToRoot(null);
-	}
-
 	void popToRoot(Promise promise) {
 		while (canPop()) {
-			boolean animate = stack.size() == 2; //first element is root
-			pop(animate, animate ? promise : null);
+			boolean animate = stack.size() == 2; // First element is root
+            if (animate) {
+                animatePop(promise);
+            } else {
+                pop(NO_OP);
+            }
 		}
 	}
 
 	@Override
 	public boolean handleBack() {
 		if (canPop()) {
-			pop(null);
+			animatePop(NO_OP);
 			return true;
-		} else {
-			return false;
 		}
+        return false;
 	}
 
-	@NonNull
-	@Override
-	protected ViewGroup createView() {
-		return new FrameLayout(getActivity());
-	}
+    @NonNull
+    @Override
+    protected StackLayout createView() {
+        stackLayout = new StackLayout(getActivity());
+        return stackLayout;
+    }
 
 	@NonNull
 	@Override

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

 
 public abstract class ViewController implements ViewTreeObserver.OnGlobalLayoutListener {
 
+    public Options options;
+
 	private final Activity activity;
 	private final String id;
-
 	private View view;
 	private ParentController parentController;
 	private boolean isShown = false;
-
     private boolean isDestroyed;
 
 	public ViewController(Activity activity, String id) {
 
 	protected abstract View createView();
 
-	@VisibleForTesting(otherwise = VisibleForTesting.PACKAGE_PRIVATE)
+	@SuppressWarnings("WeakerAccess")
+    @VisibleForTesting(otherwise = VisibleForTesting.PACKAGE_PRIVATE)
 	public void ensureViewIsCreated() {
 		getView();
 	}
 		return false;
 	}
 
+    public void applyOptions(Options options) {
+
+    }
+
 	public Activity getActivity() {
 		return activity;
 	}
 
-    protected ViewController getParentController() {
-	    return parentController;
+	protected void applyOnParentStack(Task<ParentController> task) {
+        if (parentController != null) {
+            task.run(parentController);
+        }
     }
 
 	@Nullable
 
 	public void onViewDisappear() {
         isShown = false;
-    }
-
-    public void applyOptions(Options options) {
-
     }
 
 	public void destroy() {

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/toptabs/TopTabController.java

 
     private final String componentName;
     private ComponentViewController.ReactViewCreator viewCreator;
-    private final Options options;
     private TopTab topTab;
     private boolean isSelectedTab;
 
 
     @Override
     public void applyOptions(Options options) {
-        getParentController().applyOptions(options);
+        applyOnParentStack(parentController -> parentController.applyOptions(options));
     }
 
     @Override
     }
 
     String getTabTitle() {
-        return options.topTabOptions.title;
+        return options.topTabOptions.title.get("");
     }
 
     public void setTabIndex(int i) {

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/toptabs/TopTabsAdapter.java

 import android.view.View;
 import android.view.ViewGroup;
 
+import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.viewcontrollers.ViewController;
+
 import java.util.List;
 
 public class TopTabsAdapter extends PagerAdapter implements ViewPager.OnPageChangeListener {
-    private List<TopTabController> tabs;
+    private List<ViewController> tabs;
     private int currentPage = 0;
 
-    public TopTabsAdapter(List<TopTabController> tabs) {
+    public TopTabsAdapter(List<ViewController> tabs) {
         this.tabs = tabs;
     }
 
     @Override
     public CharSequence getPageTitle(int position) {
-        return tabs.get(position).getTabTitle();
+        return getTabOptions(position).topTabOptions.title.get("");
     }
 
     @Override
 
     }
 
-    int getCurrentItem() {
-        return currentPage;
+    private Options getTabOptions(int position) {
+        return tabs.get(position).options;
     }
 }

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/toptabs/TopTabsController.java

 
 public class TopTabsController extends ParentController implements NavigationOptionsListener {
 
-    private List<TopTabController> tabs;
+    private List<ViewController> tabs;
     private TopTabsLayout topTabsLayout;
     private TopTabsLayoutCreator viewCreator;
     private Options options;
 
-    public TopTabsController(Activity activity, String id, List<TopTabController> tabs, TopTabsLayoutCreator viewCreator, Options options) {
+    public TopTabsController(Activity activity, String id, List<ViewController> tabs, TopTabsLayoutCreator viewCreator, Options options) {
         super(activity, id);
         this.viewCreator = viewCreator;
         this.options = options;
     @Override
     public void onViewAppeared() {
         applyOptions(options);
-        performOnCurrentTab(TopTabController::onViewAppeared);
+        performOnCurrentTab(ViewController::onViewAppeared);
     }
 
     @Override
     public void onViewDisappear() {
-        performOnCurrentTab(TopTabController::onViewDisappear);
+        performOnCurrentTab(ViewController::onViewDisappear);
     }
 
     @Override
         topTabsLayout.switchToTab(index);
     }
 
-    private void performOnCurrentTab(Task<TopTabController> task) {
+    private void performOnCurrentTab(Task<ViewController> task) {
         task.run(tabs.get(topTabsLayout.getCurrentItem()));
     }
 }

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

 @SuppressLint("ViewConstructor")
 public class TopTabsViewPager extends ViewPager {
     private static final int OFFSCREEN_PAGE_LIMIT = 99;
-    private List<TopTabController> tabs;
+    private List<ViewController> tabs;
 
-    public TopTabsViewPager(Context context, List<TopTabController> tabs, TopTabsAdapter adapter) {
+    public TopTabsViewPager(Context context, List<ViewController> tabs, TopTabsAdapter adapter) {
         super(context);
         this.tabs = tabs;
         init(adapter);

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

 public interface Component {
     void applyOptions(Options options);
 
-    TopBar getTopBar();
-
     void drawBehindTopBar();
 
-    void drawBelowTopBar();
+    void drawBelowTopBar(TopBar topBar);
 }

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

 import android.annotation.SuppressLint;
 import android.content.Context;
 import android.view.View;
+import android.widget.FrameLayout;
 import android.widget.RelativeLayout;
 
 import com.reactnativenavigation.interfaces.ScrollEventListener;
 import com.reactnativenavigation.parse.Options;
-import com.reactnativenavigation.presentation.OptionsPresenter;
 import com.reactnativenavigation.viewcontrollers.ComponentViewController.IReactView;
 
 import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
-import static android.view.ViewGroup.LayoutParams.WRAP_CONTENT;
+import static android.widget.RelativeLayout.BELOW;
 
 @SuppressLint("ViewConstructor")
-public class ComponentLayout extends RelativeLayout implements ReactComponent, TitleBarButton.OnClickListener {
+public class ComponentLayout extends FrameLayout implements ReactComponent, TitleBarButton.OnClickListener {
 
-    private TopBar topBar;
     private IReactView reactView;
-    private final OptionsPresenter optionsPresenter;
 
 	public ComponentLayout(Context context, IReactView reactView) {
 		super(context);
 		this.reactView = reactView;
-		this.topBar = new TopBar(context, reactView.asView(), reactView.getScrollEventListener(), this);
-        optionsPresenter = new OptionsPresenter(this);
-        initViews();
-    }
-
-    private void initViews() {
-        LayoutParams layoutParams = new LayoutParams(MATCH_PARENT, MATCH_PARENT);
-        layoutParams.addRule(BELOW, topBar.getId());
-        addView(reactView.asView(), layoutParams);
-        addView(topBar, new LayoutParams(MATCH_PARENT, WRAP_CONTENT));
+        addView(reactView.asView(), MATCH_PARENT, MATCH_PARENT);
     }
 
     @Override
 
     @Override
     public void applyOptions(Options options) {
-        optionsPresenter.applyOptions(options);
+
     }
 
     @Override
         return reactView.getScrollEventListener();
     }
 
-    @Override
-    public TopBar getTopBar() {
-        return topBar;
-    }
-
     @Override
     public void drawBehindTopBar() {
         RelativeLayout.LayoutParams layoutParams = (RelativeLayout.LayoutParams) reactView.asView().getLayoutParams();
     }
 
     @Override
-    public void drawBelowTopBar() {
+    public void drawBelowTopBar(TopBar topBar) {
         RelativeLayout.LayoutParams layoutParams = (RelativeLayout.LayoutParams) reactView.asView().getLayoutParams();
         layoutParams.addRule(BELOW, topBar.getId());
         reactView.asView().setLayoutParams(layoutParams);

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

+package com.reactnativenavigation.views;
+
+import android.content.Context;
+import android.support.annotation.RestrictTo;
+import android.widget.RelativeLayout;
+
+import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.presentation.OptionsPresenter;
+import com.reactnativenavigation.utils.CompatUtils;
+
+import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
+import static android.view.ViewGroup.LayoutParams.WRAP_CONTENT;
+
+public class StackLayout extends RelativeLayout implements TitleBarButton.OnClickListener {
+
+    private final TopBar topBar;
+
+    public StackLayout(Context context) {
+        super(context);
+        topBar = new TopBar(context, this);
+        topBar.setId(CompatUtils.generateViewId());
+        createLayout();
+    }
+
+    void createLayout() {
+        addView(topBar, MATCH_PARENT, WRAP_CONTENT);
+    }
+
+    @Override
+    public void onPress(String buttonId) {
+
+    }
+
+    public void applyOptions(Options options, ReactComponent component) {
+        new OptionsPresenter(topBar, component).applyOptions(options);
+    }
+
+    @RestrictTo(RestrictTo.Scope.TESTS)
+    public TopBar getTopBar() {
+        return topBar;
+    }
+
+    public void clearOptions() {
+        topBar.clear();
+    }
+}

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

 	}
 
 	void addToMenu(Context context, final Menu menu) {
-		MenuItem menuItem = menu.add(button.title);
+		MenuItem menuItem = menu.add(button.title.get(""));
 		menuItem.setShowAsAction(button.showAsAction);
 		menuItem.setEnabled(button.disabled != Options.BooleanOptions.True);
 		menuItem.setOnMenuItemClickListener(this);
 			return;
 		}
 
-		ImageUtils.tryLoadIcon(context, button.icon, new ImageUtils.ImageLoadingListener() {
+		ImageUtils.tryLoadIcon(context, button.icon.get(), new ImageUtils.ImageLoadingListener() {
 			@Override
 			public void onComplete(@NonNull Drawable drawable) {
 				icon = drawable;
 	}
 
 	private void applyIcon(Context context, final MenuItem menuItem) {
-		ImageUtils.tryLoadIcon(context, button.icon, new ImageUtils.ImageLoadingListener() {
+		ImageUtils.tryLoadIcon(context, button.icon.get(), new ImageUtils.ImageLoadingListener() {
 			@Override
 			public void onComplete(@NonNull Drawable drawable) {
 				icon = drawable;
 	}
 
 	private void setFontSize(MenuItem menuItem) {
-		SpannableString spanString = new SpannableString(button.title);
-		spanString.setSpan(new AbsoluteSizeSpan(button.buttonFontSize, true), 0, button.title.length(), Spannable.SPAN_INCLUSIVE_INCLUSIVE);
+		SpannableString spanString = new SpannableString(button.title.get());
+		spanString.setSpan(new AbsoluteSizeSpan(button.buttonFontSize, true), 0, button.title.get().length(), Spannable.SPAN_INCLUSIVE_INCLUSIVE);
 		menuItem.setTitleCondensed(spanString);
 	}
 
 	@NonNull
 	private ArrayList<View> findActualTextViewInMenuByLabel() {
 		ArrayList<View> outViews = new ArrayList<>();
-		this.toolbar.findViewsWithText(outViews, button.title, View.FIND_VIEWS_WITH_TEXT);
+		this.toolbar.findViewsWithText(outViews, button.title.get(), View.FIND_VIEWS_WITH_TEXT);
 		return outViews;
 	}
 

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

 import android.annotation.SuppressLint;
 import android.content.Context;
 import android.graphics.Typeface;
-import android.support.annotation.ColorInt;
 import android.support.annotation.Nullable;
 import android.support.design.widget.AppBarLayout;
 import android.support.v7.widget.Toolbar;
 import com.reactnativenavigation.interfaces.ScrollEventListener;
 import com.reactnativenavigation.parse.Button;
 import com.reactnativenavigation.parse.Color;
+import com.reactnativenavigation.parse.Fraction;
 import com.reactnativenavigation.parse.Number;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.viewcontrollers.toptabs.TopTabsViewPager;
     private final TopBarAnimator animator;
     private TopTabs topTabs;
 
-    public TopBar(final Context context, View contentView, ScrollEventListener scrollEventListener, TitleBarButton.OnClickListener onClickListener) {
+    public TopBar(final Context context, TitleBarButton.OnClickListener onClickListener) {
         super(context);
         this.onClickListener = onClickListener;
-        collapsingBehavior = new TopBarCollapseBehavior(this, scrollEventListener);
+        collapsingBehavior = new TopBarCollapseBehavior(this);
         titleBar = new Toolbar(context);
         topTabs = new TopTabs(getContext());
-        this.animator = new TopBarAnimator(this, contentView);
+        this.animator = new TopBarAnimator(this);
         addView(titleBar);
     }
 
         return titleBar.getTitle() != null ? titleBar.getTitle().toString() : "";
     }
 
-    public void setTitleTextColor(@ColorInt int color) {
-        titleBar.setTitleTextColor(color);
+    public void setTitleTextColor(Color color) {
+        if (color.hasValue()) titleBar.setTitleTextColor(color.get());
     }
 
-    public void setTitleFontSize(float size) {
+    public void setTitleFontSize(Fraction size) {
         TextView titleTextView = getTitleTextView();
-        if (titleTextView != null) {
-            titleTextView.setTextSize(size);
+        if (titleTextView != null && size.hasValue()) {
+            titleTextView.setTextSize(size.get());
         }
     }
 
         return findTextView(titleBar);
     }
 
-    @Override
-    public void setBackgroundColor(@ColorInt int color) {
-        titleBar.setBackgroundColor(color);
+    public void setBackgroundColor(Color color) {
+        if (color.hasValue()) titleBar.setBackgroundColor(color.get());
     }
 
     @Nullable
     private TextView findTextView(ViewGroup root) {
         for (int i = 0; i < root.getChildCount(); i++) {
             View view = root.getChildAt(i);
+            if (view instanceof ViewGroup) {
+                view = findTextView((ViewGroup) view);
+            }
             if (view instanceof TextView) {
                 return (TextView) view;
             }
-            if (view instanceof ViewGroup) {
-                return findTextView((ViewGroup) view);
-            }
         }
         return null;
     }
 
     private void setLeftButtons(ArrayList<Button> leftButtons) {
-        if (leftButtons == null || leftButtons.isEmpty()) {
+        if (leftButtons == null) return;
+        if (leftButtons.isEmpty()) {
             titleBar.setNavigationIcon(null);
             return;
         }
             setVisibility(View.GONE);
         }
     }
+
+    public void clear() {
+        titleBar.setTitle(null);
+        titleBar.setNavigationIcon(null);
+        titleBar.getMenu().clear();
+    }
 }

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

 package com.reactnativenavigation.views;
 
-import android.annotation.*;
-import android.content.*;
-import android.support.annotation.*;
-import android.support.v4.view.*;
-import android.view.*;
-import android.widget.*;
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.support.annotation.RestrictTo;
+import android.support.v4.view.ViewPager;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.RelativeLayout;
 
-import com.reactnativenavigation.parse.*;
-import com.reactnativenavigation.presentation.*;
-import com.reactnativenavigation.utils.*;
-import com.reactnativenavigation.viewcontrollers.toptabs.*;
+import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.viewcontrollers.ViewController;
+import com.reactnativenavigation.viewcontrollers.toptabs.TopTabsAdapter;
+import com.reactnativenavigation.viewcontrollers.toptabs.TopTabsViewPager;
 
-import java.util.*;
+import java.util.List;
 
 @SuppressLint("ViewConstructor")
 public class TopTabsLayout extends RelativeLayout implements Component, TitleBarButton.OnClickListener {
 
     private TopBar topBar;
-    private List<TopTabController> tabs;
     private TopTabsViewPager viewPager;
-    private final OptionsPresenter optionsPresenter;
 
-    public TopTabsLayout(Context context, List<TopTabController> tabs, TopTabsAdapter adapter) {
+    public TopTabsLayout(Context context, List<ViewController> tabs, TopTabsAdapter adapter) {
         super(context);
-        this.tabs = tabs;
         viewPager = new TopTabsViewPager(context, tabs, adapter);
-        topBar = new TopBar(context, viewPager, null, this);
+        topBar = new TopBar(context, this);
         topBar.setId(View.generateViewId());
-        optionsPresenter = new OptionsPresenter(this);
+
         initViews();
     }
 
 
     @Override
     public void applyOptions(Options options) {
-        optionsPresenter.applyOptions(options);
-    }
 
-    @Override
-    public TopBar getTopBar() {
-        return topBar;
     }
 
     @Override
     }
 
     @Override
-    public void drawBelowTopBar() {
+    public void drawBelowTopBar(TopBar topBar) {
 
     }
 
         return viewPager;
     }
 
-
-    public void performOnCurrentTab(Task<TopTabController> task) {
-        task.run(tabs.get(viewPager.getCurrentItem()));
-    }
-
     public void switchToTab(int index) {
         viewPager.setCurrentItem(index);
     }

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

 
 import android.content.Context;
 
-import com.reactnativenavigation.viewcontrollers.toptabs.TopTabController;
+import com.reactnativenavigation.viewcontrollers.ViewController;
 import com.reactnativenavigation.viewcontrollers.toptabs.TopTabsAdapter;
 
 import java.util.List;
 
 public class TopTabsLayoutCreator {
     private Context context;
-    private List<TopTabController> tabs;
+    private List<ViewController> tabs;
 
-    public TopTabsLayoutCreator(Context context, List<TopTabController> tabs) {
+    public TopTabsLayoutCreator(Context context, List<ViewController> tabs) {
         this.context = context;
         this.tabs = tabs;
     }

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

 package com.reactnativenavigation.mocks;
 
-import android.content.*;
-import android.view.*;
-import android.widget.*;
+import android.content.Context;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.RelativeLayout;
 
 import com.reactnativenavigation.interfaces.ScrollEventListener;
-import com.reactnativenavigation.parse.*;
-import com.reactnativenavigation.presentation.*;
-import com.reactnativenavigation.views.*;
+import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.views.ReactComponent;
+import com.reactnativenavigation.views.TitleBarButton;
+import com.reactnativenavigation.views.TopBar;
 
 public class TestComponentLayout extends RelativeLayout implements ReactComponent, TitleBarButton.OnClickListener {
 
-    private final TopBar topBar;
     private final View contentView;
-    private final OptionsPresenter optionsPresenter;
 
     public TestComponentLayout(final Context context) {
         super(context);
         contentView = new View(context);
-        topBar = new TopBar(context, contentView, null, this);
-        addView(topBar);
         addView(contentView);
-        optionsPresenter = new OptionsPresenter(this);
-    }
-
-    public TopBar getTopBar() {
-        return topBar;
     }
 
     @Override
     }
 
     @Override
-    public void drawBelowTopBar() {
+    public void drawBelowTopBar(TopBar topBar) {
         RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT);
         layoutParams.addRule(BELOW, topBar.getId());
         contentView.setLayoutParams(layoutParams);
 
     @Override
     public void applyOptions(Options options) {
-        optionsPresenter.applyOptions(options);
+
     }
 
     @Override

lib/android/app/src/test/java/com/reactnativenavigation/parse/NavigationOptionsTest.java

     }
 
     private void assertResult(Options result) {
-        assertThat(result.topBarOptions.title).isEqualTo(TITLE);
-        assertThat(result.topBarOptions.backgroundColor).isEqualTo(TOP_BAR_BACKGROUND_COLOR);
-        assertThat(result.topBarOptions.textColor).isEqualTo(TOP_BAR_TEXT_COLOR);
-        assertThat(result.topBarOptions.textFontSize).isEqualTo(TOP_BAR_FONT_SIZE);
+        assertThat(result.topBarOptions.title.get()).isEqualTo(TITLE);
+        assertThat(result.topBarOptions.backgroundColor.get()).isEqualTo(TOP_BAR_BACKGROUND_COLOR);
+        assertThat(result.topBarOptions.textColor.get()).isEqualTo(TOP_BAR_TEXT_COLOR);
+        assertThat(result.topBarOptions.textFontSize.get()).isEqualTo(TOP_BAR_FONT_SIZE);
         assertThat(result.topBarOptions.textFontFamily).isEqualTo(TOP_BAR_TYPEFACE);
         assertThat(result.topBarOptions.hidden).isEqualTo(TOP_BAR_HIDDEN);
         assertThat(result.topBarOptions.drawBehind).isEqualTo(TOP_BAR_DRAW_BEHIND);
         assertThat(result.bottomTabsOptions.animateHide).isEqualTo(BOTTOM_TABS_ANIMATE_HIDE);
         assertThat(result.bottomTabsOptions.hidden).isEqualTo(BOTTOM_TABS_HIDDEN);
         assertThat(result.bottomTabsOptions.tabBadge).isEqualTo(BOTTOM_TABS_BADGE);
-        assertThat(result.bottomTabsOptions.currentTabId).isEqualTo(BOTTOM_TABS_CURRENT_TAB_ID);
+        assertThat(result.bottomTabsOptions.currentTabId.get()).isEqualTo(BOTTOM_TABS_CURRENT_TAB_ID);
         assertThat(result.bottomTabsOptions.currentTabIndex).isEqualTo(BOTTOM_TABS_CURRENT_TAB_INDEX);
     }
 
     @NonNull
     private JSONObject createTopBar() throws JSONException {
         return new JSONObject()
-                .put("title", TITLE)
+                .put("title", "the title")
                 .put("backgroundColor", TOP_BAR_BACKGROUND_COLOR)
                 .put("textColor", TOP_BAR_TEXT_COLOR)
                 .put("textFontSize", TOP_BAR_FONT_SIZE)
     @NonNull
     private JSONObject createOtherTopBar() throws JSONException {
         return new JSONObject()
-                .put("title", TITLE)
+                .put("title", "the title")
                 .put("backgroundColor", TOP_BAR_BACKGROUND_COLOR)
                 .put("textColor", TOP_BAR_TEXT_COLOR)
                 .put("textFontSize", TOP_BAR_FONT_SIZE)
     @Test
     public void defaultEmptyOptions() throws Exception {
         Options uut = new Options();
-        assertThat(uut.topBarOptions.title).isEmpty();
+        assertThat(uut.topBarOptions.title.get("")).isEmpty();
     }
 }

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

         assertThat(uut.findControllerById("123")).isNull();
         assertThat(uut.findControllerById(uut.getId())).isEqualTo(uut);
         StackController inner = new StackController(activity, "inner");
-        inner.push(child1, new MockPromise());
+        inner.animatePush(child1, new MockPromise());
         assertThat(uut.findControllerById(child1.getId())).isNull();
         uut.setTabs(Collections.singletonList(inner));
         assertThat(uut.findControllerById(child1.getId())).isEqualTo(child1);

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

 package com.reactnativenavigation.viewcontrollers;
 
-import android.app.*;
+import android.app.Activity;
 
-import com.reactnativenavigation.*;
-import com.reactnativenavigation.mocks.*;
-import com.reactnativenavigation.parse.*;
+import com.reactnativenavigation.BaseTest;
+import com.reactnativenavigation.mocks.TestComponentLayout;
+import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.views.StackLayout;
 
-import org.junit.*;
+import org.junit.Test;
 
-import static org.assertj.core.api.Java6Assertions.*;
-import static org.mockito.Mockito.*;
+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.when;
 
 public class ComponentViewControllerTest extends BaseTest {
     private ComponentViewController uut;
+    private ParentController<StackLayout> parentController;
     private ComponentViewController.IReactView view;
 
     @Override
         super.beforeEach();
         Activity activity = newActivity();
         view = spy(new TestComponentLayout(activity));
-        uut = new ComponentViewController(activity, "componentId1", "componentName", new ComponentViewController.ReactViewCreator() {
-            @Override
-            public ComponentViewController.IReactView create(final Activity activity1, final String componentId, final String componentName) {
-                return view;
-            }
-        }, new Options());
+        parentController = new StackController(activity, "stack");
+        uut = new ComponentViewController(activity, "componentId1", "componentName", (activity1, componentId, componentName) -> view, new Options());
+        uut.setParentController(parentController);
+        parentController.ensureViewIsCreated();
     }
 
     @Test

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

 public class NavigatorTest extends BaseTest {
     private Activity activity;
     private Navigator uut;
+    private ParentController parentController;
     private SimpleViewController child1;
     private ViewController child2;
     private ViewController child3;
         super.beforeEach();
         activity = newActivity();
         uut = new Navigator(activity);
+        parentController = new StackController(activity, "stack");
+        parentController.ensureViewIsCreated();
         child1 = new SimpleViewController(activity, "child1");
         child2 = new SimpleViewController(activity, "child2");
         child3 = new SimpleViewController(activity, "child3");
     @Test
     public void setRoot_AddsChildControllerView() throws Exception {
         assertThat(uut.getView().getChildCount()).isZero();
-        uut.setRoot(child1);
+        uut.setRoot(child1, new MockPromise());
         assertIsChildById(uut.getView(), child1.getView());
     }
 
     @Test
     public void setRoot_ReplacesExistingChildControllerViews() throws Exception {
-        uut.setRoot(child1);
-        uut.setRoot(child2);
+        uut.setRoot(child1, new MockPromise());
+        uut.setRoot(child2, new MockPromise());
         assertIsChildById(uut.getView(), child2.getView());
     }
 
     @Test
     public void push() throws Exception {
         StackController stackController = newStack();
-        stackController.push(child1, new MockPromise());
-        uut.setRoot(stackController);
+        stackController.animatePush(child1, new MockPromise());
+        uut.setRoot(stackController, new MockPromise());
 
         assertIsChildById(uut.getView(), stackController.getView());
         assertIsChildById(stackController.getView(), child1.getView());
 
-        uut.push(child1.getId(), child2);
+        uut.push(child1.getId(), child2, new MockPromise());
 
         assertIsChildById(uut.getView(), stackController.getView());
         assertIsChildById(stackController.getView(), child2.getView());
 
     @Test
     public void push_InvalidPushWithoutAStack_DoesNothing() throws Exception {
-        uut.setRoot(child1);
-        uut.push(child1.getId(), child2);
+        uut.setRoot(child1, new MockPromise());
+        uut.push(child1.getId(), child2, new MockPromise());
         assertIsChildById(uut.getView(), child1.getView());
     }
 
         BottomTabsController bottomTabsController = newTabs();
         StackController stack1 = newStack();
         StackController stack2 = newStack();
-        stack1.push(child1, new MockPromise());
-        stack2.push(child2, new MockPromise());
+        stack1.animatePush(child1, new MockPromise());
+        stack2.animatePush(child2, new MockPromise());
         bottomTabsController.setTabs(Arrays.asList(stack1, stack2));
-        uut.setRoot(bottomTabsController);
+        uut.setRoot(bottomTabsController, new MockPromise());
 
         SimpleViewController newChild = new SimpleViewController(activity, "new child");
-        uut.push(child2.getId(), newChild);
+        uut.push(child2.getId(), newChild, new MockPromise());
 
         assertThat(stack1.getChildControllers()).doesNotContain(newChild);
         assertThat(stack2.getChildControllers()).contains(newChild);
 
     @Test
     public void pop_InvalidDoesNothing() throws Exception {
-        uut.pop("123");
-        uut.setRoot(child1);
-        uut.pop(child1.getId());
+        uut.pop("123", new MockPromise());
+        uut.setRoot(child1, new MockPromise());
+        uut.pop(child1.getId(), new MockPromise());
         assertThat(uut.getChildControllers()).hasSize(1);
     }
 
         BottomTabsController bottomTabsController = newTabs();
         StackController stack1 = newStack();
         StackController stack2 = newStack();
-        stack1.push(child1, new MockPromise());
-        stack2.push(child2, new MockPromise());
-        stack2.push(child3, new MockPromise());
-        stack2.push(child4, new MockPromise());
         bottomTabsController.setTabs(Arrays.asList(stack1, stack2));
-        uut.setRoot(bottomTabsController);
-
-        uut.pop("child4");
-
-        assertThat(stack2.getChildControllers()).containsOnly(child2, child3);
+        uut.setRoot(bottomTabsController, new MockPromise());
+        stack1.animatePush(child1, new MockPromise());
+        stack2.animatePush(child2, new MockPromise());
+        stack2.animatePush(child3, new MockPromise() {
+            @Override
+            public void resolve(@Nullable Object value) {
+                stack2.animatePush(child4, new MockPromise() {
+                    @Override
+                    public void resolve(@Nullable Object value) {
+                        uut.pop("child4", new MockPromise());
+                        assertThat(stack2.getChildControllers()).containsOnly(child2, child3);
+                    }
+                });
+            }
+        });
     }
 
     @Test
         BottomTabsController bottomTabsController = newTabs();
         StackController stack1 = newStack();
         StackController stack2 = newStack();
-        stack1.push(child1, new MockPromise());
-        stack2.push(child2, new MockPromise());
-        stack2.push(child3, new MockPromise());
-        stack2.push(child4, new MockPromise());
+        stack1.animatePush(child1, new MockPromise());
+        stack2.animatePush(child2, new MockPromise());
+        stack2.animatePush(child3, new MockPromise());
+        stack2.animatePush(child4, new MockPromise());
         bottomTabsController.setTabs(Arrays.asList(stack1, stack2));
-        uut.setRoot(bottomTabsController);
+        uut.setRoot(bottomTabsController, new MockPromise());
 
-        uut.popSpecific(child2.getId());
+        uut.popSpecific(child2.getId(), new MockPromise());
 
         assertThat(stack2.getChildControllers()).containsOnly(child4, child3);
     }
         BottomTabsController bottomTabsController = newTabs();
         StackController stack1 = newStack();
         StackController stack2 = newStack();
-        stack1.push(child1, new MockPromise());
-        stack2.push(child2, new MockPromise());
-        stack2.push(child3, new MockPromise());
-        stack2.push(child4, new MockPromise());
-        stack2.push(child5, new MockPromise());
         bottomTabsController.setTabs(Arrays.asList(stack1, stack2));
-        uut.setRoot(bottomTabsController);
+        uut.setRoot(bottomTabsController, new MockPromise());
 
-        uut.popTo(child2.getId());
-
-        assertThat(stack2.getChildControllers()).containsOnly(child2);
+        stack1.animatePush(child1, new MockPromise());
+        stack2.animatePush(child2, new MockPromise());
+        stack2.animatePush(child3, new MockPromise());
+        stack2.animatePush(child4, new MockPromise());
+        stack2.animatePush(child5, new MockPromise() {
+            @Override
+            public void resolve(@Nullable Object value) {
+                uut.popTo(child2.getId(), new MockPromise());
+                assertThat(stack2.getChildControllers()).containsOnly(child2);
+            }
+        });
     }
 
     @Test
         BottomTabsController bottomTabsController = newTabs();
         StackController stack1 = newStack();
         StackController stack2 = newStack();
-        stack1.push(child1, new MockPromise());
-        stack2.push(child2, new MockPromise());
-        stack2.push(child3, new MockPromise());
-        stack2.push(child4, new MockPromise());
-        stack2.push(child5, new MockPromise());
-
         bottomTabsController.setTabs(Arrays.asList(stack1, stack2));
-        uut.setRoot(bottomTabsController);
+        uut.setRoot(bottomTabsController, new MockPromise());
 
-        uut.popToRoot(child3.getId());
+        stack1.animatePush(child1, new MockPromise());
+        stack2.animatePush(child2, new MockPromise());
+        stack2.animatePush(child3, new MockPromise());
+        stack2.animatePush(child4, new MockPromise());
+        stack2.animatePush(child5, new MockPromise() {
+            @Override
+            public void resolve(@Nullable Object value) {
+                uut.popToRoot(child3.getId(), new MockPromise());
 
-        assertThat(stack2.getChildControllers()).containsOnly(child2);
+                assertThat(stack2.getChildControllers()).containsOnly(child2);
+            }
+        });
     }
 
     @Test
     public void handleBack_DelegatesToRoot() throws Exception {
         assertThat(uut.handleBack()).isFalse();
         ViewController spy = spy(child1);
-        uut.setRoot(spy);
+        uut.setRoot(spy, new MockPromise());
         when(spy.handleBack()).thenReturn(true);
         assertThat(uut.handleBack()).isTrue();
         verify(spy, times(1)).handleBack();
     @Test
     public void setOptions_CallsApplyNavigationOptions() {
         ComponentViewController componentVc = new SimpleComponentViewController(activity, "theId");
-        uut.setRoot(componentVc);
-        assertThat(componentVc.getOptions().topBarOptions.title).isEmpty();
+        componentVc.setParentController(parentController);
+        assertThat(componentVc.getOptions().topBarOptions.title.get("")).isEmpty();
+        uut.setRoot(componentVc, new MockPromise());
 
         Options options = new Options();
-        options.topBarOptions.title = "new title";
+        options.topBarOptions.title = new Text("new title");
 
         uut.setOptions("theId", options);
-        assertThat(componentVc.getOptions().topBarOptions.title).isEqualTo("new title");
+        assertThat(componentVc.getOptions().topBarOptions.title.get()).isEqualTo("new title");
     }
 
     @Test
 
     @NonNull
     private StackController newStack() {
-        return new StackController(activity, "stack" + CompatUtils.generateViewId(), new TestNavigationAnimator());
+        return new StackController(activity, "stack" + CompatUtils.generateViewId());
     }
 
     @Test
     public void push_Promise() throws Exception {
         final StackController stackController = newStack();
-        stackController.push(child1, new MockPromise());
-        uut.setRoot(stackController);
+        stackController.animatePush(child1, new MockPromise());
+        uut.setRoot(stackController, new MockPromise());
 
         assertIsChildById(uut.getView(), stackController.getView());
         assertIsChildById(stackController.getView(), child1.getView());
 
     @Test
     public void push_InvalidPushWithoutAStack_DoesNothing_Promise() throws Exception {
-        uut.setRoot(child1);
+        uut.setRoot(child1, new MockPromise());
         uut.push(child1.getId(), child2, new MockPromise() {
             @Override
             public void reject(String code, Throwable e) {
 
     @Test
     public void pop_InvalidDoesNothing_Promise() throws Exception {
-        uut.pop("123");
-        uut.setRoot(child1);
+        uut.pop("123", new MockPromise());
+        uut.setRoot(child1, new MockPromise());
         uut.pop(child1.getId(), new MockPromise() {
             @Override
             public void reject(Throwable reason) {
         BottomTabsController bottomTabsController = newTabs();
         StackController stack1 = newStack();
         final StackController stack2 = newStack();
-        stack1.push(child1, new MockPromise());
-        stack2.push(child2, new MockPromise());
-        stack2.push(child3, new MockPromise());
-        stack2.push(child4, new MockPromise());
         bottomTabsController.setTabs(Arrays.asList(stack1, stack2));
-        uut.setRoot(bottomTabsController);
+        uut.setRoot(bottomTabsController, new MockPromise());
 
-        uut.pop("child4", new MockPromise() {
+        stack1.animatePush(child1, new MockPromise());
+        stack2.animatePush(child2, new MockPromise());
+        stack2.animatePush(child3, new MockPromise());
+        stack2.animatePush(child4, new MockPromise() {
             @Override
             public void resolve(@Nullable Object value) {
+                uut.pop("child4", new MockPromise());
                 assertThat(stack2.getChildControllers()).containsOnly(child2, child3);
             }
         });
     @Test
     public void pushIntoModal() throws Exception {
         StackController stackController = newStack();
-        stackController.push(child1, new MockPromise());
+        stackController.animatePush(child1, new MockPromise());
         uut.showModal(stackController, new MockPromise());
-        uut.push(stackController.getId(), child2);
+        uut.push(stackController.getId(), child2, new MockPromise());
         assertIsChildById(stackController.getView(), child2.getView());
     }
 }

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

 package com.reactnativenavigation.viewcontrollers;
 
-import android.app.*;
+import android.app.Activity;
 import android.graphics.Color;
-import android.graphics.drawable.*;
-import android.view.*;
-import android.widget.*;
+import android.graphics.drawable.ColorDrawable;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.RelativeLayout;
 
-import com.reactnativenavigation.*;
-import com.reactnativenavigation.mocks.*;
-import com.reactnativenavigation.parse.*;
+import com.reactnativenavigation.BaseTest;
+import com.reactnativenavigation.mocks.MockPromise;
+import com.reactnativenavigation.mocks.TestComponentLayout;
+import com.reactnativenavigation.parse.Fraction;
+import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.parse.Text;
 
-import org.junit.*;
+import org.junit.Test;
 
-import static android.widget.RelativeLayout.*;
-import static org.assertj.core.api.Java6Assertions.*;
-import static org.mockito.Mockito.*;
+import javax.annotation.Nullable;
+
+import static android.widget.RelativeLayout.BELOW;
+import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.mockito.Mockito.spy;
 
 public class OptionsApplyingTest extends BaseTest {
     private Activity activity;
+    private StackController stackController;
     private ComponentViewController uut;
     private ComponentViewController.IReactView view;
     private Options initialNavigationOptions;
                 (activity1, componentId, componentName) -> view,
                 initialNavigationOptions
         );
-        uut.ensureViewIsCreated();
+        stackController = new StackController(activity, "stack");
+        stackController.ensureViewIsCreated();
+        uut.setParentController(stackController);
     }
 
     @Test
     public void applyNavigationOptionsHandlesNoParentStack() throws Exception {
+        uut.setParentController(null);
         assertThat(uut.getParentStackController()).isNull();
         uut.onViewAppeared();
         assertThat(uut.getParentStackController()).isNull();
     @Test
     public void initialOptionsAppliedOnAppear() throws Exception {
         assertThat(uut.getOptions()).isSameAs(initialNavigationOptions);
-        initialNavigationOptions.topBarOptions.title = "the title";
+        initialNavigationOptions.topBarOptions.title = new Text("the title");
         StackController stackController = new StackController(activity, "stackId");
-        stackController.push(uut, new MockPromise());
-        assertThat(uut.getTopBar().getTitle()).isEmpty();
+        stackController.animatePush(uut, new MockPromise() {});
+        assertThat(stackController.getTopBar().getTitle()).isEmpty();
 
         uut.onViewAppeared();
-        assertThat(uut.getTopBar().getTitle()).isEqualTo("the title");
+        assertThat(stackController.getTopBar().getTitle()).isEqualTo("the title");
     }
 
     @Test
     public void mergeNavigationOptionsUpdatesCurrentOptions() throws Exception {
-        assertThat(uut.getOptions().topBarOptions.title).isEmpty();
+        uut.ensureViewIsCreated();
+        assertThat(uut.getOptions().topBarOptions.title.get("")).isEmpty();
         Options options = new Options();
-        options.topBarOptions.title = "new title";
+        options.topBarOptions.title = new Text("new title");
         uut.mergeOptions(options);
-        assertThat(uut.getOptions().topBarOptions.title).isEqualTo("new title");
+        assertThat(uut.getOptions().topBarOptions.title.get()).isEqualTo("new title");
         assertThat(uut.getOptions()).isSameAs(initialNavigationOptions);
     }
 
     @Test
     public void reappliesOptionsOnMerge() throws Exception {
         uut.onViewAppeared();
-        assertThat(uut.getTopBar().getTitle()).isEmpty();
+        assertThat(stackController.getTopBar().getTitle()).isEmpty();
 
         Options opts = new Options();
-        opts.topBarOptions.title = "the new title";
+        opts.topBarOptions.title = new Text("the new title");
         uut.mergeOptions(opts);
 
-        assertThat(uut.getTopBar().getTitle()).isEqualTo("the new title");
+        assertThat(stackController.getTopBar().getTitle()).isEqualTo("the new title");
     }
 
     @Test
     public void appliesTopBackBackgroundColor() throws Exception {
         uut.onViewAppeared();
-        //TODO: FIX TEST
-        assertThat(((ColorDrawable) uut.getTopBar().getTitleBar().getBackground()).getColor()).isNotEqualTo(Color.RED);
 
         Options opts = new Options();
-        opts.topBarOptions.backgroundColor = Color.RED;
+        opts.topBarOptions.backgroundColor = new com.reactnativenavigation.parse.Color(Color.RED);
         uut.mergeOptions(opts);
 
-        assertThat(((ColorDrawable) uut.getTopBar().getTitleBar().getBackground()).getColor()).isEqualTo(Color.RED);
+        assertThat(((ColorDrawable) stackController.getTopBar().getTitleBar().getBackground()).getColor()).isEqualTo(Color.RED);
     }
 
     @Test
     public void appliesTopBarTextColor() throws Exception {
         assertThat(uut.getOptions()).isSameAs(initialNavigationOptions);
-        initialNavigationOptions.topBarOptions.title = "the title";
-        uut.onViewAppeared();
-        assertThat(uut.getTopBar().getTitleTextView().getCurrentTextColor()).isNotEqualTo(Color.RED);
-
-        Options opts = new Options();
-        opts.topBarOptions.title = "the title";
-        opts.topBarOptions.textColor = Color.RED;
-        uut.mergeOptions(opts);
-
-        assertThat(uut.getTopBar().getTitleTextView()).isNotEqualTo(null);
-        assertThat(uut.getTopBar().getTitleTextView().getCurrentTextColor()).isEqualTo(Color.RED);
+        initialNavigationOptions.topBarOptions.title = new Text("the title");
+        stackController.animatePush(uut, new MockPromise() {
+            @Override
+            public void resolve(@Nullable Object value) {
+                Options opts = new Options();
+                opts.topBarOptions.title = new Text("the title");
+                opts.topBarOptions.textColor = new com.reactnativenavigation.parse.Color(Color.RED);
+                uut.mergeOptions(opts);
+
+                assertThat(stackController.getTopBar().getTitleTextView()).isNotEqualTo(null);
+                assertThat(stackController.getTopBar().getTitleTextView().getCurrentTextColor()).isEqualTo(Color.RED);
+            }
+        });
     }
 
     @Test
     public void appliesTopBarTextSize() throws Exception {
         assertThat(uut.getOptions()).isSameAs(initialNavigationOptions);
-        initialNavigationOptions.topBarOptions.title = "the title";
+        initialNavigationOptions.topBarOptions.title = new Text("the title");
         uut.onViewAppeared();
-        assertThat(uut.getTopBar().getTitleTextView().getTextSize()).isNotEqualTo(18);
 
         Options opts = new Options();
-        opts.topBarOptions.title = "the title";
-        opts.topBarOptions.textFontSize = 18;
+        opts.topBarOptions.title = new Text("the title");
+        opts.topBarOptions.textFontSize = new Fraction(18);
         uut.mergeOptions(opts);
 
-        assertThat(uut.getTopBar().getTitleTextView()).isNotEqualTo(null);
-        assertThat(uut.getTopBar().getTitleTextView().getTextSize()).isEqualTo(18);
+        assertThat(stackController.getTopBar().getTitleTextView()).isNotEqualTo(null);
+        assertThat(stackController.getTopBar().getTitleTextView().getTextSize()).isEqualTo(18);
     }
 
     @Test
     public void appliesTopBarHidden() throws Exception {
         assertThat(uut.getOptions()).isSameAs(initialNavigationOptions);
-        initialNavigationOptions.topBarOptions.title = "the title";
+        initialNavigationOptions.topBarOptions.title = new Text("the title");
         uut.onViewAppeared();
-        assertThat(uut.getTopBar().getVisibility()).isNotEqualTo(View.GONE);
+        assertThat(stackController.getTopBar().getVisibility()).isNotEqualTo(View.GONE);
 
         Options opts = new Options();
         opts.topBarOptions.hidden = Options.BooleanOptions.True;
         uut.mergeOptions(opts);
 
-        assertThat(uut.getTopBar().getVisibility()).isEqualTo(View.GONE);
+        assertThat(stackController.getTopBar().getVisibility()).isEqualTo(View.GONE);
     }
 
     @Test
     public void appliesDrawUnder() throws Exception {
         assertThat(uut.getOptions()).isSameAs(initialNavigationOptions);
-        initialNavigationOptions.topBarOptions.title = "the title";
+        initialNavigationOptions.topBarOptions.title = new Text("the title");
         initialNavigationOptions.topBarOptions.drawBehind = Options.BooleanOptions.False;
         uut.onViewAppeared();
-        RelativeLayout.LayoutParams uutLayoutParams = (RelativeLayout.LayoutParams) ((ViewGroup) uut.getComponent().asView()).getChildAt(1).getLayoutParams();
-        assertThat(uutLayoutParams.getRule(BELOW)).isNotEqualTo(0);
-
-        Options opts = new Options();
-        opts.topBarOptions.drawBehind = Options.BooleanOptions.True;
-        uut.mergeOptions(opts);
-
-        uutLayoutParams = (RelativeLayout.LayoutParams) ((ViewGroup) uut.getComponent().asView()).getChildAt(1).getLayoutParams();
-        assertThat(uutLayoutParams.getRule(BELOW)).isEqualTo(0);
+        stackController.animatePush(uut, new MockPromise() {
+            @Override
+            public void resolve(@Nullable Object value) {
+                RelativeLayout.LayoutParams uutLayoutParams = (RelativeLayout.LayoutParams) ((ViewGroup) uut.getComponent().asView()).getChildAt(0).getLayoutParams();
+                assertThat(uutLayoutParams.getRule(BELOW)).isNotEqualTo(0);
+
+                Options opts = new Options();
+                opts.topBarOptions.drawBehind = Options.BooleanOptions.True;
+                uut.mergeOptions(opts);
+
+                uutLayoutParams = (RelativeLayout.LayoutParams) (uut.getComponent().asView()).getLayoutParams();
+                assertThat(uutLayoutParams.getRule(BELOW)).isNotEqualTo(stackController.getTopBar().getId());
+            }
+        });
     }
 }

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

 
     @Test
     public void findControllerById_Recursive() throws Exception {
-        StackController stackController = new StackController(activity, "stack", new TestNavigationAnimator());
+        StackController stackController = new StackController(activity, "stack");
         SimpleViewController child1 = new SimpleViewController(activity, "child1");
         SimpleViewController child2 = new SimpleViewController(activity, "child2");
-        stackController.push(child1, new MockPromise());
-        stackController.push(child2, new MockPromise());
+        stackController.animatePush(child1, new MockPromise());
+        stackController.animatePush(child2, new MockPromise());
         children.add(stackController);
 
         assertThat(uut.findControllerById("child2")).isEqualTo(child2);

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

 import org.assertj.core.api.iterable.*;
 import org.junit.*;
 
+import javax.annotation.Nullable;
+
 import static org.assertj.core.api.Java6Assertions.*;
 import static org.mockito.Mockito.*;
 
     public void beforeEach() {
         super.beforeEach();
         activity = newActivity();
-        uut = new StackController(activity, "uut", new TestNavigationAnimator());
+        uut = new StackController(activity, "uut");
         child1 = new SimpleViewController(activity, "child1");
         child2 = new SimpleViewController(activity, "child2");
         child3 = new SimpleViewController(activity, "child3");
     @Test
     public void holdsAStackOfViewControllers() throws Exception {
         assertThat(uut.isEmpty()).isTrue();
-        uut.push(child1, new MockPromise());
-        uut.push(child2, new MockPromise());
-        uut.push(child3, new MockPromise());
+        uut.animatePush(child1, new MockPromise());
+        uut.animatePush(child2, new MockPromise());
+        uut.animatePush(child3, new MockPromise());
         assertThat(uut.peek()).isEqualTo(child3);
         assertContainsOnlyId(child1.getId(), child2.getId(), child3.getId());
     }
     @Test
     public void push() throws Exception {
         assertThat(uut.isEmpty()).isTrue();
-        uut.push(child1, new MockPromise());
+        uut.animatePush(child1, new MockPromise());
         assertContainsOnlyId(child1.getId());
     }
 
     @Test
     public void pop() throws Exception {
-        uut.push(child1, new MockPromise());
-        uut.push(child2, new MockPromise());
-        assertContainsOnlyId(child2.getId(), child1.getId());
-        uut.pop(new MockPromise());
-        assertContainsOnlyId(child1.getId());
+        uut.animatePush(child1, new MockPromise());
+        uut.animatePush(child2, new MockPromise() {
+            @Override
+            public void resolve(@Nullable Object value) {
+                assertContainsOnlyId(child2.getId(), child1.getId());
+                uut.pop(new MockPromise());
+                assertContainsOnlyId(child1.getId());
+            }
+        });
     }
 
     @Test
         assertThat(uut.peek()).isNull();
         assertThat(uut.size()).isZero();
         assertThat(uut.isEmpty()).isTrue();
-        uut.push(child1, new MockPromise());
+        uut.animatePush(child1, new MockPromise());
         assertThat(uut.peek()).isEqualTo(child1);
         assertThat(uut.size()).isEqualTo(1);
         assertThat(uut.isEmpty()).isFalse();
     @Test
     public void pushAssignsRefToSelfOnPushedController() throws Exception {
         assertThat(child1.getParentStackController()).isNull();
-        uut.push(child1, new MockPromise());
+        uut.animatePush(child1, new MockPromise());
         assertThat(child1.getParentStackController()).isEqualTo(uut);
 
-        StackController anotherNavController = new StackController(activity, "another", new TestNavigationAnimator());
-        anotherNavController.push(child2, new MockPromise());
+        StackController anotherNavController = new StackController(activity, "another");
+        anotherNavController.animatePush(child2, new MockPromise());
         assertThat(child2.getParentStackController()).isEqualTo(anotherNavController);
     }
 
         assertThat(uut.isEmpty()).isTrue();
         assertThat(uut.handleBack()).isFalse();
 
-        uut.push(child1, new MockPromise());
+        uut.animatePush(child1, new MockPromise());
         assertThat(uut.size()).isEqualTo(1);
         assertThat(uut.handleBack()).isFalse();
 
-        uut.push(child2, new MockPromise());
-        assertThat(uut.size()).isEqualTo(2);
-        assertThat(uut.handleBack()).isTrue();
-        assertThat(uut.size()).isEqualTo(1);
-        assertThat(uut.handleBack()).isFalse();
+        uut.animatePush(child2, new MockPromise() {
+            @Override
+            public void resolve(@Nullable Object value) {
+                assertThat(uut.size()).isEqualTo(2);
+                assertThat(uut.handleBack()).isTrue();
+
+                assertThat(uut.size()).isEqualTo(1);
+                assertThat(uut.handleBack()).isFalse();
+            }
+        });
     }
 
     @Test
         uut.pop(new MockPromise());
         assertThat(uut.isEmpty()).isTrue();
 
-        uut.push(child1, new MockPromise());
+        uut.animatePush(child1, new MockPromise());
         uut.pop(new MockPromise());
         assertContainsOnlyId(child1.getId());
     }
     public void canPopWhenSizeIsMoreThanOne() throws Exception {
         assertThat(uut.isEmpty()).isTrue();
         assertThat(uut.canPop()).isFalse();
-        uut.push(child1, new MockPromise());
+        uut.animatePush(child1, new MockPromise());
         assertContainsOnlyId(child1.getId());
         assertThat(uut.canPop()).isFalse();
-        uut.push(child2, new MockPromise());
+        uut.animatePush(child2, new MockPromise());
         assertContainsOnlyId(child1.getId(), child2.getId());
         assertThat(uut.canPop()).isTrue();
     }
     @Test
     public void pushAddsToViewTree() throws Exception {
         assertThat(uut.getView().findViewById(child1.getView().getId())).isNull();
-        uut.push(child1, new MockPromise());
+        uut.animatePush(child1, new MockPromise());
         assertThat(uut.getView().findViewById(child1.getView().getId())).isNotNull();
     }
 
     @Test
     public void pushRemovesPreviousFromTree() throws Exception {
         assertThat(uut.getView().findViewById(child1.getView().getId())).isNull();
-        uut.push(child1, new MockPromise());
+        uut.animatePush(child1, new MockPromise());
         assertThat(uut.getView().findViewById(child1.getView().getId())).isNotNull();
-        uut.push(child2, new MockPromise());
-        assertThat(uut.getView().findViewById(child1.getView().getId())).isNull();
-        assertThat(uut.getView().findViewById(child2.getView().getId())).isNotNull();
+        uut.animatePush(child2, new MockPromise() {
+            @Override
+            public void resolve(@Nullable Object value) {
+                assertThat(uut.getView().findViewById(child1.getView().getId())).isNull();
+                assertThat(uut.getView().findViewById(child2.getView().getId())).isNotNull();
+            }
+        });
     }
 
     @Test
     public void popReplacesViewWithPrevious() throws Exception {
-        uut.push(child1, new MockPromise());
-        uut.push(child2, new MockPromise());
         final View child2View = child2.getView();
         final View child1View = child1.getView();
-        assertIsChildById(uut.getView(), child2View);
-        assertNotChildOf(uut.getView(), child1View);
-        uut.pop(new MockPromise());
-        assertNotChildOf(uut.getView(), child2View);
-        assertIsChildById(uut.getView(), child1View);
+
+        uut.animatePush(child1, new MockPromise());
+        uut.animatePush(child2, new MockPromise() {
+            @Override
+            public void resolve(@Nullable Object value) {
+                assertIsChildById(uut.getView(), child2View);
+                assertNotChildOf(uut.getView(), child1View);
+                uut.pop(new MockPromise());
+                assertNotChildOf(uut.getView(), child2View);
+                assertIsChildById(uut.getView(), child1View);
+            }
+        });
     }
 
     @Test
     public void popSpecificWhenTopIsRegularPop() throws Exception {
-        uut.push(child1, new MockPromise());
-        uut.push(child2, new MockPromise());
-        uut.popSpecific(child2);
-        assertContainsOnlyId(child1.getId());
-        assertIsChildById(uut.getView(), child1.getView());
+        uut.animatePush(child1, new MockPromise());
+        uut.animatePush(child2, new MockPromise() {
+            @Override
+            public void resolve(@Nullable Object value) {
+                uut.popSpecific(child2, new MockPromise() {
+                    @Override
+                    public void resolve(@Nullable Object value) {
+                        assertContainsOnlyId(child1.getId());
+                        assertIsChildById(uut.getView(), child1.getView());
+                    }
+                });
+            }
+        });
     }
 
     @Test
     public void popSpecificDeepInStack() throws Exception {
-        uut.push(child1, new MockPromise());
-        uut.push(child2, new MockPromise());
+        uut.animatePush(child1, new MockPromise());
+        uut.animatePush(child2, new MockPromise());
         assertIsChildById(uut.getView(), child2.getView());
-        uut.popSpecific(child1);
+        uut.popSpecific(child1, new MockPromise());
         assertContainsOnlyId(child2.getId());
         assertIsChildById(uut.getView(), child2.getView());
     }
 
     @Test
     public void popTo_PopsTopUntilControllerIsNewTop() throws Exception {
-        uut.push(child1, new MockPromise());
-        uut.push(child2, new MockPromise());
-        uut.push(child3, new MockPromise());
-
-        assertThat(uut.size()).isEqualTo(3);
-        assertThat(uut.peek()).isEqualTo(child3);
-
-        uut.popTo(child1);
-
-        assertThat(uut.size()).isEqualTo(1);
-        assertThat(uut.peek()).isEqualTo(child1);
+        uut.animatePush(child1, new MockPromise());
+        uut.animatePush(child2, new MockPromise());
+        uut.animatePush(child3, new MockPromise() {
+            @Override
+            public void resolve(@Nullable Object value) {
+                assertThat(uut.size()).isEqualTo(3);
+                assertThat(uut.peek()).isEqualTo(child3);
+
+                uut.popTo(child1, new MockPromise());
+
+                assertThat(uut.size()).isEqualTo(1);
+                assertThat(uut.peek()).isEqualTo(child1);
+            }
+        });
     }
 
     @Test
     public void popTo_NotAChildOfThisStack_DoesNothing() throws Exception {
-        uut.push(child1, new MockPromise());
-        uut.push(child3, new MockPromise());
+        uut.animatePush(child1, new MockPromise());
+        uut.animatePush(child3, new MockPromise());
         assertThat(uut.size()).isEqualTo(2);
-        uut.popTo(child2);
+        uut.popTo(child2, new MockPromise());
         assertThat(uut.size()).isEqualTo(2);
     }
 
     @Test
     public void popToRoot_PopsEverythingAboveFirstController() throws Exception {
-        uut.push(child1, new MockPromise());
-        uut.push(child2, new MockPromise());
-        uut.push(child3, new MockPromise());
-
-        assertThat(uut.size()).isEqualTo(3);
-        assertThat(uut.peek()).isEqualTo(child3);
-
-        uut.popToRoot();
-
-        assertThat(uut.size()).isEqualTo(1);
-        assertThat(uut.peek()).isEqualTo(child1);
+        uut.animatePush(child1, new MockPromise());
+        uut.animatePush(child2, new MockPromise());
+        uut.animatePush(child3, new MockPromise() {
+            @Override
+            public void resolve(@Nullable Object value) {
+                assertThat(uut.size()).isEqualTo(3);
+                assertThat(uut.peek()).isEqualTo(child3);
+
+                uut.popToRoot(new MockPromise() {
+                    @Override
+                    public void resolve(@Nullable Object value) {
+                        assertThat(uut.size()).isEqualTo(1);
+                        assertThat(uut.peek()).isEqualTo(child1);
+                    }
+                });
+            }
+        });
     }
 
     @Test
     public void popToRoot_EmptyStackDoesNothing() throws Exception {
         assertThat(uut.isEmpty()).isTrue();
-        uut.popToRoot();
+        uut.popToRoot(new MockPromise());
         assertThat(uut.isEmpty()).isTrue();
     }
 
     public void findControllerById_ReturnsSelfOrChildrenById() throws Exception {
         assertThat(uut.findControllerById("123")).isNull();
         assertThat(uut.findControllerById(uut.getId())).isEqualTo(uut);
-        uut.push(child1, new MockPromise());
+        uut.animatePush(child1, new MockPromise());
         assertThat(uut.findControllerById(child1.getId())).isEqualTo(child1);
     }
 
     @Test
     public void findControllerById_Deeply() throws Exception {
-        StackController stack = new StackController(activity, "stack2", new TestNavigationAnimator());
-        stack.push(child2, new MockPromise());
-        uut.push(stack, new MockPromise());
+        StackController stack = new StackController(activity, "stack2");
+        stack.animatePush(child2, new MockPromise());
+        uut.animatePush(stack, new MockPromise());
         assertThat(uut.findControllerById(child2.getId())).isEqualTo(child2);
     }
 
         child1 = spy(child1);
         child2 = spy(child2);
         child3 = spy(child3);
-        uut.push(child1, new MockPromise());
-        uut.push(child2, new MockPromise());
-        uut.push(child3, new MockPromise());
-
-        verify(child3, times(0)).destroy();
-        uut.pop(new MockPromise());
-        verify(child3, times(1)).destroy();
+        uut.animatePush(child1, new MockPromise());
+        uut.animatePush(child2, new MockPromise());
+        uut.animatePush(child3, new MockPromise() {
+            @Override
+            public void resolve(@Nullable Object value) {
+                verify(child3, times(0)).destroy();
+                uut.pop(new MockPromise());
+                verify(child3, times(1)).destroy();
+            }
+        });
     }
 
     @Test
         child1 = spy(child1);
         child2 = spy(child2);
         child3 = spy(child3);
-        uut.push(child1, new MockPromise());
-        uut.push(child2, new MockPromise());
-        uut.push(child3, new MockPromise());
+        uut.animatePush(child1, new MockPromise());
+        uut.animatePush(child2, new MockPromise());
+        uut.animatePush(child3, new MockPromise());
 
         verify(child2, times(0)).destroy();
-        uut.popSpecific(child2);
+        uut.popSpecific(child2, new MockPromise());
         verify(child2, times(1)).destroy();
     }
 
         child1 = spy(child1);
         child2 = spy(child2);
         child3 = spy(child3);
-        uut.push(child1, new MockPromise());
-        uut.push(child2, new MockPromise());
-        uut.push(child3, new MockPromise());
-
-        verify(child2, times(0)).destroy();
-        verify(child3, times(0)).destroy();
-        uut.popTo(child1);
-        verify(child2, times(1)).destroy();
-        verify(child3, times(1)).destroy();
+        uut.animatePush(child1, new MockPromise());
+        uut.animatePush(child2, new MockPromise());
+        uut.animatePush(child3, new MockPromise() {
+            @Override
+            public void resolve(@Nullable Object value) {
+                verify(child2, times(0)).destroy();
+                verify(child3, times(0)).destroy();
+
+                uut.popTo(child1, new MockPromise() {
+                    @Override
+                    public void resolve(@Nullable Object value) {
+                        verify(child2, times(1)).destroy();
+                        verify(child3, times(1)).destroy();
+                    }
+                });
+            }
+        });
     }
 
     private void assertContainsOnlyId(String... ids) {

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

 
     private TopTabsController uut;
     private List<TopTabLayoutMock> tabs = new ArrayList<>(SIZE);
-    private List<TopTabController> tabControllers = new ArrayList<>(SIZE);
+    private List<ViewController> tabControllers = new ArrayList<>(SIZE);
     private List<Options> tabOptions = new ArrayList<>(SIZE);
     private Options options;
     private TopTabsLayout topTabsLayout;
         tabControllers.clear();
         tabs.clear();
         Activity activity = newActivity();
-        createTabs(activity);
+        tabControllers = createTabs(activity);
         options = new Options();
         topTabsLayout = spy(new TopTabsLayout(activity, tabControllers, new TopTabsAdapter(tabControllers)));
 
         uut = new TopTabsController(activity, "componentId", tabControllers, layoutCreator, options);
     }
 
-    private void createTabs(Activity activity) {
+    private List<ViewController> createTabs(Activity activity) {
+        List<ViewController> result = new ArrayList<>(SIZE);
+        tabOptions = new ArrayList<>();
         for (int i = 0; i < SIZE; i++) {
             TopTabLayoutMock reactView = spy(new TopTabLayoutMock(activity));
             tabs.add(reactView);
-            tabOptions.add(new Options());
-            tabControllers.add(spy(new TopTabController(activity,
+            Options options = new Options();
+            options.topTabOptions.title = new Text("Tab " + i);
+            tabOptions.add(options);
+            result.add(spy(new TopTabController(activity,
                     "idTab" + i,
                     "tab" + i,
                     (activity1, componentId, componentName) -> reactView,
-                    tabOptions.get(i))
+                    options)
             ));
         }
+        return result;
     }
 
     @Test

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

     public void holdsAReferenceToStackControllerOrNull() throws Exception {
         assertThat(uut.getParentStackController()).isNull();
         StackController nav = new StackController(activity, "stack");
-        nav.push(uut, new MockPromise());
+        nav.animatePush(uut, new MockPromise());
         assertThat(uut.getParentStackController()).isEqualTo(nav);
     }
 

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

 public class TopBarTest extends BaseTest {
     @Test
     public void title() throws Exception {
-        TopBar topBar = new TopBar(newActivity(), null, null, buttonId -> {});
+        TopBar topBar = new TopBar(newActivity(), buttonId -> {});
         assertThat(topBar.getTitle()).isEmpty();
 
         topBar.setTitle("new title");

playground/src/screens/OptionsScreen.js

   root: {
     flexGrow: 1,
     justifyContent: 'center',
-    alignItems: 'center'
+    alignItems: 'center',
+    backgroundColor: 'white'
   },
   h1: {
     fontSize: 24,

playground/src/screens/PushedScreen.js

 const testIDs = require('../testIDs');
 
 class PushedScreen extends Component {
-  static get navigationOptions() {
+  static get options() {
     return {
       topBar: {
         testID: testIDs.TOP_BAR_ELEMENT
         passProps: {
           stackPosition: this.getStackPosition() + 1,
           previousScreenIds: _.concat([], this.props.previousScreenIds || [], this.props.componentId)
+        },
+        options: {
+          topBar: {
+            title: `Pushed ${this.getStackPosition() + 1}`
+          }
         }
       }
     });

playground/src/screens/WelcomeScreen.js

   async onClickPush() {
     await Navigation.push(this.props.componentId, {
       component: {
-        name: 'navigation.playground.PushedScreen'
+        name: 'navigation.playground.PushedScreen',
+        options: {
+          topBar: {
+            title: 'pushed'
+          }
+        }
       }
     });
   }