Merge branch 'v2' into typescript

e2e/ScreenStyle.test.js

     await expect(elementById(testIDs.FIRST_TAB_BAR_BUTTON)).toBeVisible();
     await expect(elementById(testIDs.SECOND_TAB_BAR_BUTTON)).toBeVisible();
   });
+
+  it('default options should apply to all screens in stack', async () => {
+    await elementById(testIDs.PUSH_OPTIONS_BUTTON).tap();
+    await elementById(testIDs.PUSH_DEFAULT_OPTIONS_BUTTON).tap();
+    await expect(elementById(testIDs.TOP_BAR_ELEMENT)).toBeNotVisible();
+    await elementById(testIDs.PUSH_BUTTON).tap();
+    await expect(elementById(testIDs.TOP_BAR_ELEMENT)).toBeNotVisible();
+  });
+
+  it('default options should not override static options', async () => {
+    await elementById(testIDs.PUSH_OPTIONS_BUTTON).tap();
+    await elementById(testIDs.PUSH_DEFAULT_OPTIONS_BUTTON).tap();
+    await expect(elementById(testIDs.TOP_BAR_ELEMENT)).toBeNotVisible();
+    await elementById(testIDs.POP_BUTTON).tap();
+    await expect(elementById(testIDs.TOP_BAR_ELEMENT)).toBeVisible();
+  });
 });

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

 public abstract class NavigationApplication extends Application implements ReactApplication {
 
 	private ReactGateway reactGateway;
+	public static NavigationApplication instance;
 
 	@Override
 	public void onCreate() {
 		super.onCreate();
-		reactGateway = new ReactGateway(this, isDebug(), createAdditionalReactPackages());
+        instance = this;
+        reactGateway = new ReactGateway(this, isDebug(), createAdditionalReactPackages());
 	}
 
 	public ReactGateway getReactGateway() {

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

 import android.animation.AnimatorListenerAdapter;
 import android.animation.AnimatorSet;
 import android.animation.ObjectAnimator;
-import android.animation.TimeInterpolator;
 import android.content.Context;
 import android.support.annotation.Nullable;
-import android.util.DisplayMetrics;
 import android.view.View;
-import android.view.ViewGroup;
-import android.view.WindowManager;
 import android.view.animation.AccelerateInterpolator;
 import android.view.animation.DecelerateInterpolator;
 
 import com.reactnativenavigation.utils.UiUtils;
-import com.reactnativenavigation.views.TopBar;
 
 @SuppressWarnings("ResourceType")
 public class NavigationAnimator {

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

 public class TopBarAnimator {
 
     private static final int DURATION_TOPBAR = 300;
-    private DecelerateInterpolator decelerateInterpolator;
-    private AccelerateInterpolator accelerateInterpolator;
+    private final DecelerateInterpolator decelerateInterpolator = new DecelerateInterpolator();
+    private final AccelerateInterpolator accelerateInterpolator = new AccelerateInterpolator();
 
     private TopBar topBar;
     private View contentView;
 
+    public TopBarAnimator(TopBar topBar) {
+        this.topBar = topBar;
+    }
+
     public TopBarAnimator(TopBar topBar, View contentView) {
-        decelerateInterpolator = new DecelerateInterpolator();
-        accelerateInterpolator = new AccelerateInterpolator();
         this.topBar = topBar;
         this.contentView = contentView;
     }
         hide(0, accelerateInterpolator, DURATION_TOPBAR);
     }
 
-    public 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);
+    void hide(float startTranslation, TimeInterpolator interpolator, int 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

 
 import android.view.View;
 
-import com.facebook.react.uimanager.events.EventDispatcher;
 import com.reactnativenavigation.interfaces.ScrollEventListener;
-import com.reactnativenavigation.utils.UiThread;
 import com.reactnativenavigation.views.TopBar;
 
-public class TopBarCollapseBehavior {
+public class TopBarCollapseBehavior implements ScrollEventListener.OnScrollListener, ScrollEventListener.OnDragListener {
     private TopBar topBar;
-
-    private EventDispatcher eventDispatcher;
     private ScrollEventListener scrollEventListener;
-    private boolean dragStarted;
     private TopBarAnimator animator;
 
-    public TopBarCollapseBehavior(EventDispatcher eventDispatcher, TopBar topBar) {
-        this.eventDispatcher = eventDispatcher;
+    public TopBarCollapseBehavior(TopBar topBar) {
         this.topBar = topBar;
-        this.animator = new TopBarAnimator(topBar, null);
+        this.animator = new TopBarAnimator(topBar);
     }
 
     public void enableCollapse() {
-        scrollEventListener = (new ScrollEventListener(new ScrollEventListener.OnVerticalScrollListener() {
-            @Override
-            public void onVerticalScroll(int scrollY, int oldScrollY) {
-                if (scrollY < 0) return;
-                if (!dragStarted) return;
-
-                final int scrollDiff = calcScrollDiff(scrollY, oldScrollY, topBar.getMeasuredHeight());
-                final float nextTranslation = topBar.getTranslationY() - scrollDiff;
-                if (scrollDiff < 0) {
-                    down(topBar.getMeasuredHeight(), nextTranslation);
-                } else {
-                    up(topBar.getMeasuredHeight(), nextTranslation);
-                }
-            }
+        scrollEventListener.register(topBar, this, this);
+    }
 
-            @Override
-            public void onDrag(boolean started, double velocity) {
-                dragStarted = started;
-                UiThread.post(() -> {
-                    if (!dragStarted) {
-                        if (velocity > 0) {
-                            animator.show(topBar.getTranslationY(), null, 100);
-                        } else {
-                            animator.hide(topBar.getTranslationY(), null, 100);
-                        }
-                    }
-                });
-            }
-        }));
-        if (eventDispatcher != null) {
-            eventDispatcher.addListener(scrollEventListener);
-        }
+    public void disableCollapse() {
+        scrollEventListener.unregister();
+        topBar.setVisibility(View.VISIBLE);
+        topBar.setTranslationY(0);
     }
 
-    private void up(int measuredHeight, float nextTranslation) {
+    @Override
+    public void onScrollUp(float nextTranslation) {
+        final int measuredHeight = topBar.getMeasuredHeight();
         if (nextTranslation < -measuredHeight && topBar.getVisibility() == View.VISIBLE) {
             topBar.setVisibility(View.GONE);
             topBar.setTranslationY(-measuredHeight);
         }
     }
 
-    private void down(int measuredHeight, float nextTranslation) {
+    @Override
+    public void onScrollDown(float nextTranslation) {
+        final int measuredHeight = topBar.getMeasuredHeight();
         if (topBar.getVisibility() == View.GONE && nextTranslation > -measuredHeight) {
             topBar.setVisibility(View.VISIBLE);
             topBar.setTranslationY(nextTranslation);
         }
     }
 
-    private int calcScrollDiff(int scrollY, int oldScrollY, int measuredHeight) {
-        int diff = scrollY - oldScrollY;
-        if (Math.abs(diff) > measuredHeight) {
-            diff = (Math.abs(diff) / diff) * measuredHeight;
-        }
-        return diff;
+    @Override
+    public void onShow() {
+        animator.show(topBar.getTranslationY(), null, 100);
     }
 
-    public void disableCollapse() {
-        if (eventDispatcher != null) {
-            eventDispatcher.removeListener(scrollEventListener);
-        }
-        topBar.setVisibility(View.VISIBLE);
-        topBar.setTranslationY(0);
+    @Override
+    public void onHide() {
+        animator.hide(topBar.getTranslationY(), null, 100);
     }
 }

lib/android/app/src/main/java/com/reactnativenavigation/interfaces/ScrollEventListener.java

 package com.reactnativenavigation.interfaces;
 
 import com.facebook.react.uimanager.events.Event;
+import com.facebook.react.uimanager.events.EventDispatcher;
 import com.facebook.react.uimanager.events.EventDispatcherListener;
 import com.facebook.react.views.scroll.ScrollEvent;
 import com.reactnativenavigation.utils.ReflectionUtils;
+import com.reactnativenavigation.utils.UiThread;
 
 public class ScrollEventListener implements EventDispatcherListener {
 
-    private OnVerticalScrollListener verticalScrollListener;
+    public interface OnScrollListener {
+        void onScrollUp(float nextTranslation);
+
+        void onScrollDown(float nextTranslation);
+    }
+
+    public interface OnDragListener {
+        void onShow();
+
+        void onHide();
+    }
+
+    public interface ScrollAwareView {
+        int getMeasuredHeight();
+
+        float getTranslationY();
+    }
+
+    private ScrollAwareView view;
+    private OnScrollListener onScrollListener;
+    private OnDragListener dragListener;
+    private EventDispatcher eventDispatcher;
     private int prevScrollY = -1;
+    private boolean dragStarted;
 
-    public interface OnVerticalScrollListener {
-        void onVerticalScroll(int scrollY, int oldScrollY);
+    public ScrollEventListener(EventDispatcher eventDispatcher) {
+        this.eventDispatcher = eventDispatcher;
+    }
 
-        void onDrag(boolean started, double velocity);
+    public void register(ScrollAwareView scrollAwareView, OnScrollListener scrollListener, OnDragListener dragListener) {
+        this.view = scrollAwareView;
+        this.onScrollListener = scrollListener;
+        this.dragListener = dragListener;
+        eventDispatcher.addListener(this);
     }
 
-    public ScrollEventListener(OnVerticalScrollListener verticalScrollListener) {
-        this.verticalScrollListener = verticalScrollListener;
+    public void unregister() {
+        eventDispatcher.removeListener(this);
     }
 
     @Override
         try {
             if ("topScroll".equals(event.getEventName())) {
                 int scrollY = (int) ReflectionUtils.getDeclaredField(event, "mScrollY");
-                verticalScrollListener.onVerticalScroll(scrollY, prevScrollY);
+                onVerticalScroll(scrollY, prevScrollY);
                 if (scrollY != prevScrollY) {
                     prevScrollY = scrollY;
                 }
             } else if ("topScrollBeginDrag".equals(event.getEventName())) {
                 double velocity = (double) ReflectionUtils.getDeclaredField(event, "mYVelocity");
-                verticalScrollListener.onDrag(true, velocity);
+                onDrag(true, velocity);
             } else if ("topScrollEndDrag".equals(event.getEventName())) {
                 double velocity = (double) ReflectionUtils.getDeclaredField(event, "mYVelocity");
-                verticalScrollListener.onDrag(false, velocity);
+                onDrag(false, velocity);
             }
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
+
+    private void onVerticalScroll(int scrollY, int oldScrollY) {
+        if (scrollY < 0) return;
+        if (!dragStarted) return;
+
+        final int scrollDiff = calcScrollDiff(scrollY, oldScrollY, view.getMeasuredHeight());
+        final float translationY = view.getTranslationY() - scrollDiff;
+        if (scrollDiff < 0) {
+            onScrollListener.onScrollDown(translationY);
+        } else {
+            onScrollListener.onScrollUp(translationY);
+        }
+    }
+
+    private int calcScrollDiff(int scrollY, int oldScrollY, int measuredHeight) {
+        int diff = scrollY - oldScrollY;
+        if (Math.abs(diff) > measuredHeight) {
+            diff = (Math.abs(diff) / diff) * measuredHeight;
+        }
+        return diff;
+    }
+
+    private void onDrag(boolean started, double velocity) {
+        dragStarted = started;
+        UiThread.post(() -> {
+            if (!dragStarted) {
+                if (velocity > 0) {
+                    dragListener.onShow();
+                } else {
+                    dragListener.onHide();
+                }
+            }
+        });
+    }
 }

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.react.ReactComponentViewCreator;
+import com.reactnativenavigation.utils.NoOpPromise;
 import com.reactnativenavigation.utils.TypefaceLoader;
 import com.reactnativenavigation.viewcontrollers.BottomTabsController;
 import com.reactnativenavigation.viewcontrollers.ComponentViewController;
 import com.reactnativenavigation.viewcontrollers.SideMenuController;
 import com.reactnativenavigation.viewcontrollers.StackController;
 import com.reactnativenavigation.viewcontrollers.ViewController;
-import com.reactnativenavigation.viewcontrollers.overlay.DialogViewController;
 import com.reactnativenavigation.viewcontrollers.toptabs.TopTabController;
 import com.reactnativenavigation.viewcontrollers.toptabs.TopTabsController;
 import com.reactnativenavigation.views.ComponentViewCreator;
 				return createSideMenuLeft(node);
 			case SideMenuRight:
 				return createSideMenuRight(node);
-//			case CustomDialog:
-//				return createDialogComponent(node);
             case TopTabs:
                 return createTopTabs(node);
-//            case TopTab:
-//                return createTopTab(node);
 			default:
 				throw new IllegalArgumentException("Invalid node type: " + node.type);
 		}
 	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;
 	}
 		return tabsComponent;
 	}
 
-	private ViewController createDialogComponent(LayoutNode node) {
-		String id = node.id;
-		String name = node.data.optString("name");
-		ReactComponentViewCreator creator = new ReactComponentViewCreator(reactInstanceManager);
-		return new DialogViewController(activity, id, name, creator);
-	}
-
     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);
         return new TopTabsController(activity, node.id, tabs, new TopTabsLayoutCreator(activity, tabs), options);
     }
-
-    private ViewController createTopTab(LayoutNode node) {
-        String id = node.id;
-        String name = node.data.optString("name");
-        Options options = Options.parse(typefaceManager, node.getNavigationOptions(), defaultOptions);
-        return new TopTabController(activity,
-                id,
-                name,
-                new ReactComponentViewCreator(reactInstanceManager),
-                options
-        );
-    }
 }

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) {
-        applyTopBarOptions(options.topBarOptions);
         applyButtons(options.topBarOptions.leftButtons, options.topBarOptions.rightButtons);
+        applyTopBarOptions(options.topBarOptions);
         applyTopTabsOptions(options.topTabsOptions);
         applyTopTabOptions(options.topTabOptions);
     }
 
     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/react/NavigationModule.java

 import com.reactnativenavigation.utils.UiThread;
 import com.reactnativenavigation.viewcontrollers.Navigator;
 import com.reactnativenavigation.viewcontrollers.ViewController;
-import com.reactnativenavigation.viewcontrollers.overlay.OverlayFactory;
 
 public class NavigationModule extends ReactContextBaseJavaModule {
 	private static final String NAME = "RNNBridgeModule";
 
 	@ReactMethod
 	public void showOverlay(final String type, final ReadableMap data, final Promise promise) {
-		if (OverlayFactory.Overlay.create(type) == OverlayFactory.Overlay.CustomDialog) {
-			final LayoutNode layoutTree = LayoutNodeParser.parse(JSONParser.parse(data));
-			handle(() -> {
-                ViewController viewController = newLayoutFactory().create(layoutTree);
-                navigator().showOverlay(type, OverlayOptions.create(viewController), promise);
-            });
-		} else {
-			final OverlayOptions overlayOptions = OverlayOptions.parse(JSONParser.parse(data));
-			handle(() -> navigator().showOverlay(type, overlayOptions, promise));
-		}
-
-
+        final OverlayOptions overlayOptions = OverlayOptions.parse(JSONParser.parse(data));
+        handle(() -> navigator().showOverlay(type, overlayOptions, promise));
 	}
 
 	@ReactMethod

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

 
 import com.facebook.react.ReactInstanceManager;
 import com.facebook.react.ReactRootView;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.uimanager.UIManagerModule;
+import com.facebook.react.uimanager.events.EventDispatcher;
+import com.reactnativenavigation.interfaces.ScrollEventListener;
 import com.reactnativenavigation.viewcontrollers.ComponentViewController;
 
 @SuppressLint("ViewConstructor")
 	public void sendOnNavigationButtonPressed(String buttonId) {
 		new NavigationEvent(reactInstanceManager.getCurrentReactContext()).sendOnNavigationButtonPressed(componentId, buttonId);
 	}
+
+    @Override
+    public ScrollEventListener getScrollEventListener() {
+        return new ScrollEventListener(getEventDispatcher());
+    }
+
+    public EventDispatcher getEventDispatcher() {
+        ReactContext reactContext = reactInstanceManager.getCurrentReactContext();
+        return reactContext == null ? null : reactContext.getNativeModule(UIManagerModule.class).getEventDispatcher();
+    }
 }

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

 import android.net.Uri;
 import android.os.StrictMode;
 import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
 
+import com.reactnativenavigation.NavigationApplication;
+
+import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.URL;
 		void onError(Throwable error);
 	}
 
-	public static void tryLoadIcon(final Context context, final String uri, final ImageLoadingListener listener) {
-		if (uri == null) {
-			if (listener != null) {
-				listener.onError(new IllegalArgumentException("Uri is null"));
-			}
-			return;
-		}
-		runWorkerThread(new Runnable() {
-			@Override
-			public void run() {
-				loadIcon(context, uri, listener);
-			}
-		});
-	}
+	public static void loadIcon(final Context context, final String uri, final ImageLoadingListener listener) {
+        try {
+            StrictMode.ThreadPolicy threadPolicy = adjustThreadPolicyDebug();
+            
+            InputStream is = openStream(context, uri);
+            Bitmap bitmap = BitmapFactory.decodeStream(is);
+            Drawable drawable = new BitmapDrawable(context.getResources(), bitmap);
+            listener.onComplete(drawable);
 
-	private static void loadIcon(Context context, String uri, final ImageLoadingListener listener) {
-		try {
-			InputStream is = null;
-			if (uri.contains("http")) {
-				URL url = new URL(uri);
-				is = url.openStream();
-			} else {
-				is = context.getContentResolver().openInputStream(Uri.parse(uri));
-			}
+            restoreThreadPolicyDebug(threadPolicy);
+        } catch (IOException e) {
+            listener.onError(e);
+        }
+    }
 
-			Bitmap bitmap = BitmapFactory.decodeStream(is);
-			Drawable drawable = new BitmapDrawable(context.getResources(), bitmap);
-			if (listener != null) {
-				listener.onComplete(drawable);
-			}
-		} catch (IOException e) {
-			if (listener != null) {
-				listener.onError(e);
-			} else {
-				e.printStackTrace();
-			}
-		}
-	}
+    private static StrictMode.ThreadPolicy adjustThreadPolicyDebug() {
+        StrictMode.ThreadPolicy threadPolicy = null;
+        if (NavigationApplication.instance.isDebug()) {
+            threadPolicy = StrictMode.getThreadPolicy();
+            StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder().permitNetwork().build());
+        }
+        return threadPolicy;
+    }
 
-	private static void runWorkerThread(Runnable runnable) {
-		new Thread(runnable).start();
-	}
+    private static void restoreThreadPolicyDebug(@Nullable StrictMode.ThreadPolicy threadPolicy) {
+        if (NavigationApplication.instance.isDebug() && threadPolicy != null) {
+            StrictMode.setThreadPolicy(threadPolicy);
+        }
+    }
+
+    private static InputStream openStream(Context context, String uri) throws IOException {
+        return uri.contains("http") ? remoteUrl(uri) : localFile(context, uri);
+    }
+
+    private static InputStream remoteUrl(String uri) throws IOException {
+        return new URL(uri).openStream();
+    }
+
+    private static InputStream localFile(Context context, String uri) throws FileNotFoundException {
+        return context.getContentResolver().openInputStream(Uri.parse(uri));
+    }
 }

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

 import android.support.annotation.*;
 import android.view.*;
 
+import com.reactnativenavigation.interfaces.ScrollEventListener;
 import com.reactnativenavigation.parse.*;
 import com.reactnativenavigation.presentation.*;
 import com.reactnativenavigation.views.*;
         void sendComponentStop();
 
         void sendOnNavigationButtonPressed(String buttonId);
+
+        ScrollEventListener getScrollEventListener();
     }
 
     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);
