[BREAKING] BottomTabs refactor (#3469)

* Refactored bottomTab and bottomTabs

* Initial commit before switching to our fork of AHBottomNavigation

* Bump AHBottomNavigation version

* More work on BottomTab options

Need to merge some child options when a child is attached to parent

* Fix tests

* DefaultOptions refactor

* defaultOptions are now merged before applying options
* Handle BottomTab options in dedicated presenter
* Create BottomTabs in BottomTabsController.createView() instead of constructor

* Set bottomTab TypeFace

* Update Android installation guide

* fixed unit tests

* Fix unit tests

Kind of a workaround

* Handle NPE in getPreferredHeight

If a view hasn't been attached yet, return 0 height

* Apply BottomTab text and icon color individually

wix-playground/AHBottomNavigation does not support setting color for the entire tab (icon and text),
instead it supports setting color individually to text and icon. Another change is that it no longer supports
default color for icons. If icon color is undefined - it won't tint the icon.

* Add getCurrentChild to ParentController contract

* Clear backButton when setting stack root

* Add  ViewController.resolveCurrentOptions

resolveCurrentOptions merges the controllers options with all of its current children

* StackController refactor

* Create pushed child view only in StackController.createView
* When initialising a stack with multiple children, only create the top child's view
* StackController constructor now accepts children
* When pushing child to stack, apply options that change LayoutParams

* Apply BottomTabs layout options when tab views are created

* bototmTab changes in iOS

* options fix

* Fixes options propagating

docs/docs/Installing.md

 	           // All of React Native (JS, Obj-C sources, Android binaries) is installed from npm
 	           url "$rootDir/../node_modules/react-native/android"
 			}