+    }
 
-	public void push(final ViewController child) {
-		push(child, null);
-	}
+    @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);
 
-		//TODO animatePush only when needed
-		if (previousTop != null) {
-			animator.animatePush(enteringView, new NavigationAnimator.NavigationAnimationListener() {
-				@Override
-				public void onAnimationEnd() {
-					getView().removeView(previousTop.getView());
-					if (promise != null) {
-						promise.resolve(child.getId());
-					}
-				}
-			});
-		} else if (promise != null) {
+		if (toRemove != null) {
+            animator.animatePush(enteringView, () -> {
+                getView().removeView(toRemove.getView());
+                promise.resolve(child.getId());
+            });
+		} 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();
 
-	void pop() {
-		pop(true, null);
-	}
+        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, new NavigationAnimator.NavigationAnimationListener() {
-				@Override
-				public void onAnimationEnd() {
-					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/overlay/CustomOverlay.java

-package com.reactnativenavigation.viewcontrollers.overlay;
-
-
-import android.content.Context;
-
-import com.reactnativenavigation.parse.OverlayOptions;
-import com.reactnativenavigation.viewcontrollers.ComponentViewController;
-import com.reactnativenavigation.viewcontrollers.ViewController;
-import com.reactnativenavigation.views.CustomDialog;
-
-public class CustomOverlay implements OverlayInterface {
-
-	private CustomDialog dialog;
-
-	@Override
-	public CustomOverlay create(ViewController root, OverlayOptions options) {
-		//TODO; implement
-
-		ViewController viewController = options.getCustomView();
-		dialog = new CustomDialog(root.getActivity(), viewController.getView());
-
-		return this;
-	}
-
-	@Override
-	public void show() {
-		dialog.show();
-	}
-
-	@Override
-	public void dismiss() {
-		if (dialog != null) {
-			dialog.dismiss();
-		}
-	}
-}

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/overlay/OverlayFactory.java

 package com.reactnativenavigation.viewcontrollers.overlay;
 
 
-import android.content.Context;
-
 import com.reactnativenavigation.parse.OverlayOptions;
 import com.reactnativenavigation.viewcontrollers.ViewController;
 
 
 	public enum Overlay {
 		AlertDialog("alert", new AlertOverlay()),
-		Snackbar("snackbar", new SnackbarOverlay()),
-		CustomDialog("custom", new CustomOverlay());
+		Snackbar("snackbar", new SnackbarOverlay());
 
 		private String name;
 		private OverlayInterface overlayInstance;

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

 package com.reactnativenavigation.views;
 
-import android.view.View;
-
 import com.reactnativenavigation.parse.Options;
 
 public interface Component {
     void applyOptions(Options options);
 
-    void sendOnNavigationButtonPressed(String id);
-
-    TopBar getTopBar();
-
-    View getContentView();
-
     void drawBehindTopBar();
 
-    void drawBelowTopBar();
+    void drawBelowTopBar(TopBar topBar);
 }

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

 package com.reactnativenavigation.views;
 
-import android.annotation.*;
-import android.content.*;
-import android.view.*;
-import android.widget.*;
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.view.View;
+import android.widget.FrameLayout;
+import android.widget.RelativeLayout;
 
-import com.facebook.react.uimanager.events.*;
-import com.reactnativenavigation.parse.*;
-import com.reactnativenavigation.presentation.*;
-import com.reactnativenavigation.viewcontrollers.ComponentViewController.*;
+import com.reactnativenavigation.interfaces.ScrollEventListener;
+import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.viewcontrollers.ComponentViewController.IReactView;
 
-import static android.view.ViewGroup.LayoutParams.*;
+import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
+import static android.widget.RelativeLayout.BELOW;
 
 @SuppressLint("ViewConstructor")
-public class ComponentLayout extends RelativeLayout implements ReactComponent {
+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, EventDispatcher eventDispatcher) {
+	public ComponentLayout(Context context, IReactView reactView) {
 		super(context);
 		this.reactView = reactView;
-		this.topBar = new TopBar(context, this, eventDispatcher);
-        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
     }
 
     @Override
-    public TopBar getTopBar() {
-        return topBar;
-    }
-
-    @Override
-    public View getContentView() {
-        return reactView.asView();
+    public ScrollEventListener getScrollEventListener() {
+        return reactView.getScrollEventListener();
     }
 
     @Override
     }
 
     @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);
     }
+
+    @Override
+    public void onPress(String buttonId) {
+        reactView.sendOnNavigationButtonPressed(buttonId);
+    }
 }

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

 package com.reactnativenavigation.views;
 
-import android.app.*;
+import android.app.Activity;
 
-import com.facebook.react.*;
-import com.facebook.react.uimanager.*;
-import com.reactnativenavigation.react.*;
-import com.reactnativenavigation.viewcontrollers.*;
+import com.facebook.react.ReactInstanceManager;
+import com.reactnativenavigation.react.ReactComponentViewCreator;
+import com.reactnativenavigation.viewcontrollers.ComponentViewController;
 
 public class ComponentViewCreator implements ComponentViewController.ReactViewCreator {
 
 	@Override
 	public ComponentViewController.IReactView create(Activity activity, String componentId, String componentName) {
         ComponentViewController.IReactView reactView = new ReactComponentViewCreator(instanceManager).create(activity, componentId, componentName);
-        return new ComponentLayout(activity, reactView, instanceManager.getCurrentReactContext().getNativeModule(UIManagerModule.class).getEventDispatcher());
+        return new ComponentLayout(activity, reactView);
 	}
 }

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

-package com.reactnativenavigation.views;
-
-import android.app.Dialog;
-import android.content.Context;
-import android.support.annotation.NonNull;
-import android.util.Log;
-import android.view.View;
-import android.view.ViewGroup;
-import android.view.ViewTreeObserver;
-import android.view.WindowManager;
-
-import com.facebook.react.ReactRootView;
-
-
-public class CustomDialog extends Dialog {
-
-	private View component;
-
-	public CustomDialog(@NonNull Context context, @NonNull View component) {
-		super(context);
-
-		this.component = component;
-		init();
-	}
-
-	private void init() {
-		addContentView(component, new WindowManager.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
-	}
-}

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

 import java.util.ArrayList;
 
 public class TitleBarButton implements MenuItem.OnMenuItemClickListener {
+    public interface OnClickListener {
+        void onPress(String buttonId);
+    }
+
 	private Toolbar toolbar;
 	private final Button button;
-	private Component component;
 	private Drawable icon;
+    private OnClickListener onPressListener;
 
-	TitleBarButton(Component component, Toolbar toolbar, Button button) {
-		this.component = component;
+    TitleBarButton(Toolbar toolbar, Button button, OnClickListener onPressListener) {
+        this.onPressListener = onPressListener;
 		this.toolbar = toolbar;
 		this.button = button;
 	}
 
 	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.loadIcon(context, button.icon.get(), new ImageUtils.ImageLoadingListener() {
 			@Override
 			public void onComplete(@NonNull Drawable drawable) {
 				icon = drawable;
-				UiUtils.runOnMainThread(() -> {
-                    setIconColor();
-                    setNavigationClickListener();
-                    toolbar.setNavigationIcon(icon);
-                });
+                setIconColor();
+                setNavigationClickListener();
+                toolbar.setNavigationIcon(icon);
 			}
 
 			@Override
 			public void onError(Throwable error) {
-				//TODO: handle
 				error.printStackTrace();
 			}
 		});
 	}
 
 	private void applyIcon(Context context, final MenuItem menuItem) {
-		ImageUtils.tryLoadIcon(context, button.icon, new ImageUtils.ImageLoadingListener() {
+		ImageUtils.loadIcon(context, button.icon.get(), new ImageUtils.ImageLoadingListener() {
 			@Override
 			public void onComplete(@NonNull Drawable drawable) {
 				icon = drawable;
-				UiUtils.runOnMainThread(() -> {
-                    menuItem.setIcon(icon);
-                    setIconColor();
-                });
+                menuItem.setIcon(icon);
+                setIconColor();
 			}
 
 			@Override
 			public void onError(Throwable error) {
-				//TODO: handle
 				error.printStackTrace();
 			}
 		});
 	}
 
 	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);
 	}
 
 	private void setNavigationClickListener() {
-		toolbar.setNavigationOnClickListener(view -> component.sendOnNavigationButtonPressed(button.id));
+		toolbar.setNavigationOnClickListener(view -> onPressListener.onPress(button.id));
 	}
 
 	@Override
 	public boolean onMenuItemClick(MenuItem menuItem) {
-		this.component.sendOnNavigationButtonPressed(button.id);
+		onPressListener.onPress(button.id);
 		return true;
 	}
 
 	@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

 package com.reactnativenavigation.views;
 
-import android.annotation.*;
-import android.content.*;
-import android.graphics.*;
-import android.support.annotation.*;
-import android.support.design.widget.*;
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.graphics.Typeface;
+import android.support.annotation.Nullable;
+import android.support.design.widget.AppBarLayout;
 import android.support.v7.widget.Toolbar;
-import android.util.*;
-import android.view.*;
-import android.widget.*;
-
-import com.facebook.react.uimanager.events.*;
-import com.reactnativenavigation.anim.*;
+import android.util.Log;
+import android.view.Menu;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.TextView;
+
+import com.reactnativenavigation.anim.TopBarAnimator;
+import com.reactnativenavigation.anim.TopBarCollapseBehavior;
+import com.reactnativenavigation.interfaces.ScrollEventListener;
 import com.reactnativenavigation.parse.Button;
 import com.reactnativenavigation.parse.Color;
-import com.reactnativenavigation.parse.*;
+import com.reactnativenavigation.parse.Fraction;
 import com.reactnativenavigation.parse.Number;
-import com.reactnativenavigation.viewcontrollers.toptabs.*;
+import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.viewcontrollers.toptabs.TopTabsViewPager;
 
-import java.util.*;
+import java.util.ArrayList;
 
 @SuppressLint("ViewConstructor")
-public class TopBar extends AppBarLayout {
+public class TopBar extends AppBarLayout implements ScrollEventListener.ScrollAwareView {
     private final Toolbar titleBar;
+    private TitleBarButton.OnClickListener onClickListener;
     private final TopBarCollapseBehavior collapsingBehavior;
     private final TopBarAnimator animator;
-    private Component component;
     private TopTabs topTabs;
 
-    public TopBar(final Context context, Component component, EventDispatcher eventDispatcher) {
+    public TopBar(final Context context, TitleBarButton.OnClickListener onClickListener) {
         super(context);
-        collapsingBehavior = new TopBarCollapseBehavior(eventDispatcher, this);
-        this.component = component;
+        this.onClickListener = onClickListener;
+        collapsingBehavior = new TopBarCollapseBehavior(this);
         titleBar = new Toolbar(context);
         topTabs = new TopTabs(getContext());
-        this.animator = new TopBarAnimator(this, component != null ? component.getContentView() : null);
+        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;
         }
     }
 
     private void setLeftButton(final Button button) {
-        TitleBarButton leftBarButton = new TitleBarButton(component, this.titleBar, button);
+        TitleBarButton leftBarButton = new TitleBarButton(this.titleBar, button, onClickListener);
         leftBarButton.applyNavigationIcon(getContext());
     }
 
 
         for (int i = 0; i < rightButtons.size(); i++) {
             Button button = rightButtons.get(i);
-            TitleBarButton titleBarButton = new TitleBarButton(component, this.titleBar, button);
+            TitleBarButton titleBarButton = new TitleBarButton(this.titleBar, button, onClickListener);
             titleBarButton.addToMenu(getContext(), menu);
         }
     }
             setVisibility(View.GONE);
         }
     }
+
+    public void clear() {
+        titleBar.setTitle(null);
+        titleBar.setNavigationIcon(null);
+        titleBar.getMenu().clear();
+    }
 }

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

 import android.view.View;
 import android.widget.FrameLayout;
 
+import com.reactnativenavigation.interfaces.ScrollEventListener;
 import com.reactnativenavigation.viewcontrollers.ComponentViewController.IReactView;
 
 @SuppressLint("ViewConstructor")
     public void sendOnNavigationButtonPressed(String buttonId) {
         reactView.sendOnNavigationButtonPressed(buttonId);
     }
+
+    @Override
+    public ScrollEventListener getScrollEventListener() {
+        return reactView.getScrollEventListener();
+    }
 }

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 {
+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;
-        topBar = new TopBar(context, this, null);
-        topBar.setId(View.generateViewId());
         viewPager = new TopTabsViewPager(context, tabs, adapter);
-        optionsPresenter = new OptionsPresenter(this);
+        topBar = new TopBar(context, this);
+        topBar.setId(View.generateViewId());
+
         initViews();
     }
 
 
     @Override
     public void applyOptions(Options options) {
-        optionsPresenter.applyOptions(options);
-    }
-
-    @Override
-    public void sendOnNavigationButtonPressed(String id) {
-        viewPager.sendOnNavigationButtonPressed(id);
-    }
-
-    @Override
-    public TopBar getTopBar() {
-        return topBar;
-    }
 
-    @Override
-    public View getContentView() {
-        return viewPager;
     }
 
     @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);
     }
     public int getCurrentItem() {
         return viewPager.getCurrentItem();
     }