+  +		maven { url 'https://jitpack.io' }
 		}
 	}
 	```

docs/docs/styling.md

     currentTabId: 'currentTabId',
     testID: 'bottomTabsTestID',
     drawBehind: false,
-    backgroundColor: 'white',
-    tabColor: 'red',
-    selectedTabColor: 'blue',
-    fontFamily: 'Helvetica',
-    fontSize: 10
+    backgroundColor: 'white'
   },
   bottomTab: {
     title: 'Tab 1',
     badge: '2',
     testID: 'bottomTabTestID',
-    icon: require('tab.png')
+    icon: require('tab.png'),
+    iconColor: 'red',
+    selectedIconColor: 'blue',
+    textColor: 'red',
+    selectedTextColor: 'blue',
+    fontFamily: 'Helvetica',
+    fontSize: 10
   },
   sideMenu: {
     left: {

lib/android/app/build.gradle

         p.android.compileOptions.sourceCompatibility JavaVersion.VERSION_1_8
         p.android.compileOptions.targetCompatibility JavaVersion.VERSION_1_8
     }
+    p.repositories {
+        maven { url "https://jitpack.io" }
+    }
 }
 
 dependencies {
     implementation 'com.android.support:design:26.1.0'
     implementation 'com.android.support:appcompat-v7:26.1.0'
     implementation 'com.android.support:support-v4:26.1.0'
-    implementation 'com.aurelhubert:ahbottomnavigation:2.1.0'
+    implementation 'com.github.wix-playground:ahbottomnavigation:2.4.3'
+
     implementation 'com.github.clans:fab:1.6.4'
 
     //noinspection GradleDynamicVersion

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

 package com.reactnativenavigation.parse;
 
+import android.graphics.Typeface;
+import android.support.annotation.Nullable;
+
+import com.reactnativenavigation.parse.params.Color;
+import com.reactnativenavigation.parse.params.NullColor;
 import com.reactnativenavigation.parse.params.NullText;
 import com.reactnativenavigation.parse.params.Text;
+import com.reactnativenavigation.parse.parsers.ColorParser;
 import com.reactnativenavigation.parse.parsers.TextParser;
+import com.reactnativenavigation.utils.TypefaceLoader;
 
 import org.json.JSONObject;
 
 public class BottomTabOptions {
 
-    public static BottomTabOptions parse(JSONObject json) {
+    public static BottomTabOptions parse(TypefaceLoader typefaceManager, JSONObject json) {
         BottomTabOptions options = new BottomTabOptions();
         if (json == null) return options;
 
-        options.title = TextParser.parse(json, "title");
-        if (json.has("icon")) {
-            options.icon = TextParser.parse(json.optJSONObject("icon"), "uri");
-        }
+        options.text = TextParser.parse(json, "text");
+        options.textColor = ColorParser.parse(json, "textColor");
+        options.selectedTextColor = ColorParser.parse(json, "selectedTextColor");
+        if (json.has("icon")) options.icon = TextParser.parse(json.optJSONObject("icon"), "uri");
+        options.iconColor = ColorParser.parse(json, "iconColor");
+        options.selectedIconColor = ColorParser.parse(json, "selectedIconColor");
         options.badge = TextParser.parse(json, "badge");
         options.testId = TextParser.parse(json, "testID");
+        options.fontFamily = typefaceManager.getTypeFace(json.optString("fontFamily", ""));
         return options;
     }
 
-    public Text title = new NullText();
+    public Text text = new NullText();
+    public Color textColor = new NullColor();
+    public Color selectedTextColor = new NullColor();
     public Text icon = new NullText();
+    public Color iconColor = new NullColor();
+    public Color selectedIconColor = new NullColor();
     public Text testId = new NullText();
     public Text badge = new NullText();
+    @Nullable public Typeface fontFamily;
+
 
     void mergeWith(final BottomTabOptions other) {
-        if (other.title.hasValue()) {
-            title = other.title;
-        }
-        if (other.icon.hasValue()) {
-            icon = other.icon;
-        }
-        if (other.badge.hasValue()) {
-            badge = other.badge;
-        }
-        if (other.testId.hasValue()) {
-            testId = other.testId;
-        }
+        if (other.text.hasValue()) text = other.text;
+        if (other.textColor.hasValue()) textColor = other.textColor;
+        if (other.selectedTextColor.hasValue()) selectedTextColor = other.selectedTextColor;
+        if (other.icon.hasValue()) icon = other.icon;
+        if (other.iconColor.hasValue()) iconColor = other.iconColor;
+        if (other.selectedIconColor.hasValue()) selectedIconColor = other.selectedIconColor;
+        if (other.badge.hasValue()) badge = other.badge;
+        if (other.testId.hasValue()) testId = other.testId;
+        if (other.fontFamily != null) fontFamily = other.fontFamily;
     }
 
     void mergeWithDefault(final BottomTabOptions defaultOptions) {
-        if (!title.hasValue()) {
-            title = defaultOptions.title;
-        }
-        if (!icon.hasValue()) {
-            icon = defaultOptions.icon;
-        }
-        if (!badge.hasValue()) {
-            badge = defaultOptions.badge;
-        }
+        if (!text.hasValue()) text = defaultOptions.text;
+        if (!textColor.hasValue()) textColor = defaultOptions.textColor;
+        if (!selectedTextColor.hasValue()) selectedTextColor = defaultOptions.selectedTextColor;
+        if (!icon.hasValue()) icon = defaultOptions.icon;
+        if (!iconColor.hasValue()) iconColor = defaultOptions.iconColor;
+        if (!selectedIconColor.hasValue()) selectedIconColor = defaultOptions.selectedIconColor;
+        if (!badge.hasValue()) badge = defaultOptions.badge;
+        if (fontFamily == null) fontFamily = defaultOptions.fontFamily;
     }
 }

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

 		if (json == null) return options;
 
         options.backgroundColor = ColorParser.parse(json, "backgroundColor");
-        options.tabColor = ColorParser.parse(json, "tabColor");
-        options.selectedTabColor = ColorParser.parse(json, "selectedTabColor");
         options.currentTabId = TextParser.parse(json, "currentTabId");
 		options.currentTabIndex = NumberParser.parse(json,"currentTabIndex");
 		options.visible = BoolParser.parse(json,"visible");
 	}
 
     public Color backgroundColor = new NullColor();
-    public Color tabColor = new NullColor();
-    public Color selectedTabColor = new NullColor();
 	public Bool visible = new NullBool();
     public Bool drawBehind = new NullBool();
 	public Bool animate = new NullBool();
 		if (other.visible.hasValue()) visible = other.visible;
         if (other.drawBehind.hasValue()) drawBehind = other.drawBehind;
 		if (other.animate.hasValue()) animate = other.animate;
-        if (other.tabColor.hasValue()) tabColor = other.tabColor;
-        if (other.selectedTabColor.hasValue()) selectedTabColor = other.selectedTabColor;
         if (other.backgroundColor.hasValue()) backgroundColor = other.backgroundColor;
         if (other.testId.hasValue()) testId = other.testId;
         if (other.titleDisplayMode.hasValue()) titleDisplayMode = other.titleDisplayMode;
         if (!visible.hasValue()) visible = defaultOptions.visible;
         if (!drawBehind.hasValue()) drawBehind = defaultOptions.drawBehind;
         if (!animate.hasValue()) animate = defaultOptions.animate;
-        if (!tabColor.hasValue()) tabColor = defaultOptions.tabColor;
-        if (!selectedTabColor.hasValue()) selectedTabColor = defaultOptions.selectedTabColor;
         if (!backgroundColor.hasValue()) backgroundColor = defaultOptions.backgroundColor;
         if (!titleDisplayMode.hasValue()) titleDisplayMode = defaultOptions.titleDisplayMode;
     }

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

 import android.app.Activity;
 
 import com.facebook.react.ReactInstanceManager;
+import com.reactnativenavigation.presentation.BottomTabOptionsPresenter;
+import com.reactnativenavigation.presentation.BottomTabsOptionsPresenter;
+import com.reactnativenavigation.presentation.OptionsPresenter;
+import com.reactnativenavigation.presentation.StackOptionsPresenter;
 import com.reactnativenavigation.react.EventEmitter;
-import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.utils.ImageLoader;
 import com.reactnativenavigation.utils.TypefaceLoader;
 import com.reactnativenavigation.viewcontrollers.ChildControllersRegistry;
 import com.reactnativenavigation.viewcontrollers.ComponentViewController;
 import com.reactnativenavigation.viewcontrollers.SideMenuController;
-import com.reactnativenavigation.viewcontrollers.stack.StackController;
-import com.reactnativenavigation.viewcontrollers.stack.StackControllerBuilder;
 import com.reactnativenavigation.viewcontrollers.ViewController;
 import com.reactnativenavigation.viewcontrollers.bottomtabs.BottomTabsController;
 import com.reactnativenavigation.viewcontrollers.externalcomponent.ExternalComponentCreator;
 import com.reactnativenavigation.viewcontrollers.externalcomponent.ExternalComponentViewController;
+import com.reactnativenavigation.viewcontrollers.stack.StackControllerBuilder;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import com.reactnativenavigation.viewcontrollers.toptabs.TopTabsController;
 import java.util.List;
 import java.util.Map;
 
+import static com.reactnativenavigation.parse.Options.parse;
+
 public class LayoutFactory {
 
 	private final Activity activity;
 	}
 
     private ViewController createSideMenuRoot(LayoutNode node) {
-		SideMenuController sideMenuController = new SideMenuController(activity, childRegistry, node.id, parseNodeOptions(node));
+		SideMenuController sideMenuController = new SideMenuController(activity,
+                childRegistry,
+                node.id,
+                parse(typefaceManager, node.getOptions()),
+                new OptionsPresenter(activity, defaultOptions)
+        );
 		ViewController childControllerCenter = null, childControllerLeft = null, childControllerRight = null;
 
 		for (LayoutNode child : node.children) {
 			}
 		}
 
-		// Need to set the center controller first, otherwise "onPress" events on the JS components
-		// of the left and right drawers are not handled properly.
-		//
-		// See https://github.com/wix/react-native-navigation/issues/2835
-		//
 		if (childControllerCenter != null) {
 			sideMenuController.setCenterController(childControllerCenter);
 		}
                 id,
                 name,
                 new ComponentViewCreator(reactInstanceManager),
-                parseNodeOptions(node)
+                parse(typefaceManager, node.getOptions()),
+                new OptionsPresenter(activity, defaultOptions)
         );
 	}
 
                 externalComponent,
                 externalComponentCreators.get(externalComponent.name.get()),
                 reactInstanceManager,
-                parseNodeOptions(node)
+                parse(typefaceManager, node.getOptions())
         );
     }
 
 	private ViewController createStack(LayoutNode node) {
-        StackController stackController = new StackControllerBuilder(activity)
+        return new StackControllerBuilder(activity)
+                .setChildren(createChildredn(node.children))
                 .setChildRegistry(childRegistry)
                 .setTopBarButtonCreator(new TitleBarButtonCreator(reactInstanceManager))
                 .setTitleBarReactViewCreator(new TitleBarReactViewCreator(reactInstanceManager))
                 .setTopBarBackgroundViewController(new TopBarBackgroundViewController(activity, new TopBarBackgroundViewCreator(reactInstanceManager)))
                 .setTopBarController(new TopBarController())
                 .setId(node.id)
-                .setInitialOptions(parseNodeOptions(node))
+                .setInitialOptions(parse(typefaceManager, node.getOptions()))
+                .setOptionsPresenter(new OptionsPresenter(activity, defaultOptions))
+                .setStackPresenter(new StackOptionsPresenter(activity, defaultOptions))
                 .build();
-        addChildrenToStack(node.children, stackController);
-        return stackController;
 	}
 
-    private void addChildrenToStack(List<LayoutNode> children, StackController stackController) {
+    private List<ViewController> createChildredn(List<LayoutNode> children) {
+        List<ViewController> result = new ArrayList<>();
         for (LayoutNode child : children) {
-            stackController.push(create(child), new CommandListenerAdapter());
+            result.add(create(child));
         }
+        return result;
     }
 
     private ViewController createBottomTabs(LayoutNode node) {
         for (int i = 0; i < node.children.size(); i++) {
             tabs.add(create(node.children.get(i)));
         }
-        return new BottomTabsController(activity, tabs, childRegistry, eventEmitter, new ImageLoader(), node.id, parseNodeOptions(node));
+        return new BottomTabsController(activity,
+                tabs,
+                childRegistry,
+                eventEmitter,
+                new ImageLoader(),
+                node.id,
+                parse(typefaceManager, node.getOptions()),
+                new OptionsPresenter(activity, defaultOptions),
+                new BottomTabsOptionsPresenter(tabs, defaultOptions),
+                new BottomTabOptionsPresenter(activity, tabs, defaultOptions));
 	}
 
     private ViewController createTopTabs(LayoutNode node) {
         final List<ViewController> tabs = new ArrayList<>();
         for (int i = 0; i < node.children.size(); i++) {
             ViewController tabController = create(node.children.get(i));
-            Options options = parseNodeOptions(node.children.get(i));
+            Options options = parse(typefaceManager, node.children.get(i).getOptions());
             options.setTopTabIndex(i);
             tabs.add(tabController);
         }
-        return new TopTabsController(activity, childRegistry, node.id, tabs, new TopTabsLayoutCreator(activity, tabs), parseNodeOptions(node));
-    }
-
-    private Options parseNodeOptions(LayoutNode node) {
-        return Options.parse(typefaceManager, node.getNavigationOptions(), defaultOptions);
+        return new TopTabsController(activity, childRegistry, node.id, tabs, new TopTabsLayoutCreator(activity, tabs), parse(typefaceManager, node.getOptions()), new OptionsPresenter(activity, defaultOptions));
     }
 }

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

 		this.children = children;
 	}
 
-    JSONObject getNavigationOptions() {
+    JSONObject getOptions() {
 	    return data.optJSONObject("options");
     }
 }

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

 
     @NonNull
     public static Options parse(TypefaceLoader typefaceManager, JSONObject json) {
-        return parse(typefaceManager, json, new Options());
-    }
-
-    @NonNull
-    public static Options parse(TypefaceLoader typefaceManager, JSONObject json, @NonNull Options defaultOptions) {
         Options result = new Options();
-        if (json == null) return result.withDefaultOptions(defaultOptions);
+        if (json == null) return result;
 
         result.topBar = TopBarOptions.parse(typefaceManager, json.optJSONObject("topBar"));
         result.topTabs = TopTabsOptions.parse(json.optJSONObject("topTabs"));
         result.topTabOptions = TopTabOptions.parse(typefaceManager, json.optJSONObject("topTab"));
-        result.bottomTabOptions = BottomTabOptions.parse(json.optJSONObject("bottomTab"));
+        result.bottomTabOptions = BottomTabOptions.parse(typefaceManager, json.optJSONObject("bottomTab"));
         result.bottomTabsOptions = BottomTabsOptions.parse(json.optJSONObject("bottomTabs"));
         result.overlayOptions = OverlayOptions.parse(json.optJSONObject("overlay"));
         result.fabOptions = FabOptions.parse(json.optJSONObject("fab"));
         result.statusBar = StatusBarOptions.parse(json.optJSONObject("statusBar"));
         result.layout = LayoutOptions.parse(json.optJSONObject("layout"));
 
-        return result.withDefaultOptions(defaultOptions);
+        return result;
     }
 
     @NonNull public TopBarOptions topBar = new TopBarOptions();
         return result;
     }
 
-    Options withDefaultOptions(final Options defaultOptions) {
+    public Options withDefaultOptions(final Options defaultOptions) {
         topBar.mergeWithDefault(defaultOptions.topBar);
         topTabOptions.mergeWithDefault(defaultOptions.topTabOptions);
         topTabs.mergeWithDefault(defaultOptions.topTabs);

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

 package com.reactnativenavigation.parse;
 
+import android.support.annotation.CheckResult;
+
 import com.reactnativenavigation.parse.params.Orientation;
 
 import org.json.JSONArray;
         return !orientations.isEmpty();
     }
 
+    @CheckResult
+    public OrientationOptions copy() {
+        OrientationOptions result = new OrientationOptions();
+        result.orientations = new ArrayList<>(orientations);
+        return result;
+    }
+
+    public OrientationOptions mergeWithDefault(OrientationOptions defaultOptions) {
+        if (!hasValue()) orientations = defaultOptions.orientations;
+        return this;
+    }
+
     @Override
     public String toString() {
         return hasValue() ? Arrays.toString(orientations.toArray(new Orientation[0])) : Orientation.Default.toString();

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

+package com.reactnativenavigation.presentation;
+
+import android.content.Context;
+import android.support.annotation.VisibleForTesting;
+import android.support.v4.content.ContextCompat;
+
+import com.reactnativenavigation.parse.BottomTabOptions;
+import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.viewcontrollers.ViewController;
+import com.reactnativenavigation.viewcontrollers.bottomtabs.BottomTabFinder;
+import com.reactnativenavigation.views.BottomTabs;
+import com.reactnativenavigation.views.Component;
+
+import java.util.List;
+
+public class BottomTabOptionsPresenter {
+    private Options defaultOptions;
+    private final BottomTabFinder bottomTabFinder;
+    private BottomTabs bottomTabs;
+    private final int defaultSelectedTextColor;
+    private final int defaultTextColor;
+    private final List<ViewController> tabs;
+
+    public BottomTabOptionsPresenter(Context context, List<ViewController> tabs, Options defaultOptions) {
+        this.tabs = tabs;
+        this.bottomTabFinder = new BottomTabFinder(tabs);
+        this.defaultOptions = defaultOptions;
+        defaultSelectedTextColor = defaultOptions.bottomTabOptions.selectedIconColor.get(ContextCompat.getColor(context, com.aurelhubert.ahbottomnavigation.R.color.colorBottomNavigationAccent));
+        defaultTextColor = defaultOptions.bottomTabOptions.iconColor.get(ContextCompat.getColor(context, com.aurelhubert.ahbottomnavigation.R.color.colorBottomNavigationInactive));
+    }
+
+    public void setDefaultOptions(Options defaultOptions) {
+        this.defaultOptions = defaultOptions;
+    }
+
+    public void bindView(BottomTabs bottomTabs) {
+        this.bottomTabs = bottomTabs;
+    }
+
+    public void present() {
+        for (int i = 0; i < tabs.size(); i++) {
+            BottomTabOptions bottomTab = tabs.get(i).options.copy().withDefaultOptions(defaultOptions).bottomTabOptions;
+            bottomTabs.setBadge(i, bottomTab.badge.get(""));
+            bottomTabs.setTitleTypeface(i, bottomTab.fontFamily);
+            bottomTabs.setIconActiveColor(i, bottomTab.selectedIconColor.get(null));
+            bottomTabs.setIconInactiveColor(i, bottomTab.iconColor.get(null));
+            bottomTabs.setTitleActiveColor(i, bottomTab.selectedTextColor.get(null));
+            bottomTabs.setTitleInactiveColor(i, bottomTab.textColor.get(null));
+        }
+    }
+
+    public void mergeChildOptions(Options options, Component child) {
+        BottomTabOptions withDefaultOptions = options.withDefaultOptions(defaultOptions).bottomTabOptions;
+        int index = bottomTabFinder.findByComponent(child);
+        if (withDefaultOptions.badge.hasValue()) bottomTabs.setBadge(index, withDefaultOptions.badge.get());
+        if (withDefaultOptions.fontFamily != null) bottomTabs.setTitleTypeface(index, withDefaultOptions.fontFamily);
+        if (withDefaultOptions.selectedIconColor.hasValue()) bottomTabs.setIconActiveColor(index, withDefaultOptions.selectedIconColor.get());
+        if (withDefaultOptions.iconColor.hasValue()) bottomTabs.setIconInactiveColor(index, withDefaultOptions.iconColor.get());
+        if (withDefaultOptions.selectedTextColor.hasValue()) bottomTabs.setTitleActiveColor(index, withDefaultOptions.selectedTextColor.get());
+        if (withDefaultOptions.textColor.hasValue()) bottomTabs.setTitleInactiveColor(index, withDefaultOptions.textColor.get());
+    }
+
+    @VisibleForTesting
+    public int getDefaultSelectedTextColor() {
+        return defaultSelectedTextColor;
+    }
+
+    @VisibleForTesting
+    public int getDefaultTextColor() {
+        return defaultTextColor;
+    }
+}

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

 package com.reactnativenavigation.presentation;
 
+import android.view.ViewGroup;
 import android.view.ViewGroup.MarginLayoutParams;
 
 import com.reactnativenavigation.anim.BottomTabsAnimator;
 import com.reactnativenavigation.parse.AnimationsOptions;
-import com.reactnativenavigation.parse.BottomTabOptions;
 import com.reactnativenavigation.parse.BottomTabsOptions;
 import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.utils.UiUtils;
 import com.reactnativenavigation.viewcontrollers.ViewController;
 import com.reactnativenavigation.viewcontrollers.bottomtabs.BottomTabFinder;
 import com.reactnativenavigation.viewcontrollers.bottomtabs.TabSelector;
 import java.util.List;
 
 public class BottomTabsOptionsPresenter {
-    private final BottomTabs bottomTabs;
-    private final TabSelector tabSelector;
     private final BottomTabFinder bottomTabFinder;
-    private final BottomTabsAnimator animator;
     private final List<ViewController> tabs;
+    private Options defaultOptions;
+    private BottomTabs bottomTabs;
+    private BottomTabsAnimator animator;
+    private TabSelector tabSelector;
 
-    public BottomTabsOptionsPresenter(BottomTabs bottomTabs, List<ViewController> tabs, TabSelector tabSelector, BottomTabFinder bottomTabFinder) {
-        this.bottomTabs = bottomTabs;
+    public BottomTabsOptionsPresenter(List<ViewController> tabs, Options defaultOptions) {
         this.tabs = tabs;
+        this.defaultOptions = defaultOptions;
+        this.bottomTabFinder = new BottomTabFinder(tabs);
+    }
+
+    public void setDefaultOptions(Options defaultOptions) {
+        this.defaultOptions = defaultOptions;
+    }
+
+    public void bindView(BottomTabs bottomTabs, TabSelector tabSelector) {
+        this.bottomTabs = bottomTabs;
         this.tabSelector = tabSelector;
-        this.bottomTabFinder = bottomTabFinder;
         animator = new BottomTabsAnimator(bottomTabs);
     }
 
+    public void applyLayoutParamsOptions(Options options, int tabIndex) {
+        Options withDefaultOptions = options.copy().withDefaultOptions(defaultOptions);
+        applyDrawBehind(withDefaultOptions.bottomTabsOptions, tabIndex);
+    }
+
     public void present(Options options) {
-        applyBottomTabsOptions(options.bottomTabsOptions, options.animations);
+        Options withDefaultOptions = options.copy().withDefaultOptions(defaultOptions);
+        applyBottomTabsOptions(withDefaultOptions.bottomTabsOptions, withDefaultOptions.animations);
     }
 
     public void presentChildOptions(Options options, Component child) {
-        applyBottomTabsOptions(options.bottomTabsOptions, options.animations);
+        Options withDefaultOptions = options.copy().withDefaultOptions(defaultOptions);
+        applyBottomTabsOptions(withDefaultOptions.bottomTabsOptions, withDefaultOptions.animations);
         int tabIndex = bottomTabFinder.findByComponent(child);
-        applyBottomTabOptions(options.bottomTabOptions, tabIndex);
-        applyDrawBehind(options.bottomTabsOptions, tabIndex);
-    }
-
-    private void applyBottomTabOptions(BottomTabOptions options, int tabIndex) {
-        if (options.badge.hasValue()) {
-            bottomTabs.setBadge(tabIndex, options.badge);
-        }
+        applyDrawBehind(withDefaultOptions.bottomTabsOptions, tabIndex);
     }
 
     private void applyDrawBehind(BottomTabsOptions options, int tabIndex) {
-        MarginLayoutParams lp = (MarginLayoutParams) tabs.get(tabIndex).getView().getLayoutParams();
+        ViewGroup tab = tabs.get(tabIndex).getView();
+        MarginLayoutParams lp = (MarginLayoutParams) tab.getLayoutParams();
         if (options.drawBehind.isTrue()) {
             lp.bottomMargin = 0;
         }
         if (options.visible.isTrueOrUndefined() && options.drawBehind.isFalseOrUndefined()) {
-            lp.bottomMargin = bottomTabs.getHeight();
+            if (bottomTabs.getHeight() == 0) {
+                UiUtils.runOnPreDrawOnce(bottomTabs, () -> lp.bottomMargin = bottomTabs.getHeight());
+            } else {
+                lp.bottomMargin = bottomTabs.getHeight();
+            }
         }
     }
 
         if (options.testId.hasValue()) {
             bottomTabs.setTag(options.testId.get());
         }
-        if (options.selectedTabColor.hasValue()) {
-            bottomTabs.setAccentColor(options.selectedTabColor.get());
-        }
-        if (options.tabColor.hasValue()) {
-            bottomTabs.setInactiveColor(options.tabColor.get());
-        }
         if (options.currentTabId.hasValue()) {
             int tabIndex = bottomTabFinder.findByControllerId(options.currentTabId.get());
             if (tabIndex >= 0) tabSelector.selectTab(tabIndex);

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

 import android.graphics.Color;
 import android.os.Build;
 import android.view.View;
+import android.view.ViewGroup;
 import android.view.ViewGroup.MarginLayoutParams;
 
 import com.reactnativenavigation.parse.Options;
 public class OptionsPresenter {
 
     private Activity activity;
+    private Options defaultOptions;
 
-    public OptionsPresenter(Activity activity) {
+    public OptionsPresenter(Activity activity, Options defaultOptions) {
         this.activity = activity;
+        this.defaultOptions = defaultOptions;
+    }
+
+    public void setDefaultOptions(Options defaultOptions) {
+        this.defaultOptions = defaultOptions;
+    }
+
+    public void applyLayoutOptions(ViewGroup.LayoutParams layoutParams) {
+
     }
 
     public void present(View view, Options options) {
-        applyOrientation(options.layout.orientation);
-        applyViewOptions(view, options);
-        applyStatusBarOptions(view, options.statusBar);
+        Options withDefaultOptions = options.copy().withDefaultOptions(defaultOptions);
+        applyOrientation(withDefaultOptions.layout.orientation);
+        applyViewOptions(view, withDefaultOptions);
+        applyStatusBarOptions(view, withDefaultOptions.statusBar);
     }
 
     public void applyRootOptions(View view, Options options) {
-        setDrawBehindStatusBar(view, options.statusBar);
+        Options withDefaultOptions = options.copy().withDefaultOptions(defaultOptions);
+        setDrawBehindStatusBar(view, withDefaultOptions.statusBar);
+    }
+
+    public void onViewBroughtToFront(View view, Options options) {
+        Options withDefaultOptions = options.copy().withDefaultOptions(defaultOptions);
+        applyStatusBarOptions(view, withDefaultOptions.statusBar);
     }
 
     private void applyOrientation(OrientationOptions options) {
         }
     }
 
-    public void onViewBroughtToFront(View view, Options options) {
-        applyStatusBarOptions(view, options.statusBar);
-    }
-
     private void applyStatusBarOptions(View view, StatusBarOptions statusBar) {
         setStatusBarBackgroundColor(statusBar);
         setTextColorScheme(statusBar.textColorScheme);

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

 package com.reactnativenavigation.presentation;
 
 import android.app.Activity;
+import android.content.Context;
 import android.graphics.Color;
+import android.view.View;
 import android.view.ViewGroup.LayoutParams;
 
 import com.reactnativenavigation.parse.AnimationsOptions;
     private final double defaultSubtitleFontSize;
 
     private TopBar topBar;
+    private Options defaultOptions;
 
-    public StackOptionsPresenter(TopBar topBar) {
+    public StackOptionsPresenter(Context context, Options defaultOptions) {
+        defaultTitleFontSize = UiUtils.dpToSp(context, 18);
+        defaultSubtitleFontSize = UiUtils.dpToSp(context, 14);
+        this.defaultOptions = defaultOptions;
+    }
+
+    public void setDefaultOptions(Options defaultOptions) {
+        this.defaultOptions = defaultOptions;
+    }
+
+    public void bindView(TopBar topBar) {
         this.topBar = topBar;
-        defaultTitleFontSize = UiUtils.dpToSp(topBar.getContext(), 18);
-        defaultSubtitleFontSize = UiUtils.dpToSp(topBar.getContext(), 14);
+    }
+
+    public void applyLayoutParamsOptions(Options options, View view) {
+        Options withDefaultOptions = options.copy().withDefaultOptions(defaultOptions);
+        if (view instanceof Component) {
+            if (withDefaultOptions.topBar.drawBehind.isTrue() && !withDefaultOptions.layout.topMargin.hasValue()) {
+                ((Component) view).drawBehindTopBar();
+            } else if (options.topBar.drawBehind.isFalseOrUndefined()) {
+                ((Component) view).drawBelowTopBar(topBar);
+            }
+        }
     }
 
     public void applyChildOptions(Options options, Component child) {
-        applyOrientation(options.layout.orientation);
-        applyButtons(options.topBar.buttons);
-        applyTopBarOptions(options.topBar, options.animations, child, options);
-        applyTopTabsOptions(options.topTabs);
-        applyTopTabOptions(options.topTabOptions);
+        Options withDefaultOptions = options.copy().withDefaultOptions(defaultOptions);
+        applyOrientation(withDefaultOptions.layout.orientation);
+        applyButtons(withDefaultOptions.topBar.buttons);
+        applyTopBarOptions(withDefaultOptions.topBar, withDefaultOptions.animations, child, options);
+        applyTopTabsOptions(withDefaultOptions.topTabs);
+        applyTopTabOptions(withDefaultOptions.topTabOptions);
     }
 
     public void applyOrientation(OrientationOptions options) {
-        ((Activity) topBar.getContext()).setRequestedOrientation(options.getValue());
+        OrientationOptions withDefaultOptions = options.copy().mergeWithDefault(defaultOptions.layout.orientation);
+        ((Activity) topBar.getContext()).setRequestedOrientation(withDefaultOptions.getValue());
     }
 
     private void applyTopBarOptions(TopBarOptions options, AnimationsOptions animationOptions, Component component, Options componentOptions) {
     }
 
     public void mergeChildOptions(Options options, Component child) {
-        mergeOrientation(options.layout.orientation);
-        mergeButtons(options.topBar.buttons);
-        mergeTopBarOptions(options.topBar, options.animations, child);
-        mergeTopTabsOptions(options.topTabs);
-        mergeTopTabOptions(options.topTabOptions);
+        Options withDefaultOptions = options.copy().withDefaultOptions(defaultOptions);
+        mergeOrientation(withDefaultOptions.layout.orientation);
+        mergeButtons(withDefaultOptions.topBar.buttons);
+        mergeTopBarOptions(withDefaultOptions.topBar, withDefaultOptions.animations, child);
+        mergeTopTabsOptions(withDefaultOptions.topTabs);
+        mergeTopTabOptions(withDefaultOptions.topTabOptions);
     }
 
     private void mergeOrientation(OrientationOptions orientationOptions) {

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

     }
 
     public static int getPreferredHeight(View view) {
+        if (view.getLayoutParams() == null) return 0;
         return view.getLayoutParams().height < 0 ? view.getHeight() : view.getLayoutParams().height;
     }
 }

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

         this.childRegistry = childRegistry;
     }
 
+    @Override
+    public void setDefaultOptions(Options defaultOptions) {
+        presenter.setDefaultOptions(defaultOptions);
+    }
+
     @Override
     public void onViewAppeared() {
         super.onViewAppeared();

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

                                    final String id,
                                    final String componentName,
                                    final ReactViewCreator viewCreator,
-                                   final Options initialOptions) {
-        super(activity, childRegistry, id, new OptionsPresenter(activity), initialOptions);
+                                   final Options initialOptions,
+                                   final OptionsPresenter presenter) {
+        super(activity, childRegistry, id, presenter, initialOptions);
         this.componentName = componentName;
         this.viewCreator = viewCreator;
     }

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

     private final OverlayManager overlayManager;
     private Options defaultOptions = new Options();
 
+    @Override
     public void setDefaultOptions(Options defaultOptions) {
         this.defaultOptions = defaultOptions;
+        if (root != null) root.setDefaultOptions(defaultOptions);
     }
 
     public Options getDefaultOptions() {
     }
 
     public Navigator(final Activity activity, ChildControllersRegistry childRegistry, OverlayManager overlayManager) {
-        super(activity, childRegistry,"navigator" + CompatUtils.generateViewId(), new OptionsPresenter(activity), new Options());
+        super(activity, childRegistry,"navigator" + CompatUtils.generateViewId(), new OptionsPresenter(activity, new Options()), new Options());
         modalStack = new ModalStack(new ModalPresenter(new ModalAnimator(activity)));
         this.overlayManager = overlayManager;
     }
         return modalStack.handleBack(listener, root);
     }
 
+    @Override
+    protected ViewController getCurrentChild() {
+        return root;
+    }
+
     @Override
     public void onReload() {
         destroyViews();

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

 
 import android.app.Activity;
 import android.support.annotation.CallSuper;
+import android.support.annotation.CheckResult;
 import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
 import android.support.v4.view.ViewPager;
 
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.presentation.OptionsPresenter;
+import com.reactnativenavigation.utils.CollectionUtils;
 import com.reactnativenavigation.views.Component;
 
 import java.util.Collection;
 		super(activity, childRegistry, id, presenter, initialOptions);
 	}
 
-	@NonNull
+	@Override
+    public void setDefaultOptions(Options defaultOptions) {
+        Collection<? extends ViewController> children = getChildControllers();
+        if (!CollectionUtils.isNullOrEmpty(children)) {
+            for (ViewController child : children) {
+                child.setDefaultOptions(defaultOptions);
+            }
+        }
+    }
+
+    @Override
+    @CheckResult
+    public Options resolveCurrentOptions() {
+	    if (CollectionUtils.isNullOrEmpty(getChildControllers())) return options;
+        Options o = getCurrentChild().resolveCurrentOptions();
+        return o.copy().mergeWith(options);
+    }
+
+    protected abstract ViewController getCurrentChild();
+
+    @NonNull
 	@Override
 	public T getView() {
 		return (T) super.getView();

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

 	private ViewController leftController;
 	private ViewController rightController;
 
-	public SideMenuController(Activity activity, ChildControllersRegistry childRegistry, String id, Options initialOptions) {
-		super(activity, childRegistry, id, new OptionsPresenter(activity), initialOptions);
+	public SideMenuController(Activity activity, ChildControllersRegistry childRegistry, String id, Options initialOptions, OptionsPresenter presenter) {
+		super(activity, childRegistry, id, presenter, initialOptions);
 	}
 
-	@NonNull
+    @Override
+    protected ViewController getCurrentChild() {
+	    if (getView().isDrawerOpen(Gravity.LEFT)) {
+            return leftController;
+        } else if (getView().isDrawerOpen(Gravity.RIGHT)) {
+            return rightController;
+        }
+        return centerController;
+    }
+
+    @NonNull
 	@Override
 	protected DrawerLayout createView() {
         return new DrawerLayout(getActivity());

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

 
 import android.app.Activity;
 import android.support.annotation.CallSuper;
+import android.support.annotation.CheckResult;
 import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
 import android.support.annotation.VisibleForTesting;
         return false;
     }
 
+    @CheckResult
+    public Options resolveCurrentOptions() {
+        return options;
+    }
+
     @CallSuper
     public void mergeOptions(Options options) {
         this.options = this.options.mergeWith(options);
 
     }
 
+    public void setDefaultOptions(Options defaultOptions) {
+        
+    }
+
     public Activity getActivity() {
         return activity;
     }

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/bottomtabs/BottomTabFinder.java

 public class BottomTabFinder {
     private List<ViewController> tabs;
 
+    public BottomTabFinder(List<ViewController> tabs) {
+        this.tabs = tabs;
+    }
+
     @IntRange(from = -1)
     public int findByComponent(Component component) {
         for (int i = 0; i < tabs.size(); i++) {
         }
         return -1;
     }
-
-    void setTabs(List<ViewController> tabs) {
-        this.tabs = tabs;
-    }
 }

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

 import com.aurelhubert.ahbottomnavigation.AHBottomNavigationItem;
 import com.reactnativenavigation.parse.BottomTabOptions;
 import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.presentation.BottomTabOptionsPresenter;
 import com.reactnativenavigation.presentation.BottomTabsOptionsPresenter;
 import com.reactnativenavigation.presentation.OptionsPresenter;
 import com.reactnativenavigation.react.EventEmitter;
     private EventEmitter eventEmitter;
     private ImageLoader imageLoader;
     private BottomTabsOptionsPresenter presenter;
-    private final BottomTabFinder bottomTabFinder = new BottomTabFinder();
+    private BottomTabOptionsPresenter tabPresenter;
 
-    public BottomTabsController(Activity activity, List<ViewController> tabs, ChildControllersRegistry childRegistry, EventEmitter eventEmitter, ImageLoader imageLoader, String id, Options initialOptions) {
-		super(activity, childRegistry, id, new OptionsPresenter(activity), initialOptions);
+    public BottomTabsController(Activity activity, List<ViewController> tabs, ChildControllersRegistry childRegistry, EventEmitter eventEmitter, ImageLoader imageLoader, String id, Options initialOptions, OptionsPresenter presenter, BottomTabsOptionsPresenter bottomTabsPresenter, BottomTabOptionsPresenter bottomTabPresenter) {
+		super(activity, childRegistry, id, presenter, initialOptions);
         this.tabs = tabs;
         this.eventEmitter = eventEmitter;
         this.imageLoader = imageLoader;
-        createTabs(tabs);
+        this.presenter = bottomTabsPresenter;
+        this.tabPresenter = bottomTabPresenter;
     }
 
-	@NonNull
+    @Override
+    public void setDefaultOptions(Options defaultOptions) {
+        super.setDefaultOptions(defaultOptions);
+        presenter.setDefaultOptions(defaultOptions);
+        tabPresenter.setDefaultOptions(defaultOptions);
+    }
+
+    @NonNull
 	@Override
 	protected ViewGroup createView() {
 		RelativeLayout root = new RelativeLayout(getActivity());
 		bottomTabs = new BottomTabs(getActivity());
-        presenter = new BottomTabsOptionsPresenter(bottomTabs, tabs, this, bottomTabFinder);
+        presenter.bindView(bottomTabs, this);
+        tabPresenter.bindView(bottomTabs);
         bottomTabs.setOnTabSelectedListener(this);
 		RelativeLayout.LayoutParams lp = new RelativeLayout.LayoutParams(MATCH_PARENT, WRAP_CONTENT);
 		lp.addRule(ALIGN_PARENT_BOTTOM);
 		root.addView(bottomTabs, lp);
+		createTabs(root);
 		return root;
 	}
 
     public void applyOptions(Options options) {
         super.applyOptions(options);
         presenter.present(options);
+        tabPresenter.present();
     }
 
     @Override
     public void mergeChildOptions(Options options, Component child) {
         super.mergeChildOptions(options, child);
         presenter.presentChildOptions(options, child);
+        tabPresenter.mergeChildOptions(options, child);
         applyOnParentController(parentController ->
                 ((ParentController) parentController).mergeChildOptions(options.copy().clearBottomTabsOptions(), child)
         );
 
     @Override
     public void sendOnNavigationButtonPressed(String buttonId) {
-        getCurrentTab().sendOnNavigationButtonPressed(buttonId);
+        getCurrentChild().sendOnNavigationButtonPressed(buttonId);
     }
 
-    private ViewController getCurrentTab() {
+    @Override
+    protected ViewController getCurrentChild() {
         return tabs.get(bottomTabs.getCurrentItem());
     }
 
         if (wasSelected) return false;
         eventEmitter.emitBottomTabSelected(bottomTabs.getCurrentItem(), index);
         selectTab(index);
-        return true;
+        return false;
 	}
 
-	private void createTabs(final List<ViewController> tabs) {
+	private void createTabs(RelativeLayout root) {
 		if (tabs.size() > 5) {
 			throw new RuntimeException("Too many tabs!");
 		}
-		this.tabs = tabs;
-        bottomTabFinder.setTabs(tabs);
-        getView();
         List<String> icons = new ArrayList<>();
         List<BottomTabOptions> bottomTabOptionsList = new ArrayList<>();
         for (int i = 0; i < tabs.size(); i++) {
             public void onComplete(@NonNull List<Drawable> drawables) {
                 List<AHBottomNavigationItem> tabs = new ArrayList<>();
                 for (int i = 0; i < drawables.size(); i++) {
-                    tabs.add(new AHBottomNavigationItem(bottomTabOptionsList.get(i).title.get(""), drawables.get(i)));
+                    tabs.add(new AHBottomNavigationItem(bottomTabOptionsList.get(i).text.get(""), drawables.get(i)));
                 }
                 bottomTabs.addItems(tabs);
                 bottomTabs.post(() -> {
                         bottomTabs.setTabTestId(i, bottomTabOptionsList.get(i).testId);
                     }
                 });
-                attachTabs();
+                attachTabs(root);
             }
 
             @Override
                 error.printStackTrace();
             }
         });
-
 	}
 
-    private void attachTabs() {
+    private void attachTabs(RelativeLayout root) {
         for (int i = (tabs.size() - 1); i >= 0; i--) {
             ViewGroup tab = tabs.get(i).getView();
+            tab.setLayoutParams(new RelativeLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT));
+            Options options = resolveCurrentOptions();
+            presenter.applyLayoutParamsOptions(options, i);
             if (i != 0) tab.setVisibility(View.INVISIBLE);
-            getView().addView(tab);
+            root.addView(tab);
         }
     }
 

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

 package com.reactnativenavigation.viewcontrollers.stack;
 
 import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.parse.params.Bool;
 import com.reactnativenavigation.viewcontrollers.ViewController;
 
 public class BackButtonHelper {
-    public void addToChild(StackController stack, ViewController child) {
+    public void addToPushedChild(StackController stack, ViewController child) {
         if (stack.size() <= 1 || child.options.topBar.buttons.left != null || child.options.topBar.buttons.back.visible.isFalse()) return;
         Options options = new Options();
         options.topBar.buttons.back.setVisible();
         child.mergeOptions(options);
     }
+
+    public void clear(ViewController child) {
+        if (!child.options.topBar.buttons.back.hasValue()) {
+            child.options.topBar.buttons.back.visible = new Bool(false);
+        }
+    }
 }

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

 import android.support.annotation.RestrictTo;
 import android.support.annotation.VisibleForTesting;
 import android.support.v4.view.ViewPager;
+import android.view.ViewGroup;
+import android.widget.RelativeLayout;
 
 import com.reactnativenavigation.anim.NavigationAnimator;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.presentation.OptionsPresenter;
+import com.reactnativenavigation.presentation.StackOptionsPresenter;
 import com.reactnativenavigation.react.Constants;
 import com.reactnativenavigation.utils.CommandListener;
 import com.reactnativenavigation.utils.CommandListenerAdapter;
 
 import java.util.Collection;
 import java.util.Iterator;
+import java.util.List;
 
 import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
 
     private TopBarBackgroundViewController topBarBackgroundViewController;
     private TopBarController topBarController;
     private BackButtonHelper backButtonHelper;
+    private final StackOptionsPresenter presenter;
 
-    public StackController(Activity activity, ChildControllersRegistry childRegistry, ReactViewCreator topBarButtonCreator, TitleBarReactViewCreator titleBarReactViewCreator, TopBarBackgroundViewController topBarBackgroundViewController, TopBarController topBarController, NavigationAnimator animator, String id, Options initialOptions, BackButtonHelper backButtonHelper) {
-        super(activity, childRegistry, id, new OptionsPresenter(activity), initialOptions);
+    public StackController(Activity activity, List<ViewController> children, ChildControllersRegistry childRegistry, ReactViewCreator topBarButtonCreator, TitleBarReactViewCreator titleBarReactViewCreator, TopBarBackgroundViewController topBarBackgroundViewController, TopBarController topBarController, NavigationAnimator animator, String id, Options initialOptions, BackButtonHelper backButtonHelper, StackOptionsPresenter stackPresenter, OptionsPresenter presenter) {
+        super(activity, childRegistry, id, presenter, initialOptions);
         this.topBarController = topBarController;
         this.topBarButtonCreator = topBarButtonCreator;
         this.titleBarReactViewCreator = titleBarReactViewCreator;
         this.topBarBackgroundViewController = topBarBackgroundViewController;
         this.animator = animator;
         this.backButtonHelper = backButtonHelper;
+        this.presenter = stackPresenter;
+        for (ViewController child : children) {
+            stack.push(child.getId(), child);
+            child.setParentController(this);
+        }
+    }
+
+    @Override
+    public void setDefaultOptions(Options defaultOptions) {
+        super.setDefaultOptions(defaultOptions);
+        presenter.setDefaultOptions(defaultOptions);
+    }
+
+    @Override
+    protected ViewController getCurrentChild() {
+        return stack.peek();
     }
 
     @Override
     public void applyChildOptions(Options options, Component child) {
         super.applyChildOptions(options, child);
-        getView().applyChildOptions(this.options, child);
+        presenter.applyChildOptions(options, child);
         if (child instanceof ReactComponent) {
             fabOptionsPresenter.applyOptions(this.options.fabOptions, (ReactComponent) child, getView());
         }
     @Override
     public void mergeChildOptions(Options options, Component child) {
         super.mergeChildOptions(options, child);
-        getView().mergeChildOptions(options, child);
+        presenter.mergeChildOptions(options, child);
         animator.mergeOptions(options.animations);
         if (options.fabOptions.hasValue() && child instanceof ReactComponent) {
             fabOptionsPresenter.mergeOptions(options.fabOptions, (ReactComponent) child, getView());
         final ViewController toRemove = stack.peek();
         child.setParentController(this);
         stack.push(child.getId(), child);
-        addBackButton(child);
-        getView().addView(child.getView(), MATCH_PARENT, MATCH_PARENT);
+        backButtonHelper.addToPushedChild(this, child);
+        ViewGroup childView = child.getView();
+        childView.setLayoutParams(new RelativeLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT));
+        presenter.applyLayoutParamsOptions(resolveCurrentOptions(), childView);
+        getView().addView(childView);
 
         if (toRemove != null) {
             if (child.options.animations.push.enable.isTrueOrUndefined()) {
         }
     }
 
-    private void addBackButton(ViewController child) {
-        backButtonHelper.addToChild(this, child);
-    }
-
     public void setRoot(ViewController child, CommandListener listener) {
+        backButtonHelper.clear(child);
         push(child, new CommandListenerAdapter() {
             @Override
             public void onSuccess(String childId) {
         final ViewController appearing = stack.peek();
         disappearing.onViewWillDisappear();
         appearing.onViewWillAppear();
-        getView().addView(appearing.getView(), 0);
-        getView().onChildWillAppear(appearing, disappearing);
-
+        ViewGroup appearingView = appearing.getView();
+        if (appearingView.getLayoutParams() == null) {
+            appearingView.setLayoutParams(new RelativeLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT));
+            Options options = resolveCurrentOptions();
+            presenter.applyLayoutParamsOptions(options, appearingView);
+        }
+        getView().addView(appearingView, 0);
+        presenter.onChildWillAppear(appearing.options, disappearing.options);
         if (disappearing.options.animations.pop.enable.isTrueOrUndefined()) {
             animator.pop(disappearing.getView(), () -> finishPopping(disappearing, listener));
         } else {
     @NonNull
     @Override
     protected StackLayout createView() {
-        return new StackLayout(getActivity(),
+        StackLayout stackLayout = new StackLayout(getActivity(),
                 topBarButtonCreator,
                 titleBarReactViewCreator,
                 topBarBackgroundViewController,
                 this::onNavigationButtonPressed,
                 getId()
         );
+        presenter.bindView(topBarController.getView());
+        addInitialChild(stackLayout);
+        return stackLayout;
+    }
+
+    private void addInitialChild(StackLayout stackLayout) {
+        if (isEmpty()) return;
+        ViewGroup child = peek().getView();
+        child.setLayoutParams(new RelativeLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT));
+        Options options = resolveCurrentOptions();
+        presenter.applyLayoutParamsOptions(options, child);
+        stackLayout.addView(child);
     }
 
     private void onNavigationButtonPressed(String buttonId) {

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

 
 import com.reactnativenavigation.anim.NavigationAnimator;
 import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.presentation.OptionsPresenter;
+import com.reactnativenavigation.presentation.StackOptionsPresenter;
 import com.reactnativenavigation.viewcontrollers.ChildControllersRegistry;
 import com.reactnativenavigation.viewcontrollers.ReactViewCreator;
+import com.reactnativenavigation.viewcontrollers.ViewController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import com.reactnativenavigation.views.titlebar.TitleBarReactViewCreator;
 
+import java.util.ArrayList;
+import java.util.List;
+
 public class StackControllerBuilder {
     private Activity activity;
     private ChildControllersRegistry childRegistry;
     private Options initialOptions = new Options();
     private NavigationAnimator animator;
     private BackButtonHelper backButtonHelper = new BackButtonHelper();
+    private OptionsPresenter presenter;
+    private StackOptionsPresenter stackPresenter;
+    private List<ViewController> children = new ArrayList<>();
 
     public StackControllerBuilder(Activity activity) {
         this.activity = activity;
+        presenter = new OptionsPresenter(activity, new Options());
         animator = new NavigationAnimator(activity);
     }
 
+    public StackControllerBuilder setChildren(List<ViewController> children) {
+        this.children = children;
+        return this;
+    }
+
+    public StackControllerBuilder setOptionsPresenter(OptionsPresenter presenter) {
+        this.presenter = presenter;
+        return this;
+    }
+
+    public StackControllerBuilder setStackPresenter(StackOptionsPresenter stackPresenter) {
+        this.stackPresenter = stackPresenter;
+        return this;
+    }
+
     public StackControllerBuilder setChildRegistry(ChildControllersRegistry childRegistry) {
         this.childRegistry = childRegistry;
         return this;
     }
 
     public StackController build() {
-        return new StackController(activity, childRegistry, topBarButtonCreator, titleBarReactViewCreator, topBarBackgroundViewController, topBarController, animator, id, initialOptions, backButtonHelper);
+        return new StackController(activity,
+                children,
+                childRegistry,
+                topBarButtonCreator,
+                titleBarReactViewCreator,
+                topBarBackgroundViewController,
+                topBarController,
+                animator,
+                id,
+                initialOptions,
+                backButtonHelper,
+                stackPresenter,
+                presenter
+        );
     }
 }

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

     private List<ViewController> tabs;
     private TopTabsLayoutCreator viewCreator;
 
-    public TopTabsController(Activity activity, ChildControllersRegistry childRegistry, String id, List<ViewController> tabs, TopTabsLayoutCreator viewCreator, Options options) {
-        super(activity, childRegistry, id, new OptionsPresenter(activity), options);
+    public TopTabsController(Activity activity, ChildControllersRegistry childRegistry, String id, List<ViewController> tabs, TopTabsLayoutCreator viewCreator, Options options, OptionsPresenter presenter) {
+        super(activity, childRegistry, id, presenter, options);
         this.viewCreator = viewCreator;
         this.tabs = tabs;
         for (ViewController tab : tabs) {
         }
     }
 
+    @Override
+    protected ViewController getCurrentChild() {
+        return tabs.get(getView().getCurrentItem());
+    }
+
     @NonNull
     @Override
     protected TopTabsViewPager createView() {

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

         if (BuildConfig.DEBUG) view.setContentDescription(testId.get());
     }
 
-    public void setBadge(int bottomTabIndex, Text badge) {
-        setNotification(badge.get(), bottomTabIndex);
+    public void setBadge(int bottomTabIndex, String badge) {
+        setNotification(badge, bottomTabIndex);
     }
 
     @Override
         super.setCurrentItem(position);
     }
 
-    @Override
-    public void setAccentColor(int accentColor) {
-        if (getAccentColor() != accentColor) super.setAccentColor(accentColor);
-    }
-
-    @Override
-    public void setInactiveColor(int inactiveColor) {
-        if (getInactiveColor() != inactiveColor) super.setInactiveColor(inactiveColor);
-    }
-
     @Override
     public void setTitleState(TitleState titleState) {
         if (getTitleState() != titleState) super.setTitleState(titleState);

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

 
 import com.reactnativenavigation.interfaces.ScrollEventListener;
 import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.utils.UiUtils;
 import com.reactnativenavigation.utils.ViewUtils;
 import com.reactnativenavigation.viewcontrollers.IReactView;
 import com.reactnativenavigation.viewcontrollers.TopBarButtonController;
 
     @Override
     public void drawBehindTopBar() {
-        if (getParent() instanceof RelativeLayout) {
+        if (getLayoutParams() instanceof RelativeLayout.LayoutParams) {
             RelativeLayout.LayoutParams layoutParams = (RelativeLayout.LayoutParams) getLayoutParams();
             layoutParams.topMargin = 0;
             setLayoutParams(layoutParams);
 
     @Override
     public void drawBelowTopBar(TopBar topBar) {
-        if (getParent() instanceof RelativeLayout) {
+        if (getLayoutParams() instanceof RelativeLayout.LayoutParams) {
             RelativeLayout.LayoutParams layoutParams = (RelativeLayout.LayoutParams) getLayoutParams();
-            layoutParams.topMargin = ViewUtils.getPreferredHeight(topBar);
+            int topBarHeight = ViewUtils.getPreferredHeight(topBar);
+            if (topBarHeight == 0) {
+                UiUtils.runOnPreDrawOnce(topBar, () -> layoutParams.topMargin = topBar.getHeight());
+            } else {
+                layoutParams.topMargin = topBarHeight;
+            }
             setLayoutParams(layoutParams);
         }
     }

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

 import android.content.Context;
 import android.widget.RelativeLayout;
 
-import com.reactnativenavigation.parse.Options;
-import com.reactnativenavigation.presentation.StackOptionsPresenter;
 import com.reactnativenavigation.viewcontrollers.ReactViewCreator;
 import com.reactnativenavigation.viewcontrollers.TopBarButtonController;
-import com.reactnativenavigation.viewcontrollers.ViewController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import com.reactnativenavigation.views.titlebar.TitleBarReactViewCreator;
 @SuppressLint("ViewConstructor")
 public class StackLayout extends RelativeLayout {
     private String stackId;
-    private final StackOptionsPresenter optionsPresenter;
 
     public StackLayout(Context context, ReactViewCreator topBarButtonCreator, TitleBarReactViewCreator titleBarReactViewCreator, TopBarBackgroundViewController topBarBackgroundViewController, TopBarController topBarController, TopBarButtonController.OnClickListener topBarButtonClickListener, String stackId) {
         super(context);
         this.stackId = stackId;
         createLayout(topBarButtonCreator, titleBarReactViewCreator, topBarBackgroundViewController, topBarController, topBarButtonClickListener);
-        optionsPresenter = new StackOptionsPresenter(topBarController.getView());
         setContentDescription("StackLayout");
     }
 
         addView(topBarController.createView(getContext(), buttonCreator, titleBarReactViewCreator, topBarBackgroundViewController, topBarButtonClickListener, this), MATCH_PARENT, WRAP_CONTENT);
     }
 
-    public void applyChildOptions(Options options) {
-        optionsPresenter.applyOrientation(options.layout.orientation);
-    }
-
-    public void applyChildOptions(Options options, Component child) {
-        optionsPresenter.applyChildOptions(options, child);
-    }
-
-    public void onChildWillAppear(ViewController appearing, ViewController disappearing) {
-        optionsPresenter.onChildWillAppear(appearing.options, disappearing.options);
-    }
-
-    public void mergeChildOptions(Options options, Component child) {
-        optionsPresenter.mergeChildOptions(options, child);
-    }
-
     public String getStackId() {
         return stackId;
     }

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

 package com.reactnativenavigation;
 
 import android.app.Activity;
+import android.content.Context;
 
 import com.reactnativenavigation.mocks.TitleBarReactViewCreatorMock;
 import com.reactnativenavigation.mocks.TopBarBackgroundViewCreatorMock;
 import com.reactnativenavigation.mocks.TopBarButtonCreatorMock;
 import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.presentation.StackOptionsPresenter;
+import com.reactnativenavigation.utils.ImageLoader;
 import com.reactnativenavigation.viewcontrollers.ChildControllersRegistry;
+import com.reactnativenavigation.viewcontrollers.ReactViewCreator;
+import com.reactnativenavigation.viewcontrollers.TopBarButtonController;
 import com.reactnativenavigation.viewcontrollers.stack.StackControllerBuilder;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
+import com.reactnativenavigation.views.StackLayout;
+import com.reactnativenavigation.views.titlebar.TitleBarReactViewCreator;
+import com.reactnativenavigation.views.topbar.TopBar;
 
 public class TestUtils {
     public static StackControllerBuilder newStackController(Activity activity) {
                 .setTopBarButtonCreator(new TopBarButtonCreatorMock())
                 .setTitleBarReactViewCreator(new TitleBarReactViewCreatorMock())
                 .setTopBarBackgroundViewController(new TopBarBackgroundViewController(activity, new TopBarBackgroundViewCreatorMock()))
-                .setTopBarController(new TopBarController())
+                .setTopBarController(new TopBarController() {
+                    @Override
+                    protected TopBar createTopBar(Context context, ReactViewCreator buttonCreator, TitleBarReactViewCreator titleBarReactViewCreator, TopBarBackgroundViewController topBarBackgroundViewController, TopBarButtonController.OnClickListener topBarButtonClickListener, StackLayout stackLayout, ImageLoader imageLoader) {
+                        TopBar topBar = super.createTopBar(context, buttonCreator, titleBarReactViewCreator, topBarBackgroundViewController, topBarButtonClickListener, stackLayout, imageLoader);
+                        topBar.layout(0, 0, 1000, 100);
+                        return topBar;
+                    }
+                })
+                .setStackPresenter(new StackOptionsPresenter(activity, new Options()))
                 .setInitialOptions(new Options());
     }
 }

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

 import android.app.*;
 
 import com.reactnativenavigation.parse.*;
+import com.reactnativenavigation.presentation.OptionsPresenter;
 import com.reactnativenavigation.viewcontrollers.*;
 
 public class SimpleComponentViewController extends ComponentViewController {
     public SimpleComponentViewController(Activity activity, ChildControllersRegistry childRegistry, String id, Options initialOptions) {
-        super(activity, childRegistry,id, "theComponentName", new TestComponentViewCreator(), initialOptions);
+        super(activity, childRegistry,id, "theComponentName", new TestComponentViewCreator(), initialOptions, new OptionsPresenter(activity, new Options()));
     }
 }

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

 import android.view.MotionEvent;
 import android.view.View;
 import android.widget.FrameLayout;
+import android.widget.RelativeLayout;
 
 import com.reactnativenavigation.interfaces.ScrollEventListener;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.presentation.OptionsPresenter;
+import com.reactnativenavigation.utils.ViewUtils;
 import com.reactnativenavigation.viewcontrollers.ChildController;
 import com.reactnativenavigation.viewcontrollers.ChildControllersRegistry;
 import com.reactnativenavigation.views.ReactComponent;
     private SimpleView simpleView;
 
     public SimpleViewController(Activity activity, ChildControllersRegistry childRegistry, String id, Options options) {
-        this(activity, childRegistry, id, new OptionsPresenter(activity), options);
+        this(activity, childRegistry, id, new OptionsPresenter(activity, new Options()), options);
     }
 
     public SimpleViewController(Activity activity, ChildControllersRegistry childRegistry, String id, OptionsPresenter presenter, Options options) {
 
         @Override
         public void drawBehindTopBar() {
-
+            if (getLayoutParams() instanceof RelativeLayout.LayoutParams) {
+                RelativeLayout.LayoutParams layoutParams = (RelativeLayout.LayoutParams) getLayoutParams();
+                if (layoutParams.topMargin == 0) return;
+                layoutParams.topMargin = 0;
+                setLayoutParams(layoutParams);
+            }
         }
 
         @Override
         public void drawBelowTopBar(TopBar topBar) {
-
+            if (getLayoutParams() instanceof RelativeLayout.LayoutParams) {
+                RelativeLayout.LayoutParams layoutParams = (RelativeLayout.LayoutParams) getLayoutParams();
+                if (layoutParams.topMargin == ViewUtils.getPreferredHeight(topBar)) return;
+                layoutParams.topMargin = ViewUtils.getPreferredHeight(topBar);
+//                setLayoutParams(layoutParams);
+            }
         }
 
         @Override

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

     @Test
     public void clear_bottomTabsOptions() {
         Options uut = new Options();
-        uut.bottomTabsOptions.tabColor = new com.reactnativenavigation.parse.params.Color(android.graphics.Color.RED);
+        uut.bottomTabsOptions.backgroundColor = new com.reactnativenavigation.parse.params.Color(android.graphics.Color.RED);
         uut.clearBottomTabsOptions();
-        assertThat(uut.bottomTabsOptions.tabColor.hasValue()).isFalse();
+        assertThat(uut.bottomTabsOptions.backgroundColor.hasValue()).isFalse();
     }
 
     @Test

lib/android/app/src/test/java/com/reactnativenavigation/utils/OptionHelper.java

     public static Options createBottomTabOptions() {
         Options options = new Options();
         options.topBar.buttons.left = new ArrayList<>();
-        options.bottomTabOptions.title = new Text("Tab");
+        options.bottomTabOptions.text = new Text("Tab");
         options.bottomTabOptions.icon = new Text("http://127.0.0.1/icon.png");
         return options;
     }

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

+package com.reactnativenavigation.viewcontrollers;
+
+import android.app.Activity;
+
+import com.reactnativenavigation.BaseTest;
+import com.reactnativenavigation.mocks.SimpleViewController;
+import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.parse.params.Color;
+import com.reactnativenavigation.parse.params.Text;
+import com.reactnativenavigation.presentation.BottomTabOptionsPresenter;
+import com.reactnativenavigation.views.BottomTabs;
+import com.reactnativenavigation.views.Component;
+
+import org.junit.Test;
+import org.mockito.Mockito;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
+public class BottomTabOptionsPresenterTest extends BaseTest {
+    private Options tab1Options = createTab1Options();
+    private Options tab2Options = createTab2Options();
+    private BottomTabOptionsPresenter uut;
+    private BottomTabs bottomTabs;
+    private List<ViewController> tabs;
+    private ViewController child3;
+
+    @Override
+    public void beforeEach() {
+        Activity activity = newActivity();
+        ChildControllersRegistry childRegistry = new ChildControllersRegistry();
+        bottomTabs = Mockito.mock(BottomTabs.class);
+        ViewController child1 = spy(new SimpleViewController(activity, childRegistry, "child1", tab1Options));
+        ViewController child2 = spy(new SimpleViewController(activity, childRegistry, "child2", tab2Options));
+        child3 = spy(new SimpleViewController(activity, childRegistry, "child2", new Options()));
+        tabs = Arrays.asList(child1, child2, child3);
+        uut = new BottomTabOptionsPresenter(activity, tabs, new Options());
+        uut.bindView(bottomTabs);
+        uut.setDefaultOptions(new Options());
+    }
+
+    @Test
+    public void present() {
+        uut.present();
+        for (int i = 0; i < tabs.size(); i++) {
+            verify(bottomTabs, times(1)).setBadge(i, tabs.get(i).options.bottomTabOptions.badge.get(""));
+            verify(bottomTabs, times(1)).setTitleInactiveColor(i, tabs.get(i).options.bottomTabOptions.textColor.get(null));
+            verify(bottomTabs, times(1)).setTitleActiveColor(i, tabs.get(i).options.bottomTabOptions.selectedTextColor.get(null));
+        }
+    }
+
+    @Test
+    public void mergeChildOptions() {
+        for (int i = 0; i < 2; i++) {
+            Options options = tabs.get(i).options;
+            uut.mergeChildOptions(options, (Component) tabs.get(i).getView());
+            verify(bottomTabs, times(1)).setBadge(i, options.bottomTabOptions.badge.get());
+            verify(bottomTabs, times(1)).setIconActiveColor(eq(i), anyInt());
+            verify(bottomTabs, times(1)).setIconInactiveColor(eq(i), anyInt());
+        }
+        verifyNoMoreInteractions(bottomTabs);
+    }
+
+    @Test
+    public void mergeChildOptions_onlySetsDefinedOptions() {
+        uut.mergeChildOptions(child3.options, (Component) child3.getView());
+        verify(bottomTabs, times(0)).setBadge(eq(2), anyString());
+        verify(bottomTabs, times(0)).setIconInactiveColor(eq(2), anyInt());
+        verify(bottomTabs, times(0)).setIconActiveColor(eq(2), anyInt());
+        verifyNoMoreInteractions(bottomTabs);
+    }
+
+    private Options createTab1Options() {
+        Options options = new Options();
+        options.bottomTabOptions.badge = new Text("tab1badge");
+        options.bottomTabOptions.iconColor = new Color(android.graphics.Color.RED);
+        options.bottomTabOptions.selectedIconColor = new Color(android.graphics.Color.RED);
+        return options;
+    }
+
+    private Options createTab2Options() {
+        Options options = new Options();
+        options.bottomTabOptions.badge = new Text("tab2badge");
+        options.bottomTabOptions.iconColor = new Color(android.graphics.Color.RED);
+        options.bottomTabOptions.selectedIconColor = new Color(android.graphics.Color.RED);
+        return options;
+    }
+}

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

 import com.reactnativenavigation.parse.params.Color;
 import com.reactnativenavigation.parse.params.Number;
 import com.reactnativenavigation.parse.params.Text;
+import com.reactnativenavigation.presentation.BottomTabOptionsPresenter;
+import com.reactnativenavigation.presentation.BottomTabsOptionsPresenter;
+import com.reactnativenavigation.presentation.OptionsPresenter;
+import com.reactnativenavigation.presentation.StackOptionsPresenter;
 import com.reactnativenavigation.react.EventEmitter;
 import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.utils.ImageLoader;
 
 import static org.assertj.core.api.Java6Assertions.assertThat;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
     private ViewController child3;
     private StackController child4;
     private ViewController child5;
+    private ViewController child6;
     private Options tabOptions = OptionHelper.createBottomTabOptions();
     private ImageLoader imageLoaderMock = ImageLoaderMock.mock();
     private EventEmitter eventEmitter;
     private ChildControllersRegistry childRegistry;
     private List<ViewController> tabs;
+    private BottomTabsOptionsPresenter presenter;
 
     @Override
     public void beforeEach() {
         child3 = spy(new SimpleViewController(activity, childRegistry, "child3", tabOptions));
         child4 = spy(createStack("someStack"));
         child5 = spy(new SimpleViewController(activity, childRegistry, "child5", tabOptions));
+        child6 = spy(new SimpleViewController(activity, childRegistry, "child6", tabOptions));
         when(child5.handleBack(any())).thenReturn(true);
         tabs = createTabs();
-
-        uut = new BottomTabsController(activity, tabs, childRegistry, eventEmitter, imageLoaderMock, "uut", new Options()) {
-            @Override
-            public void ensureViewIsCreated() {
-                super.ensureViewIsCreated();
-                uut.getView().layout(0, 0, 1000, 1000);
-                uut.getBottomTabs().layout(0, 0, 1000, 100);
-            }
-        };
+        presenter = spy(new BottomTabsOptionsPresenter(tabs, new Options()));
+        uut = createBottomTabs();
     }
 
     @Test
     @Test(expected = RuntimeException.class)
     public void setTabs_ThrowWhenMoreThan5() {
         tabs.add(new SimpleViewController(activity, childRegistry, "6", tabOptions));
-        new BottomTabsController(activity, tabs, childRegistry, eventEmitter, imageLoaderMock, "uut", new Options()) {
-            @Override
-            public void ensureViewIsCreated() {
-                super.ensureViewIsCreated();
-                uut.getView().layout(0, 0, 1000, 1000);
-                uut.getBottomTabs().layout(0, 0, 1000, 100);
-            }
-        };
-    }
-
-    @Test
-    public void setTab_controllerIsSetAsParent() {
-        for (ViewController tab : tabs) {
-            assertThat(tab.getParentController()).isEqualTo(uut);
-        }
+        createBottomTabs();
     }
 
     @Test
         }
     }
 
+    @Test
+    public void createView_layoutOptionsAreAppliedToTabs() {
+        uut.ensureViewIsCreated();
+        for (int i = 0; i < tabs.size(); i++) {
+            verify(presenter, times(1)).applyLayoutParamsOptions(any(), eq(i));
+            assertThat(childLayoutParams(i).width).isEqualTo(ViewGroup.LayoutParams.MATCH_PARENT);
+            assertThat(childLayoutParams(i).height).isEqualTo(ViewGroup.LayoutParams.MATCH_PARENT);
+        }
+    }
+
     @Test
     public void onTabSelected() {
+        uut.ensureViewIsCreated();
         assertThat(uut.getSelectedIndex()).isZero();
         assertThat(((ViewController) ((List) uut.getChildControllers()).get(0)).getView().getVisibility()).isEqualTo(View.VISIBLE);
 
 
     @Test
     public void onTabReSelected() {
+        uut.ensureViewIsCreated();
         assertThat(uut.getSelectedIndex()).isZero();
 
         uut.onTabSelected(0, false);
 
     @Test
     public void handleBack_DelegatesToSelectedChild() {
+        uut.ensureViewIsCreated();
         assertThat(uut.handleBack(new CommandListenerAdapter())).isFalse();
         uut.selectTab(4);
         assertThat(uut.handleBack(new CommandListenerAdapter())).isTrue();
     @Test
     public void applyOptions_bottomTabsOptionsAreClearedAfterApply() {
         Options options = new Options();
-        options.bottomTabsOptions.tabColor = new Color(android.graphics.Color.RED);
+        options.bottomTabsOptions.backgroundColor = new Color(android.graphics.Color.RED);
         child1.mergeOptions(options);
         uut.ensureViewIsCreated();
 
         ArgumentCaptor<ReactComponent> viewCaptor = ArgumentCaptor.forClass(ReactComponent.class);
         verify(stack, times(1)).applyChildOptions(optionsCaptor.capture(), viewCaptor.capture());
         assertThat(viewCaptor.getValue()).isEqualTo(child1.getView());
-        assertThat(optionsCaptor.getValue().bottomTabsOptions.tabColor.hasValue()).isFalse();
+        assertThat(optionsCaptor.getValue().bottomTabsOptions.backgroundColor.hasValue()).isFalse();
     }
 
     @Test
 
     @Test
     public void push() {
+        uut.ensureViewIsCreated();
         uut.selectTab(3);
 
         SimpleViewController stackChild = new SimpleViewController(activity, childRegistry, "stackChild", new Options());
         assertThat(child4.size()).isEqualTo(2);
     }
 
+    @Test
+    public void deepChildOptionsAreApplied() {
+        BottomTabsController spy = spy(uut);
+        activity.setContentView(spy.getView());
+
+        child6.options.topBar.drawBehind = new Bool(false);
+        disablePushAnimation(child6);
+        child4.push(child6, new CommandListenerAdapter());
+        assertThat(child4.size()).isOne();
+
+
+        verify(spy, times(1)).onViewAppeared();
+        assertThat(spy.getSelectedIndex()).isZero();
+        verify(child6, times(0)).onViewAppeared();
+        assertThat(child4.getTopBar().getHeight())
+                .isNotZero()
+                .isEqualTo(((ViewGroup.MarginLayoutParams) child6.getView().getLayoutParams()).topMargin);
+    }
+
     @NonNull
     private List<ViewController> createTabs() {
         return Arrays.asList(child1, child2, child3, child4, child5);
         return TestUtils.newStackController(activity)
                 .setId(id)
                 .setInitialOptions(tabOptions)
+                .setStackPresenter(new StackOptionsPresenter(activity, new Options()))
                 .build();
     }
 
     private ViewGroup.MarginLayoutParams childLayoutParams(int index) {
         return (ViewGroup.MarginLayoutParams) tabs.get(index).getView().getLayoutParams();
     }
+
+    public BottomTabsController createBottomTabs() {
+        return new BottomTabsController(activity,
+                tabs,
+                childRegistry,
+                eventEmitter,
+                imageLoaderMock,
+                "uut",
+                new Options(),
+                new OptionsPresenter(activity, new Options()),
+                presenter,
+                new BottomTabOptionsPresenter(activity, tabs, new Options())) {
+            @Override
+            public void ensureViewIsCreated() {
+                super.ensureViewIsCreated();
+                uut.getView().layout(0, 0, 1000, 1000);
+                uut.getBottomTabs().layout(0, 0, 1000, 100);
+            }
+        };
+    }
 }

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

 import com.reactnativenavigation.mocks.TestComponentLayout;
 import com.reactnativenavigation.mocks.TestReactView;
 import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.presentation.OptionsPresenter;
 import com.reactnativenavigation.views.StackLayout;
 
 import org.junit.Test;
         Activity activity = newActivity();
         view = spy(new TestComponentLayout(activity, new TestReactView(activity)));
         ParentController<StackLayout> parentController = TestUtils.newStackController(activity).build();
-        uut = new ComponentViewController(activity, new ChildControllersRegistry(), "componentId1", "componentName", (activity1, componentId, componentName) -> view, new Options());
+        OptionsPresenter presenter = new OptionsPresenter(activity, new Options());
+        uut = new ComponentViewController(activity, new ChildControllersRegistry(), "componentId1", "componentName", (activity1, componentId, componentName) -> view, new Options(), presenter);
         uut.setParentController(parentController);
         parentController.ensureViewIsCreated();
     }

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

         activity = newActivity();
         childRegistry = new ChildControllersRegistry();
         stackController = TestUtils.newStackController(activity).build();
+        stackController.ensureViewIsCreated();
         Options options = getOptionsWithFab();
         childFab = new SimpleViewController(activity, childRegistry, "child1", options);
         childNoFab = new SimpleViewController(activity, childRegistry, "child2", new Options());

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

 package com.reactnativenavigation.viewcontrollers;
 
 import android.support.annotation.NonNull;
+import android.view.View;
 
 import com.reactnativenavigation.BaseTest;
 import com.reactnativenavigation.TestActivity;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.params.Bool;
 import com.reactnativenavigation.parse.params.Text;
+import com.reactnativenavigation.presentation.BottomTabOptionsPresenter;
+import com.reactnativenavigation.presentation.BottomTabsOptionsPresenter;
+import com.reactnativenavigation.presentation.OptionsPresenter;
 import com.reactnativenavigation.presentation.OverlayManager;
 import com.reactnativenavigation.react.EventEmitter;
 import com.reactnativenavigation.utils.CommandListener;
     private ActivityController<TestActivity> activityController;
     private OverlayManager overlayManager;
     private EventEmitter eventEmitter;
+    private ViewController.ViewVisibilityListener parentVisibilityListener;
 
     @Override
     public void beforeEach() {
         uut = new Navigator(activity, childRegistry, overlayManager);
         activity.setNavigator(uut);
 
-        parentController = spy(newStack());
-        parentController.ensureViewIsCreated();
+        parentController = newStack();
+        parentVisibilityListener = spy(new ViewController.ViewVisibilityListener() {
+            @Override
+            public boolean onViewAppeared(View view) {
+                return false;
+            }
+
+            @Override
+            public boolean onViewDisappear(View view) {
+                return false;
+            }
+        });
+        parentController.setViewVisibilityListener(parentVisibilityListener);
+//        parentController.ensureViewIsCreated();
         child1 = new SimpleViewController(activity, childRegistry, "child1", tabOptions);
         child2 = new SimpleViewController(activity, childRegistry, "child2", tabOptions);
         child3 = new SimpleViewController(activity, childRegistry, "child3", tabOptions);
         activityController.visible();
     }
 
+    @Test
+    public void setDefaultOptions() {
+        uut.setDefaultOptions(new Options());
+
+        SimpleViewController spy = spy(child1);
+        uut.setRoot(spy, new CommandListenerAdapter());
+        Options defaultOptions = new Options();
+        uut.setDefaultOptions(defaultOptions);
+        verify(spy, times(1)).setDefaultOptions(defaultOptions);
+    }
+
     @Test
     public void setRoot_AddsChildControllerView() {
         assertThat(uut.getContentLayout().getChildCount()).isZero();
 
     @Test
     public void push_OnCorrectStackByFindingChildId() {
-        StackController stack1 = newStack();
-        StackController stack2 = newStack();
+        StackController stack1 = newStack(); stack1.ensureViewIsCreated();
+        StackController stack2 = newStack(); stack2.ensureViewIsCreated();
         stack1.push(child1, new CommandListenerAdapter());
         stack2.push(child2, new CommandListenerAdapter());
         BottomTabsController bottomTabsController = newTabs(Arrays.asList(stack1, stack2));
 
     @Test
     public void popSpecific() {
-        StackController stack1 = newStack();
-        StackController stack2 = newStack();
+        disablePushAnimation(child1, child2, child3, child4);
+        StackController stack1 = newStack(); stack1.ensureViewIsCreated();
+        StackController stack2 = newStack(); stack2.ensureViewIsCreated();
         stack1.push(child1, new CommandListenerAdapter());
         stack2.push(child2, new CommandListenerAdapter());
         stack2.push(child3, new CommandListenerAdapter());
 
     @NonNull
     private BottomTabsController newTabs(List<ViewController> tabs) {
-        return new BottomTabsController(activity, tabs, childRegistry, eventEmitter, imageLoaderMock, "tabsController", new Options());
+        return new BottomTabsController(activity, tabs, childRegistry, eventEmitter, imageLoaderMock, "tabsController", new Options(), new OptionsPresenter(activity, new Options()), new BottomTabsOptionsPresenter(tabs, new Options()), new BottomTabOptionsPresenter(activity, tabs, new Options()));
     }
 
     @NonNull
     private StackController newStack() {
-        return TestUtils.newStackController(activity)
+        StackController stack = TestUtils.newStackController(activity)
                 .setChildRegistry(childRegistry)
                 .setId("stack" + CompatUtils.generateViewId())
                 .setInitialOptions(tabOptions)
                 .build();
+        stack.ensureViewIsCreated();
+        return stack;
     }
 
     @Test
     public void pushedStackCanBePopped() {
         child1.options.animations.push.enable = new Bool(false);
         child2.options.animations.push.enable = new Bool(false);
+        StackController spy = spy(parentController);
         StackController parent = newStack();
         parent.ensureViewIsCreated();
         uut.setRoot(parent, new CommandListenerAdapter());
-        parent.push(parentController, new CommandListenerAdapter());
+        parent.push(spy, new CommandListenerAdapter());
 
-        parentController.push(child1, new CommandListenerAdapter());
-        parentController.push(child2, new CommandListenerAdapter());
-        assertThat(parentController.getChildControllers().size()).isEqualTo(2);
+        spy.push(child1, new CommandListenerAdapter());
+        spy.push(child2, new CommandListenerAdapter());
+        assertThat(spy.getChildControllers().size()).isEqualTo(2);
         child1.ensureViewIsCreated();
         child2.ensureViewIsCreated();
 
         CommandListenerAdapter listener = new CommandListenerAdapter() {
             @Override
             public void onSuccess(String childId) {
-                assertThat(parentController.getChildControllers().size()).isEqualTo(1);
+                assertThat(spy.getChildControllers().size()).isEqualTo(1);
             }
         };
         uut.popSpecific("child2", listener);
-        verify(parentController, times(1)).popSpecific(child2, listener);
+        verify(spy, times(1)).popSpecific(child2, listener);
     }
 
     @Test
 
         uut.dismissModal(child2.getId(), new CommandListenerAdapter());
         assertThat(parentController.getView().getParent()).isNull();
-        verify(parentController, times(1)).onViewAppeared();
+        verify(parentVisibilityListener, times(1)).onViewAppeared(parentController.getView());
 
         uut.dismissModal(child1.getId(), new CommandListenerAdapter());
         assertThat(parentController.getView().getParent()).isNotNull();
 
-        verify(parentController, times(2)).onViewAppeared();
+        verify(parentVisibilityListener, times(2)).onViewAppeared(parentController.getView());
     }
 
     @Test
         disableShowModalAnimation(child1);
 
         uut.dismissAllModals(new CommandListenerAdapter());
-        verify(parentController, times(0)).onViewAppeared();
+        verify(parentVisibilityListener, times(0)).onViewAppeared(parentController.getView());
 
         uut.setRoot(parentController, new CommandListenerAdapter());
-        verify(parentController, times(1)).onViewAppeared();
+
+        verify(parentVisibilityListener, times(1)).onViewAppeared(parentController.getView());
         uut.showModal(child1, new CommandListenerAdapter());
         uut.dismissAllModals(new CommandListenerAdapter());
 
-        verify(parentController, times(2)).onViewAppeared();
+        verify(parentVisibilityListener, times(2)).onViewAppeared(parentController.getView());
     }
 
     @Test
     public void handleBack_onViewAppearedInvokedOnRoot() {
         disableShowModalAnimation(child1, child2);
 
-        uut.setRoot(parentController, new CommandListenerAdapter());
+        StackController spy = spy(parentController);
+        uut.setRoot(spy, new CommandListenerAdapter());
         uut.showModal(child1, new CommandListenerAdapter());
         uut.showModal(child2, new CommandListenerAdapter());
 
         uut.handleBack(new CommandListenerAdapter());
-        verify(parentController, times(1)).onViewAppeared();
+        verify(parentVisibilityListener, times(1)).onViewAppeared(spy.getView());
 
         uut.handleBack(new CommandListenerAdapter() {
             @Override
             public void onSuccess(String childId) {
-                assertThat(parentController.getView().getParent()).isNotNull();
-                verify(parentController, times(2)).onViewAppeared();
+                assertThat(spy.getView().getParent()).isNotNull();
+                verify(spy, times(2)).onViewAppeared();
             }
         });
     }
 
     @Test
     public void destroy_destroyedRoot() {
-        parentController.options.animations.startApp.enable = new Bool(false);
-        uut.setRoot(parentController, new CommandListenerAdapter());
+        StackController spy = spy(parentController);
+        spy.options.animations.startApp.enable = new Bool(false);
+        uut.setRoot(spy, new CommandListenerAdapter());
         activityController.destroy();
-        verify(parentController, times(1)).destroy();
+        verify(spy, times(1)).destroy();
     }
 
     @Test
 
     @Test
     public void reload_navigatorIsDestroyedOnReload() {
-        uut.setRoot(parentController, new CommandListenerAdapter());
+        StackController spy = spy(parentController);
+        uut.setRoot(spy, new CommandListenerAdapter());
         uut.onReload();
-        verify(parentController, times(1)).destroy();
+        verify(spy, times(1)).destroy();
         verify(overlayManager, times(1)).destroy();
     }
 }

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

 import com.reactnativenavigation.parse.params.Bool;
 import com.reactnativenavigation.parse.params.Fraction;
 import com.reactnativenavigation.parse.params.Text;
+import com.reactnativenavigation.presentation.OptionsPresenter;
+import com.reactnativenavigation.presentation.StackOptionsPresenter;
 import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.utils.ImageLoader;
 import com.reactnativenavigation.viewcontrollers.stack.StackController;
                 "componentId1",
                 "componentName",
                 (activity1, componentId, componentName) -> view,
-                initialNavigationOptions
+                initialNavigationOptions,
+                new OptionsPresenter(activity, new Options())
         );
         TopBarController topBarController = new TopBarController() {
             @Override
                         .setTopBarController(new TopBarController())
                         .setId("stackId")
                         .setInitialOptions(new Options())
+                        .setStackPresenter(new StackOptionsPresenter(activity, new Options()))
                         .build();
+        stackController.ensureViewIsCreated();
         stackController.push(uut, new CommandListenerAdapter());
         assertThat(stackController.getTopBar().getTitle()).isEmpty();
 
         });
     }
 
+    @SuppressWarnings("MagicNumber")
     @Test
     public void appliesTopBarTextSize() {
         assertThat(uut.initialOptions).isSameAs(initialNavigationOptions);

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

         children = new ArrayList<>();
         Options initialOptions = new Options();
         initialOptions.topBar.title.text = new Text(INITIAL_TITLE);
-        presenter = spy(new OptionsPresenter(activity));
+        presenter = spy(new OptionsPresenter(activity, new Options()));
         uut = spy(new ParentController(activity, childRegistry, "uut", presenter, initialOptions) {
 
+            @Override
+            protected ViewController getCurrentChild() {
+                return children.get(0);
+            }
+
             @NonNull
             @Override
             protected ViewGroup createView() {
     @Test
     public void findControllerById_Recursive() {
         StackController stackController = TestUtils.newStackController(activity).build();
+        stackController.ensureViewIsCreated();
         SimpleViewController child1 = new SimpleViewController(activity, childRegistry, "child1", new Options());
         SimpleViewController child2 = new SimpleViewController(activity, childRegistry, "child2", new Options());
         stackController.push(child1, new CommandListenerAdapter());
     @Test
     public void optionsAreClearedWhenChildIsAppeared() {
         StackController stackController = spy(TestUtils.newStackController(activity).build());
+        stackController.ensureViewIsCreated();
         SimpleViewController child1 = new SimpleViewController(activity, childRegistry, "child1", new Options());
         stackController.push(child1, new CommandListenerAdapter());
 

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

 import com.reactnativenavigation.mocks.SimpleComponentViewController;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.params.Bool;
+import com.reactnativenavigation.presentation.OptionsPresenter;
 
 import org.junit.Test;
 
     public void beforeEach() {
         activity = newActivity();
         childRegistry = new ChildControllersRegistry();
-        uut = new SideMenuController(activity, childRegistry, "sideMenu", new Options());
+        OptionsPresenter presenter = new OptionsPresenter(activity, new Options());
+        uut = new SideMenuController(activity, childRegistry, "sideMenu", new Options(), presenter);
     }
 
     @Test

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/OptionsMergingTest.java → lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/StackOptionsPresenterTest.java

 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
-public class OptionsMergingTest extends BaseTest {
+public class StackOptionsPresenterTest extends BaseTest {
 
     private StackOptionsPresenter uut;
     private TestComponentLayout child;
     @Override
     public void beforeEach() {
         activity = spy(newActivity());
+        uut = spy(new StackOptionsPresenter(activity, new Options()));
         topBar = mockTopBar();
-        uut = spy(new StackOptionsPresenter(topBar));
+        uut.bindView(topBar);
         child = spy(new TestComponentLayout(activity, new TestReactView(activity)));
     }
 
     public void mergeTopBarOptions() {
         Options options = new Options();
         uut.mergeChildOptions(options, child);
-        assertTopBarOptions(0);
-
-        TitleOptions titleOptions = new TitleOptions();
-        titleOptions.text = new Text("abc");
-        titleOptions.component.name = new Text("someComponent");
-        titleOptions.component.componentId = new Text("compId");
-        titleOptions.color = new Color(0);
-        titleOptions.fontSize = new Fraction(1.0f);
-        titleOptions.fontFamily = Typeface.DEFAULT_BOLD;
-        options.topBar.title = titleOptions;
+        assertTopBarOptions(options, 0);
+
+        TitleOptions title = new TitleOptions();
+        title.text = new Text("abc");
+        title.component.name = new Text("someComponent");
+        title.component.componentId = new Text("compId");
+        title.color = new Color(0);
+        title.fontSize = new Fraction(1.0f);
+        title.fontFamily = Typeface.DEFAULT_BOLD;
+        options.topBar.title = title;
         SubtitleOptions subtitleOptions = new SubtitleOptions();
         subtitleOptions.text = new Text("Sub");
         subtitleOptions.color = new Color(1);
         options.topBar.hideOnScroll = new Bool(false);
         uut.mergeChildOptions(options, child);
 
-        assertTopBarOptions(1);
+        assertTopBarOptions(options, 1);
 
         options.topBar.drawBehind = new Bool(true);
         uut.mergeChildOptions(options, child);
         verify(topBar, times(1)).setTopTabFontFamily(1, Typeface.DEFAULT_BOLD);
     }
 
-    private void assertTopBarOptions(int t) {
-        verify(topBar, times(t)).setTitle(any());
-        verify(topBar, times(t)).setSubtitle(any());
+    private void assertTopBarOptions(Options options, int t) {
+        if (options.topBar.title.component.hasValue()) {
+            verify(topBar, times(0)).setTitle(any());
+            verify(topBar, times(0)).setSubtitle(any());
+        } else {
+            verify(topBar, times(t)).setTitle(any());
+            verify(topBar, times(t)).setSubtitle(any());
+        }
         verify(topBar, times(t)).setTitleComponent(any());
         verify(topBar, times(t)).setBackgroundColor(any());
         verify(topBar, times(t)).setTitleTextColor(anyInt());

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

 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.params.Bool;
 import com.reactnativenavigation.parse.params.Text;
+import com.reactnativenavigation.presentation.OptionsPresenter;
 import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.utils.ViewHelper;
 import com.reactnativenavigation.viewcontrollers.stack.StackController;
         topTabsLayout = spy(new TopTabsViewPager(activity, tabControllers, new TopTabsAdapter(tabControllers)));
         TopTabsLayoutCreator layoutCreator = Mockito.mock(TopTabsLayoutCreator.class);
         Mockito.when(layoutCreator.create()).thenReturn(topTabsLayout);
-        uut = spy(new TopTabsController(activity, childRegistry, "componentId", tabControllers, layoutCreator, options));
+        OptionsPresenter presenter = new OptionsPresenter(activity, new Options());
+        uut = spy(new TopTabsController(activity, childRegistry, "componentId", tabControllers, layoutCreator, options, presenter));
         tabControllers.forEach(viewController -> viewController.setParentController(uut));
 
         stack = spy(TestUtils.newStackController(activity).build());
+        stack.ensureViewIsCreated();
         stack.push(uut, new CommandListenerAdapter());
         uut.setParentController(stack);
     }
                     "idTab" + i,
                     "theComponentName",
                     new TestComponentViewCreator(),
-                    tabOptions.get(i)
+                    tabOptions.get(i),
+                    new OptionsPresenter(activity, new Options())
             );
             tabControllers.add(spy(viewController));
         }
         stack.getView().removeAllViews();
 
         StackController stackController = spy(TestUtils.newStackController(activity).build());
+        stackController.ensureViewIsCreated();
         ComponentViewController first = new ComponentViewController(
                 activity,
                 childRegistry,
                 "firstScreen",
                 "comp1",
                 new TestComponentViewCreator(),
-                new Options()
+                new Options(),
+                new OptionsPresenter(activity, new Options())
         );
         first.options.animations.push.enable = new Bool(false);
         uut.options.animations.push.enable = new Bool(false);

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

 
         assertThat(uut.getParentController()).isNull();
         StackController nav = TestUtils.newStackController(activity).build();
+        nav.ensureViewIsCreated();
         nav.push(uut, new CommandListenerAdapter());
         assertThat(uut.getParentController()).isEqualTo(nav);
     }

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

                 .build();
         child1 = spy(new SimpleViewController(activity, childRegistry, "child1", new Options()));
         child2 = spy(new SimpleViewController(activity, childRegistry, "child2", new Options()));
+        stack.ensureViewIsCreated();
     }
 
     @Test
     public void addToChild_doesNotAddIfStackContainsOneChild() {
-        uut.addToChild(stack, child1);
+        uut.addToPushedChild(stack, child1);
         verify(child1, times(0)).mergeOptions(any());
     }
 
 
         verify(child2, times(0)).mergeOptions(any());
     }
+
+    @Test
+    public void clear() {
+        child1.options.topBar.buttons.back.visible = new Bool(true);
+        uut.clear(child1);
+        assertThat(child1.options.topBar.buttons.back.visible.get()).isFalse();
+    }
 }

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

 import android.app.Activity;
 import android.content.Context;
 import android.view.View;
+import android.view.ViewGroup;
 
 import com.reactnativenavigation.BaseTest;
 import com.reactnativenavigation.TestUtils;
 import com.reactnativenavigation.parse.params.Bool;
 import com.reactnativenavigation.parse.params.Button;
 import com.reactnativenavigation.parse.params.Text;
+import com.reactnativenavigation.presentation.StackOptionsPresenter;
 import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.utils.ImageLoader;
 import com.reactnativenavigation.utils.ViewHelper;
 import org.mockito.Mockito;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
+import java.util.List;
 
 import static org.assertj.core.api.Java6Assertions.assertThat;
 import static org.mockito.ArgumentMatchers.any;
     private ViewController child4;
     private NavigationAnimator animator;
     private TopBarController topBarController;
+    private StackOptionsPresenter presenter;
 
     @Override
     public void beforeEach() {
         animator = Mockito.mock(NavigationAnimator.class);
         activity = newActivity();
         childRegistry = new ChildControllersRegistry();
-        uut = createStackController();
+        presenter = new StackOptionsPresenter(activity, new Options());
         child1 = spy(new SimpleViewController(activity, childRegistry, "child1", new Options()));
         child2 = spy(new SimpleViewController(activity, childRegistry, "child2", new Options()));
         child3 = spy(new SimpleViewController(activity, childRegistry, "child3", new Options()));
         child4 = spy(new SimpleViewController(activity, childRegistry, "child4", new Options()));
+        uut = createStack();
+        uut.ensureViewIsCreated();
     }
 
     @Test
         assertThat(uut).isInstanceOf(ViewController.class);
     }
 
+    @Test
+    public void childrenAreAssignedParent() {
+        StackController uut = createStack(Arrays.asList(child1, child2));
+        for (ViewController child : uut.getChildControllers()) {
+            assertThat(child.getParentController().equals(uut));
+        }
+    }
+
+    @Test
+    public void createView_currentChildIsAdded() {
+        StackController uut = createStack(Arrays.asList(child1, child2, child3, child4));
+        assertThat(uut.getChildControllers().size()).isEqualTo(4);
+        assertThat(uut.getView().getChildCount()).isEqualTo(2);
+        assertThat(uut.getView().getChildAt(1)).isEqualTo(child4.getView());
+    }
+
     @Test
     public void holdsAStackOfViewControllers() {
         assertThat(uut.isEmpty()).isTrue();
 
     @Test
     public void animateSetRoot() {
+        disablePushAnimation(child1, child2, child3);
         assertThat(uut.isEmpty()).isTrue();
         uut.push(child1, new CommandListenerAdapter());
         uut.push(child2, new CommandListenerAdapter());
 
     @Test
     public void setRoot() {
-        disablePushAnimation(child1, child2);
+        activity.setContentView(uut.getView());
+        disablePushAnimation(child1, child2, child3);
+
         assertThat(uut.isEmpty()).isTrue();
         uut.push(child1, new CommandListenerAdapter());
         uut.push(child2, new CommandListenerAdapter());
     }
 
     @Test
-    public void pop() {
+    public synchronized void pop() {
+        disablePushAnimation(child1, child2);
         uut.push(child1, new CommandListenerAdapter());
         uut.push(child2, new CommandListenerAdapter() {
             @Override
 
     @Test
     public void pop_layoutHandlesChildWillDisappear() {
-        final StackLayout[] stackLayout = new StackLayout[1];
         uut = new StackControllerBuilder(activity)
                         .setTopBarButtonCreator(new TopBarButtonCreatorMock())
                         .setTitleBarReactViewCreator(new TitleBarReactViewCreatorMock())
                         .setTopBarController(new TopBarController())
                         .setId("uut")
                         .setInitialOptions(new Options())
+                        .setStackPresenter(new StackOptionsPresenter(activity, new Options()))
                         .build();
+        uut.ensureViewIsCreated();
         uut.push(child1, new CommandListenerAdapter());
         uut.push(child2, new CommandListenerAdapter() {
             @Override
                 uut.pop(new CommandListenerAdapter() {
                     @Override
                     public void onSuccess(String childId) {
-                        verify(stackLayout[0], times(1)).onChildWillAppear(child1, child2);
+                        verify(presenter, times(1)).onChildWillAppear(child1.options, child2.options);
                     }
                 });
             }
         uut.push(child1, new CommandListenerAdapter());
         assertThat(child1.getParentController()).isEqualTo(uut);
 
-        StackController anotherNavController = createStackController("another");
+        StackController anotherNavController = createStack("another");
+        anotherNavController.ensureViewIsCreated();
         anotherNavController.push(child2, new CommandListenerAdapter());
         assertThat(child2.getParentController()).isEqualTo(anotherNavController);
     }
         });
     }
 
+    @Test
+    public void pop_appearingChildHasCorrectLayoutParams() {
+        child2.options.animations.pop.enable = new Bool(false);
+        child1.options.topBar.drawBehind = new Bool(false);
+
+        StackController uut = createStack(Arrays.asList(child1, child2));
+        uut.ensureViewIsCreated();
+
+        assertThat(child2.getView().getParent()).isEqualTo(uut.getView());
+        uut.pop(new CommandListenerAdapter());
+        assertThat(child1.getView().getParent()).isEqualTo(uut.getView());
+
+        assertThat(child1.getView().getLayoutParams().width).isEqualTo(ViewGroup.LayoutParams.MATCH_PARENT);
+        assertThat(child1.getView().getLayoutParams().height).isEqualTo(ViewGroup.LayoutParams.MATCH_PARENT);
+        assertThat(((ViewGroup.MarginLayoutParams) child1.getView().getLayoutParams()).topMargin).isEqualTo(uut
+                .getTopBar()
+                .getHeight());
+    }
+
     @Test
     public void popSpecific_deepInStack() {
         uut.push(child1, new CommandListenerAdapter());
 
     @Test
     public void findControllerById_Deeply() {
-        StackController stack = createStackController("another");
+        StackController stack = createStack("another");
+        stack.ensureViewIsCreated();
         stack.push(child2, new CommandListenerAdapter());
         uut.push(stack, new CommandListenerAdapter());
         assertThat(uut.findControllerById(child2.getId())).isEqualTo(child2);
 
     @Test
     public void stackCanBePushed() {
-        StackController parent = createStackController("someStack");
+        StackController parent = createStack("someStack");
         parent.ensureViewIsCreated();
         parent.push(uut, new CommandListenerAdapter());
         uut.onViewAppeared();
 
     @Test
     public void applyOptions_applyOnlyOnFirstStack() {
-        StackController parent = spy(createStackController("someStack"));
+        StackController parent = spy(createStack("someStack"));
         parent.ensureViewIsCreated();
         parent.push(uut, new CommandListenerAdapter());
 
                         .setTopBarController(new TopBarController())
                         .setId("stack")
                         .setInitialOptions(new Options())
+                        .setStackPresenter(new StackOptionsPresenter(activity, new Options()))
                         .build());
         Options optionsToMerge = new Options();
         Component component = mock(Component.class);
                         .setTopBarController(new TopBarController())
                         .setId("stack")
                         .setInitialOptions(new Options())
+                        .setStackPresenter(new StackOptionsPresenter(activity, new Options()))
                         .build();
         ParentController parentController = Mockito.mock(ParentController.class);
         uut.setParentController(parentController);
+        uut.ensureViewIsCreated();
         Options optionsToMerge = new Options();
         optionsToMerge.topBar.testId = new Text("topBarID");
         optionsToMerge.bottomTabsOptions.testId = new Text("bottomTabsID");
 
     @Test
     public void mergeChildOptions_StackRelatedOptionsAreCleared() {
+        uut.ensureViewIsCreated();
         ParentController parentController = Mockito.mock(ParentController.class);
         uut.setParentController(parentController);
         Options options = new Options();
         assertThat(uut.getChildControllers()).extracting((Extractor<ViewController, String>) ViewController::getId).containsOnly(ids);
     }
 
-    private StackController createStackController() {
-        return createStackController("stack");
+    private StackController createStack() {
+        return createStack("stack", new ArrayList<>());
+    }
+
+    private StackController createStack(String id) {
+        return createStack(id, new ArrayList<>());
+    }
+
+    private StackController createStack(List<ViewController> children) {
+        return createStack("stack", children);
     }
 
-    private StackController createStackController(String id) {
+    private StackController createStack(String id, List<ViewController> children) {
         createTopBarController();
         return TestUtils.newStackController(activity)
+                .setChildren(children)
                 .setId(id)
                 .setTopBarController(topBarController)
                 .setChildRegistry(childRegistry)
                 .setAnimator(animator)
+                .setStackPresenter(presenter)
                 .build();
     }
 
         topBarController = spy(new TopBarController() {
             @Override
             protected TopBar createTopBar(Context context, ReactViewCreator buttonCreator, TitleBarReactViewCreator titleBarReactViewCreator, TopBarBackgroundViewController topBarBackgroundViewController, TopBarButtonController.OnClickListener topBarButtonClickListener, StackLayout stackLayout, ImageLoader imageLoader) {
-                return spy(super.createTopBar(context, buttonCreator, titleBarReactViewCreator, topBarBackgroundViewController, topBarButtonClickListener, stackLayout, ImageLoaderMock.mock()));
+                TopBar spy = spy(super.createTopBar(context, buttonCreator, titleBarReactViewCreator, topBarBackgroundViewController, topBarButtonClickListener, stackLayout, ImageLoaderMock.mock()));
+                spy.layout(0, 0, 1000, 100);
+                return spy;
             }
         });
     }

lib/ios/RNNBottomTabOptions.h

 @interface RNNBottomTabOptions : RNNOptions
 
 @property (nonatomic) NSUInteger tag;
-@property (nonatomic, strong) NSString* title;
+@property (nonatomic, strong) NSString* text;
 @property (nonatomic, strong) NSString* badge;
 @property (nonatomic, strong) NSString* testID;
 @property (nonatomic, strong) NSNumber* visible;
 @property (nonatomic, strong) NSDictionary* icon;
 @property (nonatomic, strong) NSDictionary* selectedIcon;
-@property (nonatomic, strong) NSDictionary* disableIconTint;
-@property (nonatomic, strong) NSDictionary* disableSelectedIconTint;
+@property (nonatomic, strong) NSDictionary* iconColor;
+@property (nonatomic, strong) NSDictionary* selectedIconColor;
+@property (nonatomic, strong) NSDictionary* textColor;
+@property (nonatomic, strong) NSDictionary* selectedTextColor;
+@property (nonatomic, strong) NSString* fontFamily;
+@property (nonatomic, strong) NSNumber* fontSize;
+
 @property (nonatomic, strong) NSDictionary* iconInsets;
 
 @end

lib/ios/RNNBottomTabOptions.m

 #import "RNNBottomTabOptions.h"
+#import "UIImage+tint.h"
 
 @implementation RNNBottomTabOptions
 
 }
 
 - (void)applyOn:(UIViewController *)viewController {
-	if (self.title || self.icon) {
-		UIImage *iconImage = nil;
-		if (self.disableIconTint) {
-			iconImage = [[RCTConvert UIImage:self.icon] imageWithRenderingMode:UIImageRenderingModeAlwaysOriginal];
-		} else {
-			iconImage = [RCTConvert UIImage:self.icon];
-		}
-		UITabBarItem* tabItem = [[UITabBarItem alloc] initWithTitle:self.title image:iconImage tag:self.tag];
+	if (self.text || self.icon || self.selectedIcon) {
+		UITabBarItem* tabItem = viewController.tabBarItem;
+		
+		tabItem.selectedImage = [self getSelectedIconImage];
+		tabItem.image = [self getIconImage];
+		tabItem.title = self.text;
+		tabItem.tag = self.tag;
 		tabItem.accessibilityIdentifier = self.testID;
 		
 		if (self.iconInsets && ![self.iconInsets isKindOfClass:[NSNull class]]) {
 			tabItem.imageInsets = UIEdgeInsetsMake(top, left, bottom, right);
 		}
 		
-		[viewController.navigationController setTabBarItem:tabItem];
-	}
-	if (self.selectedIcon) {
-		UIImage *selectedIconImage = nil;
-		if (self.disableSelectedIconTint) {
-			selectedIconImage = [[RCTConvert UIImage:self.selectedIcon] imageWithRenderingMode:UIImageRenderingModeAlwaysOriginal];
-		} else {
-			selectedIconImage = [RCTConvert UIImage:self.selectedIcon];
-		}
-		if (viewController.navigationController) {
-			viewController.navigationController.tabBarItem.selectedImage = selectedIconImage;
-		} else {
-			viewController.tabBarItem.selectedImage = selectedIconImage;
-		}	
+		[self appendTitleAttributes:tabItem];
+		
+		[viewController setTabBarItem:tabItem];
 	}
 	
 	if (self.badge) {
 	[self resetOptions];
 }
 
+- (UIImage *)getIconImage {
+	return [self getIconImageWithTint:self.iconColor];
+}
+
+- (UIImage *)getSelectedIconImage {
+	if (self.selectedIcon) {
+		if (self.selectedIconColor) {
+			return [[[RCTConvert UIImage:self.selectedIcon] withTintColor:[RCTConvert UIColor:self.selectedIconColor]] imageWithRenderingMode:UIImageRenderingModeAlwaysOriginal];
+		} else {
+			return [[RCTConvert UIImage:self.selectedIcon] imageWithRenderingMode:UIImageRenderingModeAlwaysOriginal];
+		}
+	} else {
+		return [self getIconImageWithTint:self.selectedIconColor];
+	}
+	
+	return nil;
+}
+
+- (UIImage *)getIconImageWithTint:(NSDictionary *)tintColor {
+	if (self.icon) {
+		if (tintColor) {
+			return [[[RCTConvert UIImage:self.icon] withTintColor:[RCTConvert UIColor:tintColor]] imageWithRenderingMode:UIImageRenderingModeAlwaysOriginal];
+		} else {
+			return [[RCTConvert UIImage:self.icon] imageWithRenderingMode:UIImageRenderingModeAlwaysOriginal];
+		}
+	}
+	
+	return nil;
+}
+
+- (void)appendTitleAttributes:(UITabBarItem *)tabItem {
+	NSMutableDictionary* selectedAttributes = [NSMutableDictionary dictionaryWithDictionary:[tabItem titleTextAttributesForState:UIControlStateNormal]];
+	if (self.selectedTextColor) {
+		selectedAttributes[NSForegroundColorAttributeName] = [RCTConvert UIColor:self.selectedTextColor];
+	} else {
+		selectedAttributes[NSForegroundColorAttributeName] = [UIColor blackColor];
+	}
+	
+	selectedAttributes[NSFontAttributeName] = [self tabBarTextFont];
+	[tabItem setTitleTextAttributes:selectedAttributes forState:UIControlStateSelected];
+
+	
+	NSMutableDictionary* normalAttributes = [NSMutableDictionary dictionaryWithDictionary:[tabItem titleTextAttributesForState:UIControlStateNormal]];
+	if (self.textColor) {
+		normalAttributes[NSForegroundColorAttributeName] = [RCTConvert UIColor:self.textColor];
+	} else {
+		normalAttributes[NSForegroundColorAttributeName] = [UIColor blackColor];
+	}
+	
+	normalAttributes[NSFontAttributeName] = [self tabBarTextFont];
+	[tabItem setTitleTextAttributes:normalAttributes forState:UIControlStateNormal];
+}
+
+
+-(UIFont *)tabBarTextFont {
+	if (self.fontFamily) {
+		return [UIFont fontWithName:self.fontFamily size:self.tabBarTextFontSizeValue];
+	}
+	else if (self.fontSize) {
+		return [UIFont systemFontOfSize:self.tabBarTextFontSizeValue];
+	}
+	else {
+		return nil;
+	}
+}
+
+-(CGFloat)tabBarTextFontSizeValue {
+	return self.fontSize ? [self.fontSize floatValue] : 10;
+}
+
 -(void)resetOptions {
-	self.title = nil;
+	self.text = nil;
 	self.badge = nil;
 	self.visible = nil;
 	self.icon = nil;
 	self.testID = nil;
 	self.iconInsets = nil;
+	self.selectedIcon = nil;
 }
 
 @end

lib/ios/RNNBottomTabsOptions.h

 @property (nonatomic, strong) NSNumber* drawBehind;
 @property (nonatomic, strong) NSString* currentTabId;
 
+@property (nonatomic, strong) NSNumber* tabColor;
+@property (nonatomic, strong) NSNumber* selectedTabColor;
 @property (nonatomic, strong) NSNumber* translucent;
 @property (nonatomic, strong) NSNumber* hideShadow;
 @property (nonatomic, strong) NSNumber* backgroundColor;
-@property (nonatomic, strong) NSNumber* tabColor;
-@property (nonatomic, strong) NSNumber* selectedTabColor;
 @property (nonatomic, strong) NSString* fontFamily;
 @property (nonatomic, strong) NSNumber* fontSize;
 

lib/ios/RNNBottomTabsOptions.m

 	if (self.hideShadow) {
 		viewController.tabBarController.tabBar.clipsToBounds = [self.hideShadow boolValue];
 	}
-	
-	if (self.tabBarTextFont) {
-		NSMutableDictionary* tabBarTitleTextAttributes = [NSMutableDictionary new];
-		tabBarTitleTextAttributes[NSFontAttributeName] = self.tabBarTextFont;
-		
-		for (UITabBarItem* item in viewController.tabBarController.tabBar.items) {
-			[item setTitleTextAttributes:tabBarTitleTextAttributes forState:UIControlStateNormal];
-		}
-	}
-	
-	if (self.tabColor) {
-		viewController.tabBarController.tabBar.unselectedItemTintColor = [RCTConvert UIColor:self.tabColor];
-	}
-	
-	if (self.selectedTabColor) {
-		viewController.tabBarController.tabBar.tintColor = [RCTConvert UIColor:self.selectedTabColor];
-	}
-	
+
 	[self resetOptions];
 }
 

lib/ios/RNNControllerFactory.m

 }
 
 - (RNNNavigationOptions *)createOptions:(NSDictionary *)optionsDict {
-	RNNNavigationOptions* options = [[RNNNavigationOptions alloc] initWithDict:_defaultOptionsDict];
-	[options mergeWith:optionsDict];
+	RNNNavigationOptions* options = [[RNNNavigationOptions alloc] initWithDict:optionsDict];
+	options.defaultOptions = [[RNNNavigationOptions alloc] initWithDict:_defaultOptionsDict];
+	
 	return options;
 }
 

lib/ios/RNNNavigationOptions.h

 @property (nonatomic, strong) RNNPreviewOptions* preview;
 @property (nonatomic, strong) RNNLayoutOptions* layout;
 
+@property (nonatomic, strong) RNNOptions* defaultOptions;
+
 @property (nonatomic, strong) NSMutableDictionary* originalTopBarImages;
 @property (nonatomic, strong) NSNumber* popGesture;
 @property (nonatomic, strong) NSDictionary* backgroundImage;

lib/ios/RNNNavigationOptions.m

 
 
 -(void)applyOn:(UIViewController<RNNRootViewProtocol> *)viewController {
+	[self mergeOptions:_defaultOptions overrideOptions:NO];
 	[self.topBar applyOn:viewController];
 	[self.bottomTabs applyOn:viewController];
 	[self.topTab applyOn:viewController];

lib/ios/RNNUtils.h

 #import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
 
 @interface RNNUtils : NSObject
 

lib/ios/ReactNativeNavigation.xcodeproj/project.pbxproj

 		5064495E20DC62B90026709C /* RNNSideMenuSideOptions.m in Sources */ = {isa = PBXBuildFile; fileRef = 5064495C20DC62B90026709C /* RNNSideMenuSideOptions.m */; };
 		506A2B1420973DFD00F43A95 /* RNNErrorHandler.h in Headers */ = {isa = PBXBuildFile; fileRef = 506A2B1220973DFD00F43A95 /* RNNErrorHandler.h */; };
 		506A2B1520973DFD00F43A95 /* RNNErrorHandler.m in Sources */ = {isa = PBXBuildFile; fileRef = 506A2B1320973DFD00F43A95 /* RNNErrorHandler.m */; };
+		50706E6D20CE7CA5003345C3 /* UIImage+tint.h in Headers */ = {isa = PBXBuildFile; fileRef = 50706E6B20CE7CA5003345C3 /* UIImage+tint.h */; };
+		50706E6E20CE7CA5003345C3 /* UIImage+tint.m in Sources */ = {isa = PBXBuildFile; fileRef = 50706E6C20CE7CA5003345C3 /* UIImage+tint.m */; };
 		50762D08205E96C200E3D18A /* RNNModalAnimation.h in Headers */ = {isa = PBXBuildFile; fileRef = 50762D06205E96C200E3D18A /* RNNModalAnimation.h */; };
 		50762D09205E96C200E3D18A /* RNNModalAnimation.m in Sources */ = {isa = PBXBuildFile; fileRef = 50762D07205E96C200E3D18A /* RNNModalAnimation.m */; };
 		507E7D57201DDD3000444E6C /* RNNAnimationOptions.h in Headers */ = {isa = PBXBuildFile; fileRef = 507E7D55201DDD3000444E6C /* RNNAnimationOptions.h */; };
 		5064495C20DC62B90026709C /* RNNSideMenuSideOptions.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNNSideMenuSideOptions.m; sourceTree = "<group>"; };
 		506A2B1220973DFD00F43A95 /* RNNErrorHandler.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNNErrorHandler.h; sourceTree = "<group>"; };
 		506A2B1320973DFD00F43A95 /* RNNErrorHandler.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNNErrorHandler.m; sourceTree = "<group>"; };
+		50706E6B20CE7CA5003345C3 /* UIImage+tint.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "UIImage+tint.h"; sourceTree = "<group>"; };
+		50706E6C20CE7CA5003345C3 /* UIImage+tint.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = "UIImage+tint.m"; sourceTree = "<group>"; };
 		50762D06205E96C200E3D18A /* RNNModalAnimation.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNNModalAnimation.h; sourceTree = "<group>"; };
 		50762D07205E96C200E3D18A /* RNNModalAnimation.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNNModalAnimation.m; sourceTree = "<group>"; };
 		507E7D55201DDD3000444E6C /* RNNAnimationOptions.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNNAnimationOptions.h; sourceTree = "<group>"; };
 				390AD476200F499D00A8250D /* RNNSwizzles.m */,
 				506A2B1220973DFD00F43A95 /* RNNErrorHandler.h */,
 				506A2B1320973DFD00F43A95 /* RNNErrorHandler.m */,
+				50706E6B20CE7CA5003345C3 /* UIImage+tint.h */,
+				50706E6C20CE7CA5003345C3 /* UIImage+tint.m */,
 			);
 			name = Helpers;
 			sourceTree = "<group>";
 				50451D0D2042F70900695F00 /* RNNTransition.h in Headers */,
 				507F43F81FF525B500D9425B /* RNNSegmentedControl.h in Headers */,
 				50175CD1207A2AA1004FE91B /* RNNComponentOptions.h in Headers */,
+				50706E6D20CE7CA5003345C3 /* UIImage+tint.h in Headers */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
 				507F43F51FF4FCFE00D9425B /* HMSegmentedControl.m in Sources */,
 				50451D0A2042E20600695F00 /* RNNTransitionsOptions.m in Sources */,
 				507F43C61FF4F17C00D9425B /* RNNTopTabsViewController.m in Sources */,
+				50706E6E20CE7CA5003345C3 /* UIImage+tint.m in Sources */,
 				50A00C38200F84D6000F01A6 /* RNNOverlayOptions.m in Sources */,
 				50762D09205E96C200E3D18A /* RNNModalAnimation.m in Sources */,
 				50EB93421FE14A3E00BD8EEE /* RNNBottomTabOptions.m in Sources */,

lib/ios/ReactNativeNavigationTests/RNNRootViewControllerTest.m

 	XCTAssertTrue([self.uut.tabBarController.tabBar.barTintColor isEqual:expectedColor]);
 }
 
--(void)testTabBarSelectedColor_validColor{
-	NSNumber* inputColor = @(0xFFFF0000);
-	self.options.bottomTabs.tabColor = inputColor;
-	[self.uut embedInTabBarController];
-	UIColor* expectedColor = [UIColor colorWithRed:1 green:0 blue:0 alpha:1];
-	XCTAssertTrue([self.uut.tabBarController.tabBar.unselectedItemTintColor isEqual:expectedColor]);
-}
-
--(void)testTabBarUnselectedColor_validColor{
-	NSNumber* inputColor = @(0xFFFF0000);
-	self.options.bottomTabs.selectedTabColor = inputColor;
-	[self.uut embedInTabBarController];
-	UIColor* expectedColor = [UIColor colorWithRed:1 green:0 blue:0 alpha:1];
-	XCTAssertTrue([self.uut.tabBarController.tabBar.tintColor isEqual:expectedColor]);
-}
-
 -(void)testTabBarTextFontFamily_validFont{
 	NSString* inputFont = @"HelveticaNeue";
-	self.options.bottomTabs.fontFamily = inputFont;
+	self.options.bottomTab.fontFamily = inputFont;
+	self.options.bottomTab.text = @"Tab 1";
 	[self.uut embedInTabBarController];
 	UIFont* expectedFont = [UIFont fontWithName:inputFont size:10];
 	NSDictionary* attributes = [self.uut.tabBarController.tabBar.items.firstObject titleTextAttributesForState:UIControlStateNormal];
 }
 
 -(void)testTabBarTextFontSize_withoutTextFontFamily_withoutTextColor {
-	self.options.bottomTabs.fontSize = @(15);
+	self.options.bottomTab.fontSize = @(15);
+	self.options.bottomTab.text = @"Tab 1";
 	[self.uut embedInTabBarController];
 	UIFont* expectedFont = [UIFont systemFontOfSize:15];
 	NSDictionary* attributes = [self.uut.tabBarController.tabBar.items.firstObject titleTextAttributesForState:UIControlStateNormal];
 }
 
 -(void)testTabBarTextFontSize_withoutTextFontFamily {
-	self.options.bottomTabs.fontSize = @(15);
+	self.options.bottomTab.fontSize = @(15);
+	self.options.bottomTab.text = @"Tab 1";
 	[self.uut embedInTabBarController];
 	UIFont* expectedFont = [UIFont systemFontOfSize:15];
 	NSDictionary* attributes = [self.uut.tabBarController.tabBar.items.firstObject titleTextAttributesForState:UIControlStateNormal];
 
 -(void)testTabBarTextFontSize_withTextFontFamily_withTextColor {
 	NSString* inputFont = @"HelveticaNeue";
-	self.options.bottomTabs.fontSize = @(15);
-	self.options.bottomTabs.fontFamily = inputFont;
+	self.options.bottomTab.text = @"Tab 1";
+	self.options.bottomTab.fontSize = @(15);
+	self.options.bottomTab.fontFamily = inputFont;
 	[self.uut embedInTabBarController];
 	UIFont* expectedFont = [UIFont fontWithName:inputFont size:15];
 	NSDictionary* attributes = [self.uut.tabBarController.tabBar.items.firstObject titleTextAttributesForState:UIControlStateNormal];
 
 -(void)testTabBarTextFontSize_withTextFontFamily_withoutTextColor {
 	NSString* inputFont = @"HelveticaNeue";
-	self.options.bottomTabs.fontSize = @(15);
-	self.options.bottomTabs.fontFamily = inputFont;
+	self.options.bottomTab.text = @"Tab 1";
+	self.options.bottomTab.fontSize = @(15);
+	self.options.bottomTab.fontFamily = inputFont;
 	[self.uut embedInTabBarController];
 	UIFont* expectedFont = [UIFont fontWithName:inputFont size:15];
 	NSDictionary* attributes = [self.uut.tabBarController.tabBar.items.firstObject titleTextAttributesForState:UIControlStateNormal];

lib/ios/UIImage+tint.h

+#import <UIKit/UIKit.h>
+
+@interface UIImage (tint)
+
+- (UIImage *)withTintColor:(UIColor *)color;
+
+@end

lib/ios/UIImage+tint.m

+#import "UIImage+tint.h"
+
+@implementation UIImage (tint)
+
+- (UIImage *)withTintColor:(UIColor *)color {
+	UIGraphicsBeginImageContext(self.size);
+	CGContextRef context = UIGraphicsGetCurrentContext();
+	
+	CGContextTranslateCTM(context, 0, self.size.height);
+	CGContextScaleCTM(context, 1.0, -1.0);
+	
+	CGRect rect = CGRectMake(0, 0, self.size.width, self.size.height);
+	
+	// draw alpha-mask
+	CGContextSetBlendMode(context, kCGBlendModeNormal);
+	CGContextDrawImage(context, rect, self.CGImage);
+	
+	// draw tint color, preserving alpha values of original image
+	CGContextSetBlendMode(context, kCGBlendModeSourceIn);
+	[color setFill];
+	CGContextFillRect(context, rect);
+	
+	UIImage *coloredImage = UIGraphicsGetImageFromCurrentImageContext();
+	UIGraphicsEndImageContext();
+	
+	return coloredImage;
+}
+
+@end

playground/android/build.gradle

             // All of React Native (JS, Obj-C sources, Android binaries) is installed from npm
             url "$rootDir/../../node_modules/react-native/android"
         }
+        maven { url 'https://jitpack.io' }
     }
 }

playground/src/app.js

   registerScreens();
   Navigation.events().registerAppLaunchedListener(() => {
     Navigation.setDefaultOptions({
+      bottomTab: {
+        iconColor: '#1B4C77',
+        selectedIconColor: '#0f0',
+        textColor: '#1B4C77',
+        selectedTextColor: '#0f0',
+        fontFamily: 'HelveticaNeue-Italic',
+        fontSize: 13
+      },
       _animations: {
         startApp: {
           y: {

playground/src/screens/TextScreen.js

         <Text style={styles.h1} testID={testIDs.CENTERED_TEXT_HEADER}>{this.props.text || 'Text Screen'}</Text>
         {this.renderTextFromFunctionInProps()}
         <Text style={styles.footer}>{`this.props.componentId = ${this.props.componentId}`}</Text>
-        <Button title={'Set Tab Badge'} testID={testIDs.SET_TAB_BADGE_BUTTON} onPress={() => this.onButtonPress()} />
+        <Button title={'Set Tab Badge'} testID={testIDs.SET_TAB_BADGE_BUTTON} onPress={() => this.onClickSetBadge()} />
         <Button title={'Switch To Tab 2'} testID={testIDs.SWITCH_SECOND_TAB_BUTTON} onPress={() => this.onClickSwitchToTab()} />
         <Button title={'Switch To Tab 1 by componentID'} testID={testIDs.SWITCH_FIRST_TAB_BUTTON} onPress={() => this.onClickSwitchToTabByComponentID()} />
         <Button title='Hide Tab Bar' testID={testIDs.HIDE_BOTTOM_TABS_BUTTON} onPress={() => this.hideTabBar(false)} />
     );
   }
 
-  onButtonPress() {
+  onClickSetBadge() {
     Navigation.mergeOptions(this.props.componentId, {
       bottomTab: {
         badge: `TeSt`
         currentTabIndex: 1,
         visible: false,
         drawBehind: true,
-        animate: true,
-        tabColor: 'blue',
-        selectedTabColor: 'red'
+        animate: true
       }
     });
   }

playground/src/screens/WelcomeScreen.js

                 ],
                 options: {
                   bottomTab: {
-                    title: 'Tab 1',
+                    text: 'Tab 1',
                     icon: require('../images/one.png'),
+                    selectedIcon: require('../images/one.png'),
                     testID: testIDs.FIRST_TAB_BAR_BUTTON
                   },
                   topBar: {
                 ],
                 options: {
                   bottomTab: {
-                    title: 'Tab 2',
+                    text: 'Tab 2',
                     icon: require('../images/two.png'),
                     testID: testIDs.SECOND_TAB_BAR_BUTTON
                   }
           ],
           options: {
             bottomTabs: {
-              tabColor: 'red',
               titleDisplayMode: 'alwaysShow',
-              selectedTabColor: 'blue',
-              fontFamily: 'HelveticaNeue-Italic',
-              fontSize: 13,
               testID: testIDs.BOTTOM_TABS_ELEMENT
             }
           }
                           name: 'navigation.playground.TextScreen',
                           passProps: {
                             text: 'This is a side menu center screen tab 1'
-                          }
+                          },
+                          // options: {
+                          //   bottomTab: {
+                          //     iconColor: 'red',
+                          //     textColor: 'red',
+                          //     selectedIconColor: 'purple',
+                          //     selectedTextColor: 'purple',
+                          //   }
+                          // }
                         }
                       }
                     ],
                     options: {
                       bottomTab: {
-                        title: 'Tab 1',
+                        iconColor: 'red',
+                        textColor: 'red',
+                        selectedIconColor: 'purple',
+                        selectedTextColor: 'purple',
+                        text: 'Tab 1',
                         icon: require('../images/one.png'),
                         testID: testIDs.FIRST_TAB_BAR_BUTTON
                       }
                     ],
                     options: {
                       bottomTab: {
-                        title: 'Tab 2',
+                        text: 'Tab 2',
                         icon: require('../images/two.png'),
                         testID: testIDs.SECOND_TAB_BAR_BUTTON
                       }
                     ],
                     options: {
                       bottomTab: {
-                        title: 'Tab 3',
+                        text: 'Tab 3',
                         icon: require('../images/three.png'),
                         testID: testIDs.SECOND_TAB_BAR_BUTTON
                       }
                 }
               ],
               options: {
-                bottomTabs: {
-                  tabColor: 'red',
-                  selectedTabColor: 'blue',
+                bottomTab: {
+                  textColor: '#AED581',
+                  iconColor: '#AED581',
+                  selectedTextColor: '#90CAF9',
+                  selectedIconColor: '#90CAF9',
                   fontFamily: 'HelveticaNeue-Italic',
                   fontSize: 13
                 }