+
+    @Override
+    public void onPress(String buttonId) {
+        viewPager.sendOnNavigationButtonPressed(buttonId);
+    }
 }

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.parse.*;
-import com.reactnativenavigation.presentation.*;
-import com.reactnativenavigation.views.*;
+import com.reactnativenavigation.interfaces.ScrollEventListener;
+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 {
+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);
-        topBar = new TopBar(context, this, null);
         contentView = new View(context);
-        addView(topBar);
         addView(contentView);
-        optionsPresenter = new OptionsPresenter(this);
-    }
-
-    public TopBar getTopBar() {
-        return topBar;
-    }
-
-    @Override
-    public View getContentView() {
-        return contentView;
     }
 
     @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
     public void sendOnNavigationButtonPressed(String id) {
 
     }
+
+    @Override
+    public ScrollEventListener getScrollEventListener() {
+        return null;
+    }
+
+    @Override
+    public void onPress(String buttonId) {
+
+    }
 }

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

-package com.reactnativenavigation.mocks;
-
-import android.content.*;
-import android.view.*;
-
-import com.reactnativenavigation.parse.*;
-import com.reactnativenavigation.views.*;
-
-public class TestComponentView extends View implements ReactComponent {
-
-    private TopBar topBar;
-
-    public TestComponentView(final Context context) {
-        super(context);
-        topBar = new TopBar(context, this, null);
-
-    }
-
-    @Override
-    public boolean isReady() {
-        return false;
-    }
-
-    @Override
-    public View asView() {
-        return this;
-    }
-
-    @Override
-    public void destroy() {
-    }
-
-    @Override
-    public void sendComponentStart() {
-    }
-
-    @Override
-    public void sendComponentStop() {
-    }
-
-    @Override
-    public void applyOptions(Options options) {
-
-    }
-
-    @Override
-    public void sendOnNavigationButtonPressed(String id) {
-
-    }
-
-    @Override
-    public TopBar getTopBar() {
-        return topBar;
-    }
-
-    @Override
-    public View getContentView() {
-        return null;
-    }
-
-    @Override
-    public void drawBehindTopBar() {
-
-    }
-
-    @Override
-    public void drawBelowTopBar() {
-
-    }
-}

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

 import android.content.*;
 import android.view.*;
 
+import com.reactnativenavigation.interfaces.ScrollEventListener;
 import com.reactnativenavigation.viewcontrollers.*;
 
 public class TopTabLayoutMock extends View implements ComponentViewController.IReactView {
     public void sendOnNavigationButtonPressed(String buttonId) {
 
     }
+
+    @Override
+    public ScrollEventListener getScrollEventListener() {
+        return null;
+    }
 }

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

         List<ViewController> tabs = createTabs();
         uut.setTabs(tabs);
         assertThat(uut.getView().getChildCount()).isEqualTo(6);
-        assertThat(uut.getChildControllers()).extracting(new Extractor<ViewController, Integer>() {
-            @Override
-            public Integer extract(final ViewController input) {
-                return input.getView().getVisibility();
-            }
-        }).containsExactly(View.VISIBLE, View.GONE, View.GONE, View.GONE, View.GONE);
+        assertThat(uut.getChildControllers()).extracting((Extractor<ViewController, Integer>) input -> input.getView().getVisibility()).containsExactly(View.VISIBLE, View.GONE, View.GONE, View.GONE, View.GONE);
     }
 
     @Test
         uut.selectTabAtIndex(3);
 
         assertThat(uut.getSelectedIndex()).isEqualTo(3);
-        assertThat(uut.getChildControllers()).extracting(new Extractor<ViewController, Integer>() {
-            @Override
-            public Integer extract(final ViewController input) {
-                return input.getView().getVisibility();
-            }
-        }).containsExactly(View.GONE, View.GONE, View.GONE, View.VISIBLE, View.GONE);
+        assertThat(uut.getChildControllers()).extracting((Extractor<ViewController, Integer>) input -> input.getView().getVisibility()).containsExactly(View.GONE, View.GONE, View.GONE, View.VISIBLE, View.GONE);
     }
 
     @Test
         assertThat(uut.findControllerById("123")).isNull();
         assertThat(uut.findControllerById(uut.getId())).isEqualTo(uut);
         StackController inner = new StackController(activity, "inner");
-        inner.push(child1);
+        inner.animatePush(child1, new MockPromise());
         assertThat(uut.findControllerById(child1.getId())).isNull();
-        uut.setTabs(Arrays.<ViewController>asList(inner));
+        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);
-        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);
-        stack2.push(child2);
+        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);
-        stack2.push(child2);
-        stack2.push(child3);
-        stack2.push(child4);
         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);
-        stack2.push(child2);
-        stack2.push(child3);
-        stack2.push(child4);
+        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);
-        stack2.push(child2);
-        stack2.push(child3);
-        stack2.push(child4);
-        stack2.push(child5);
         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);
-        stack2.push(child2);
-        stack2.push(child3);
-        stack2.push(child4);
-        stack2.push(child5);
-
         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);
-        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);
-        stack2.push(child2);
-        stack2.push(child3);
-        stack2.push(child4);
         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);
+        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);
-        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);
-        stackController.push(child2);
+        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);
-        uut.push(child2);
-        uut.push(child3);
+        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);
+        uut.animatePush(child1, new MockPromise());
         assertContainsOnlyId(child1.getId());
     }
 
     @Test
     public void pop() throws Exception {
-        uut.push(child1);
-        uut.push(child2);
-        assertContainsOnlyId(child2.getId(), child1.getId());
-        uut.pop();
-        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);
+        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);
+        uut.animatePush(child1, new MockPromise());
         assertThat(child1.getParentStackController()).isEqualTo(uut);
 
-        StackController anotherNavController = new StackController(activity, "another", new TestNavigationAnimator());
-        anotherNavController.push(child2);
+        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);
+        uut.animatePush(child1, new MockPromise());
         assertThat(uut.size()).isEqualTo(1);
         assertThat(uut.handleBack()).isFalse();
 
-        uut.push(child2);
-        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
     public void popDoesNothingWhenZeroOrOneChild() throws Exception {
         assertThat(uut.isEmpty()).isTrue();
-        uut.pop();
+        uut.pop(new MockPromise());
         assertThat(uut.isEmpty()).isTrue();
 
-        uut.push(child1);
-        uut.pop();
+        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);
+        uut.animatePush(child1, new MockPromise());
         assertContainsOnlyId(child1.getId());
         assertThat(uut.canPop()).isFalse();
-        uut.push(child2);
+        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);
+        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);
+        uut.animatePush(child1, new MockPromise());
         assertThat(uut.getView().findViewById(child1.getView().getId())).isNotNull();
-        uut.push(child2);
-        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);
-        uut.push(child2);
         final View child2View = child2.getView();
         final View child1View = child1.getView();
-        assertIsChildById(uut.getView(), child2View);
-        assertNotChildOf(uut.getView(), child1View);
-        uut.pop();
-        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);
-        uut.push(child2);
-        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);
-        uut.push(child2);
+        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);
-        uut.push(child2);
-        uut.push(child3);
-
-        assertThat(uut.size()).isEqualTo(3);
-        assertThat(uut.peek()).isEqualTo(child3);
+        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);
+                uut.popTo(child1, new MockPromise());
 
-        assertThat(uut.size()).isEqualTo(1);
-        assertThat(uut.peek()).isEqualTo(child1);
+                assertThat(uut.size()).isEqualTo(1);
+                assertThat(uut.peek()).isEqualTo(child1);
+            }
+        });
     }
 
     @Test
     public void popTo_NotAChildOfThisStack_DoesNothing() throws Exception {
-        uut.push(child1);
-        uut.push(child3);
+        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);
-        uut.push(child2);
-        uut.push(child3);
-
-        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);
+        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);
-        uut.push(stack);
+        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);
-        uut.push(child2);
-        uut.push(child3);
-
-        verify(child3, times(0)).destroy();
-        uut.pop();
-        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);
-        uut.push(child2);
-        uut.push(child3);
+        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);
-        uut.push(child2);
-        uut.push(child3);
-
-        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) {
         assertThat(uut.size()).isEqualTo(ids.length);
-        assertThat(uut.getChildControllers()).extracting(new Extractor<ViewController, String>() {
-            @Override
-            public String extract(final ViewController input) {
-                return input.getId();
-            }
-        }).containsOnly(ids);
+        assertThat(uut.getChildControllers()).extracting((Extractor<ViewController, String>) ViewController::getId).containsOnly(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

 import android.widget.LinearLayout;
 
 import com.reactnativenavigation.BaseTest;
+import com.reactnativenavigation.mocks.MockPromise;
 import com.reactnativenavigation.mocks.SimpleViewController;
 
 import org.assertj.android.api.Assertions;
     public void holdsAReferenceToStackControllerOrNull() throws Exception {
         assertThat(uut.getParentStackController()).isNull();
         StackController nav = new StackController(activity, "stack");
-        nav.push(uut);
+        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);
+        TopBar topBar = new TopBar(newActivity(), buttonId -> {});
         assertThat(topBar.getTitle()).isEmpty();
 
         topBar.setTitle("new title");

lib/ios/RNNBridgeModule.m

 	}];
 }
 
+RCT_EXPORT_METHOD(setDefaultOptions:(NSDictionary*)options resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+	[_commandsHandler setDefaultOptions:options completion:^{
+		resolve(nil);
+	}];
+}
+
 RCT_EXPORT_METHOD(push:(NSString*)componentId layout:(NSDictionary*)layout resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
 	[_commandsHandler push:componentId layout:layout completion:^{
 		resolve(componentId);

lib/ios/RNNCommandsHandler.h

 
 -(void) setOptions:(NSString*)componentId options:(NSDictionary*)options completion:(RNNTransitionCompletionBlock)completion;
 
+-(void) setDefaultOptions:(NSDictionary*)options completion:(RNNTransitionCompletionBlock)completion;
+
 -(void) push:(NSString*)componentId layout:(NSDictionary*)layout completion:(RNNTransitionCompletionBlock)completion;
 
 -(void) pop:(NSString*)componentId options:(NSDictionary*)options completion:(RNNTransitionCompletionBlock)completion;

lib/ios/RNNCommandsHandler.m

 	}
 }
 
+-(void) setDefaultOptions:(NSDictionary*)optionsDict completion:(RNNTransitionCompletionBlock)completion {
+	[self assertReady];
+	RNNNavigationOptions* options = [[RNNNavigationOptions alloc] initWithDict:optionsDict];
+	[_controllerFactory setDefaultOptions:options];
+}
+
 -(void) push:(NSString*)componentId layout:(NSDictionary*)layout completion:(RNNTransitionCompletionBlock)completion {
 	[self assertReady];
 	

lib/ios/RNNControllerFactory.h

 
 -(UIViewController<RNNRootViewProtocol> *)createLayoutAndSaveToStore:(NSDictionary*)layout;
 
+@property (nonatomic, strong) RNNNavigationOptions* defaultOptions;
+
 @end

lib/ios/RNNControllerFactory.m

 	NSDictionary* customTransition = node.data[@"customTransition"];
 	RNNAnimator* animator = [[RNNAnimator alloc] initWithAnimationsDictionary:customTransition];
 	RNNNavigationOptions* options = [[RNNNavigationOptions alloc] initWithDict:node.data[@"options"]];
+	options.defaultOptions = _defaultOptions;
 	NSString* componentId = node.nodeId;
 	RNNRootViewController* component = [[RNNRootViewController alloc] initWithName:name withOptions:options withComponentId:componentId rootViewCreator:_creator eventEmitter:_eventEmitter animator:animator];
 	CGSize availableSize = UIApplication.sharedApplication.delegate.window.bounds.size;

lib/ios/RNNNavigationOptions.h

 @property (nonatomic, strong) RNNTopTabOptions* topTab;
 @property (nonatomic, strong) RNNSideMenuOptions* sideMenu;
 
+@property (nonatomic, strong) RNNNavigationOptions* defaultOptions;
+
 @property (nonatomic, strong) NSNumber* statusBarHidden;
 @property (nonatomic, strong) NSNumber* screenBackgroundColor;
 @property (nonatomic, strong) NSMutableDictionary* originalTopBarImages;

lib/ios/RNNNavigationOptions.m

 }
 
 -(void)applyOn:(UIViewController*)viewController {
+	[_defaultOptions applyOn:viewController];
+	
 	[self.topBar applyOn:viewController];
 	[self.bottomTabs applyOn:viewController];
 	[self.topTab applyOn:viewController];
 	[self.bottomTab applyOn:viewController];
 	[self.sideMenu applyOn:viewController];
-	
+	[self applyOtherOptionsOn:viewController];
+}
+
+- (void)applyOtherOptionsOn:(UIViewController*)viewController {
 	if (self.popGesture) {
 		viewController.navigationController.interactivePopGestureRecognizer.enabled = [self.popGesture boolValue];
 	}

lib/ios/RNNOptions.h

 #import <Foundation/Foundation.h>
 #import <UIKit/UIKit.h>
 #import <React/RCTConvert.h>
+
+@class RNNOptions;
+
 @protocol RNNOptionsProtocol <NSObject>
 
 @optional
--(void)resetOptions;
--(void)applyOn:(UIViewController*)viewController;
+- (void)resetOptions;
+- (void)applyOn:(UIViewController *)viewController;
 
 @end
 
 @interface RNNOptions : NSObject <RNNOptionsProtocol>
 
--(instancetype)initWithDict:(NSDictionary*)dict;
--(void)mergeWith:(NSDictionary*)otherOptions;
+- (instancetype)initWithDict:(NSDictionary*)dict;
+- (void)mergeWith:(NSDictionary*)otherOptions;
+- (void)applyOn:(UIViewController *)viewController defaultOptions:(RNNOptions*)defaultOptions;
 
 @end

lib/ios/RNNOptions.m

 	return self;
 }
 
+- (void)applyOn:(UIViewController *)viewController defaultOptions:(RNNOptions *)defaultOptions {
+	[defaultOptions applyOn:viewController];
+	[self applyOn:viewController];
+}
+
 -(void)mergeWith:(NSDictionary *)otherOptions {
 	for (id key in otherOptions) {
 		[self setValue:[otherOptions objectForKey:key] forKey:key];

playground/src/screens/OptionsScreen.js

     this.onClickTopBarTransparent = this.onClickTopBarTransparent.bind(this);
     this.onClickTopBarOpaque = this.onClickTopBarOpaque.bind(this);
     this.onClickCustomTranstition = this.onClickCustomTranstition.bind(this);
+    this.onClickPushDefaultOptionsScreen = this.onClickPushDefaultOptionsScreen.bind(this);
   }
 
   render() {
         <Button title="Custom Transition" onPress={this.onClickCustomTranstition} />
         <Button title="Show custom alert" testID={testIDs.SHOW_CUSTOM_ALERT_BUTTON} onPress={this.onClickAlert} />
         <Button title="Show snackbar" testID={testIDs.SHOW_SNACKBAR_BUTTON} onPress={this.onClickSnackbar} />
-        <Text style={styles.footer}>{`this.props.componentId = ${this.props.componentId}`}</Text>
+        <Button title="Push Default Options Screen" testID={testIDs.PUSH_DEFAULT_OPTIONS_BUTTON} onPress={this.onClickPushDefaultOptionsScreen} />
+        <Text style={styles.footer}>{`this.props.containerId = ${this.props.containerId}`}</Text>
       </View>
     );
   }
       }
     });
   }
+
+  onClickPushDefaultOptionsScreen() {
+    Navigation.setDefaultOptions({
+      topBar: {
+        hidden: true
+      }
+    });
+
+    Navigation.push(this.props.componentId, {
+      component: {
+        name: 'navigation.playground.PushedScreen'
+      }
+    });
+  }
 }
 
 const styles = {
   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 options() {
+    return {
+      topBar: {
+        testID: testIDs.TOP_BAR_ELEMENT
+      }
+    };
+  }
+
   constructor(props) {
     super(props);
     this.onClickPush = this.onClickPush.bind(this);
         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'
+          }
+        }
       }
     });
   }
 
   onClickPushTopTabsScreen() {
     Navigation.push(this.props.componentId, {
-      topTabs: [
-        {
-          name: 'navigation.playground.TopTabOptionsScreen',
-          passProps: {
-            title: 'Tab 1',
-            text: 'This is top tab 1'
-          },
-          options: {
-            topTab: {
-              title: 'Tab 1'
+      topTabs: {
+        children: [
+          {
+            component: {
+              name: 'navigation.playground.TopTabOptionsScreen',
+              passProps: {
+                title: 'Tab 1',
+                text: 'This is top tab 1'
+              },
+              options: {
+                topTab: {
+                  title: 'Tab 1'
+                }
+              }
             }
-          }
-        },
-        {
-          name: 'navigation.playground.TopTabScreen',
-          passProps: {
-            title: 'Tab 2',
-            text: 'This is top tab 2'
           },
-          options: {
-            topTab: {
-              title: 'Tab 2',
-              titleFontFamily: 'HelveticaNeue-Italic'
+          {
+            component: {
+              name: 'navigation.playground.TopTabScreen',
+              passProps: {
+                title: 'Tab 2',
+                text: 'This is top tab 2'
+              },
+              options: {
+                topTab: {
+                  title: 'Tab 2',
+                  titleFontFamily: 'HelveticaNeue-Italic'
+                }
+              }
             }
-          }
-        },
-        {
-          name: 'navigation.playground.TopTabScreen',
-          passProps: {
-            title: 'Tab 3',
-            text: 'This is top tab 3'
           },
-          options: {
-            topTab: {
-              title: 'Tab 3'
+          {
+            component: {
+              name: 'navigation.playground.TopTabScreen',
+              passProps: {
+                title: 'Tab 3',
+                text: 'This is top tab 3'
+              },
+              options: {
+                topTab: {
+                  title: 'Tab 3'
+                }
+              }
             }
           }
-        }
-      ],
+        ]
+      },
       options: {
         topTabs: {
           selectedTabColor: '#12766b',

playground/src/testIDs.js

   PUSH_LIFECYCLE_BUTTON: `PUSH_LIFECYCLE_BUTTON`,
   PUSH_BUTTON: `PUSH_BUTTON`,
   PUSH_OPTIONS_BUTTON: `PUSH_OPTIONS_BUTTON`,
+  PUSH_DEFAULT_OPTIONS_BUTTON: `PUSH_DEFAULT_OPTIONS_BUTTON`,
   BACK_HANDLER_BUTTON: `BACK_HANDLER_BUTTON`,
   SHOW_MODAL_BUTTON: `SHOW_MODAL_BUTTON`,
   SHOW_REDBOX_BUTTON: `SHOW_REDBOX_BUTTON`,