Merge remote-tracking branch 'origin/v2' into v2-rn51

AndroidE2E/app/src/androidTest/java/com/reactnativenavigation/e2e/androide2e/OverlayTest.java

 package com.reactnativenavigation.e2e.androide2e;
 
 import android.support.test.uiautomator.By;
+import android.support.test.uiautomator.UiObjectNotFoundException;
 
 import org.junit.Test;
 
 		elementByText("PUSH OPTIONS SCREEN").click();
         elementByText("SHOW OVERLAY").click();
 		assertExists(By.text("Test view"));
-		elementByText("OK").click();
-		assertExists(By.text("Overlay disappeared"));
-        elementByText("OK").click();
+        assetDismissed();
+	}
+
+    @Test
+	public void testOverlayNotInterceptingTouchEvents() throws Exception {
+		elementByText("PUSH OPTIONS SCREEN").click();
+        elementByText("SHOW TOUCH THROUGH OVERLAY").click();
+		assertExists(By.text("Test view"));
+        elementByText("DYNAMIC OPTIONS").click();
+        assertExists(By.text("Dynamic Title"));
+        assetDismissed();
 	}
+
+    private void assetDismissed() throws UiObjectNotFoundException {
+        elementByText("OK").click();
+        assertExists(By.text("Overlay disappeared"));
+        elementByText("OK").click();
+    }
 }

AndroidE2E/app/src/androidTest/java/com/reactnativenavigation/e2e/androide2e/StaticLifecycleEvents.java

+package com.reactnativenavigation.e2e.androide2e;
+
+import android.support.test.uiautomator.By;
+
+import org.junit.Test;
+
+public class StaticLifecycleEvents extends BaseTest {
+    @Test
+    public void didAppearDidDisappear() throws Exception {
+        elementByText("STATIC LIFECYCLE EVENTS").click();
+        assertExists(By.text("Static Lifecycle Events"));
+        assertExists(By.text("didAppear | navigation.playground.StaticLifecycleOverlay"));
+        elementByText("PUSH").click();
+        assertExists(By.text("didAppear | navigation.playground.PushedScreen"));
+        assertExists(By.text("didDisappear | navigation.playground.WelcomeScreen"));
+    }
+}

Jenkinsfile

       }
     }
   }
-}
+}
+

docs/_sidebar.md

  - [Top Level](/docs/Navigation)
 - Params
  - [Root](/docs/Root)
- - [Container](/docs/Container)
+ - [Component](/docs/Component)
  - [SideMenu](/docs/SideMenu)
 - Options
  - [NavigationOptions](/docs/options/NavigationOptions)

docs/docs/CONTRIBUTING.md

 | `lib` | The project itself composed of: |
 | `lib/android` | android sources and unit tests |
 | `lib/ios` | iOS sources and unit tests |
-| `lib/src` | javascript sources and unit tests |
-| `lib/src/index.js` | the entry point for `import Navigation from 'react-native-navigation'` |
+| `lib/src` | TypeScript sources and unit tests |
+| `lib/dist` | compiled javascript sources and unit tests |
+| `lib/dist/index.js` | the entry point for `import Navigation from 'react-native-navigation'` |
 | `e2e` | [detox](https://github.com/wix/detox) iOS e2e tests (in the future, once detox supports it, we will have android e2e here as well) |
 | `AndroidE2E` | Android e2e tests using native uiautomator (until detox for android is ready) |
 | `playground` | The end-user project all e2e tests run against. Contains its own `src`, `android` and `ios`. Does not have its own package.json, depends on the local `<root>/lib` in order not to go through npm. |
 | Command | Description |
 | ------- | ----------- |
 | `npm install` | installs dependencies |
+| `npm run build` | compiles TypeScript sources `./lib/src` into javascript `./lib/dist` |
 | `npm run clean` | cleans all build directories, stops packager, fixes flakiness by removing watchman cache, etc. |
 | `npm run start` | starts the react-native packager for local debugging |
 | `npm run xcode` | for convenience, opens xcode in this project |
 | `npm run install-android`  |  builds playground debug/release version and installs on running android devices/emulators. <br> **Options:** `-- --release` |
 | `npm run uninstall-android` | uninstalls playground from running android devices/simulators |
 | `npm run test-js` | runs javascript tests and coverage report |
-| `npm run test-watch` | runs javascript tests in watch mode (can also use the provided wallaby config) |
 | `npm run test-unit-ios` | runs ios unit tests in debug/release <br> **Options:** `-- --release` |
 | `npm run test-unit-android` | runs android unit tests in debug/release <br> **Options:** `-- --release` |
 | `npm run test-e2e-ios` | runs the ios e2e suite (with detox) in debug/release <br> **Options:** `-- --release`|

docs/docs/Container.md → docs/docs/Component.md

-<h1>Container</h1>
+<h1>Component</h1>
 
 **Properties**
 
 | Name | Type | Description |
 | --- | --- | --- |
-| name | <code>string</code> | The container's registered name |
-| topTabs | [<code>Array.&lt;Container&gt;</code>](#Container) |  |
+| name | <code>string</code> | The components registered name |
+| topTabs | [<code>Array.&lt;Component&gt;</code>](#Component) |  |
 | passProps | <code>object</code> | props |
 | options | <a href="https://wix.github.io/react-native-navigation/v2/#/docs/Options">Options</a> |  |
 

docs/docs/Navigation.md

 # Navigation
 
 * [Navigation](#Navigation)
-    * [.registerContainer(containerName, getContainerFunc)](#Navigation+registerContainer)
+    * [.registerComponent(componentName, getComponentFunc)](#Navigation+registerComponent)
     * [.setRoot(root)](#Navigation+setRoot)
     * [.setDefaultOptions(options)](#Navigation+setDefaultOptions)
-    * [.setOptions(containerId, options)](#Navigation+setOptions)
+    * [.setOptions(componentId, options)](#Navigation+setOptions)
     * [.showModal(params)](#Navigation+showModal)
-    * [.dismissModal(containerId)](#Navigation+dismissModal)
+    * [.dismissModal(componentId)](#Navigation+dismissModal)
     * [.dismissAllModals()](#Navigation+dismissAllModals)
-    * [.push(containerId, container)](#Navigation+push)
-    * [.pop(containerId, params)](#Navigation+pop)
-    * [.popTo(containerId)](#Navigation+popTo)
-    * [.popToRoot(containerId)](#Navigation+popToRoot)
+    * [.push(componentId, component)](#Navigation+push)
+    * [.pop(componentId, params)](#Navigation+pop)
+    * [.popTo(componentId)](#Navigation+popTo)
+    * [.popToRoot(componentId)](#Navigation+popToRoot)
     * [.events()](#Navigation+events)
 
 
 * * *
 
-<a name="Navigation+registerContainer"></a>
+<a name="Navigation+registerComponent"></a>
 
-## navigation.registerContainer(containerName, getContainerFunc)
+## navigation.registerComponent(componentName, getComponentFunc)
 Every screen component in your app must be registered with a unique name. The component itself is a traditional React component extending React.Component.
 
 
 | Param | Type | Description |
 | --- | --- | --- |
-| containerName | <code>string</code> | Unique container name |
-| getContainerFunc | <code>function</code> | generator function, typically `() => require('./myContainer')` |
+| componentName | <code>string</code> | Unique component name |
+| getComponentFunc | <code>function</code> | generator function, typically `() => require('./myComponent')` |
 
 
 * * *
 
 | Param | Type |
 | --- | --- |
-| root | <a href="https://wix.github.io/react-native-navigation/v2/#/docs/Root">Root</a> | 
+| root | <a href="https://wix.github.io/react-native-navigation/v2/#/docs/Root">Root</a> |
 
 
 * * *
 
 | Param | Type |
 | --- | --- |
-| options | <a href="https://wix.github.io/react-native-navigation/v2/#/docs/options/NavigationOptions">NavigationOptions</a> | 
+| options | <a href="https://wix.github.io/react-native-navigation/v2/#/docs/options/NavigationOptions">NavigationOptions</a> |
 
 
 * * *
 
 <a name="Navigation+setOptions"></a>
 
-## navigation.setOptions(containerId, options)
-Change a containers navigation options
+## navigation.setOptions(componentId, options)
+Change a components navigation options
 
 
 | Param | Type | Description |
 | --- | --- | --- |
-| containerId | <code>string</code> | The container's id. |
+| componentId | <code>string</code> | The component's id. |
 | options | <a href="https://wix.github.io/react-native-navigation/v2/#/docs/options/NavigationOptions">NavigationOptions</a> |  |
 
 
 
 | Param | Type |
 | --- | --- |
-| params | <code>object</code> | 
+| params | <code>object</code> |
 
 
 * * *
 
 <a name="Navigation+dismissModal"></a>
 
-## navigation.dismissModal(containerId)
-Dismiss a modal by containerId. The dismissed modal can be anywhere in the stack.
+## navigation.dismissModal(componentId)
+Dismiss a modal by componentId. The dismissed modal can be anywhere in the stack.
 
 
 | Param | Type | Description |
 | --- | --- | --- |
-| containerId | <code>string</code> | The container's id. |
+| componentId | <code>string</code> | The component's id. |
 
 
 * * *
 
 <a name="Navigation+push"></a>
 
-## navigation.push(containerId, container)
+## navigation.push(componentId, component)
 Push a new screen into this screen's navigation stack.
 
 
 | Param | Type | Description |
 | --- | --- | --- |
-| containerId | <code>string</code> | The container's id. |
-| container | <a href="https://wix.github.io/react-native-navigation/v2/#/docs/Container">Container</a> |  |
+| componentId | <code>string</code> | The component's id. |
+| component | <a href="https://wix.github.io/react-native-navigation/v2/#/docs/Component">Component</a> |  |
 
 
 * * *
 
 <a name="Navigation+pop"></a>
 
-## navigation.pop(containerId, params)
-Pop a container from the stack, regardless of it's position.
+## navigation.pop(componentId, params)
+Pop a component from the stack, regardless of it's position.
 
 
 | Param | Type | Description |
 | --- | --- | --- |
-| containerId | <code>string</code> | The container's id. |
+| componentId | <code>string</code> | The component's id. |
 | params | <code>*</code> |  |
 
 
 
 <a name="Navigation+popTo"></a>
 
-## navigation.popTo(containerId)
-Pop the stack to a given container
+## navigation.popTo(componentId)
+Pop the stack to a given component
 
 
 | Param | Type | Description |
 | --- | --- | --- |
-| containerId | <code>string</code> | The container's id. |
+| componentId | <code>string</code> | The component's id. |
 
 
 * * *
 
 <a name="Navigation+popToRoot"></a>
 
-## navigation.popToRoot(containerId)
-Pop the container's stack to root.
+## navigation.popToRoot(componentId)
+Pop the component's stack to root.
 
 
 | Param | Type |
 | --- | --- |
-| containerId | <code>*</code> | 
+| componentId | <code>*</code> |
 
 
 * * *
 
 ## navigation.events()
 Obtain the events registery instance
-

docs/docs/Root.md

 
 | Name | Type |
 | --- | --- |
-| container | <a href="https://wix.github.io/react-native-navigation/v2/#/docs/Container">Container</a> | 
+| component | <a href="https://wix.github.io/react-native-navigation/v2/#/docs/Component">Component</a> | 
 | sideMenu | <a href="https://wix.github.io/react-native-navigation/v2/#/docs/SideMenu">SideMenu</a> | 
-| bottomTabs | <a href="https://wix.github.io/react-native-navigation/v2/#/docs/Container">Container[]</a> | 
+| bottomTabs | <a href="https://wix.github.io/react-native-navigation/v2/#/docs/Component">Component[]</a> | 
 

docs/docs/SideMenu.md

 
 | Name | Type |
 | --- | --- |
-| left | <a href="https://wix.github.io/react-native-navigation/v2/#/docs/Container">Container</a> | 
-| right | <a href="https://wix.github.io/react-native-navigation/v2/#/docs/Container">Container</a> | 
+| left | <a href="https://wix.github.io/react-native-navigation/v2/#/docs/Component">Component</a> | 
+| center | <a href="https://wix.github.io/react-native-navigation/v2/#/docs/Component">Component</a> | 
+| right | <a href="https://wix.github.io/react-native-navigation/v2/#/docs/Component">Component</a> | 
 

docs/docs/installation-android.md

 # Android Installation
 
+!> Make sure your Android Studio installation is updated. We recommend editing `gralde` and `java` files in Android Studio as the ide will suggest fixes and point out errors, this way you avoid most common pitfalls.
+
+
 1. Install `react-native-navigation` latest stable version.
 
 	```sh
 	include ':react-native-navigation'
 	project(':react-native-navigation').projectDir = new File(rootProject.projectDir, '../node_modules/react-native-navigation/lib/android/app/')
 	```
+	
+3. Update `android/build.gradle`
+
+	```diff
+	buildscript {
+	    repositories {
+	+        mavenLocal()
+	+        mavenCentral()
+	+        google()
+	+        jcenter()
+	    }
+	    dependencies {
+	+        classpath 'com.android.tools.build:gradle:3.0.1'
+	-        classpath 'com.android.tools.build:gradle:2.2.3'
+	    }
+	}
+	
+	allprojects {
+	    repositories {
+	        mavenLocal()
+	+        mavenCentral()
+	+        google()
+	        jcenter()
+	        maven {
+	            // All of React Native (JS, Obj-C sources, Android binaries) is installed from npm
+	            url "$rootDir/../../node_modules/react-native/android"
+	        }
+	    }
+	}
+	```
+
+4. Update project dependencies in `android/app/build.gradle`.
 
-3. Update project dependencies in `android/app/build.gradle`.
 	```groovy
 	android {
-		compileSdkVersion 25
-		buildToolsVersion "25.0.1"
+	    compileSdkVersion 25
+	    buildToolsVersion "27.0.3"
+	    
+	    defaultConfig {
+	        minSdkVersion 19
+	        targetSdkVersion 25
 		...
+	    }
+	
+	    compileOptions {
+	        sourceCompatibility JavaVersion.VERSION_1_8
+	        targetCompatibility JavaVersion.VERSION_1_8
+	    }
+	    ...
 	}
-
+	
 	dependencies {
-		compile fileTree(dir: "libs", include: ["*.jar"])
-		compile "com.android.support:appcompat-v7:23.0.1"
-		compile "com.facebook.react:react-native:+"
-		compile project(':react-native-navigation')
+	    implementation fileTree(dir: "libs", include: ["*.jar"])
+	    implementation "com.android.support:appcompat-v7:25.4.0"
+	    implementation "com.facebook.react:react-native:+"
+	    implementation project(':react-native-navigation')
 	}
 	```
+	
+5. Make sure you're using the new gradle plugin, edit `android/gradle/wrapper/gradle-wrapper.properties`
+
+	```diff
+	distributionBase=GRADLE_USER_HOME
+	distributionPath=wrapper/dists
+	zipStoreBase=GRADLE_USER_HOME
+	zipStorePath=wrapper/dists
+	+distributionUrl=https\://services.gradle.org/distributions/gradle-4.4-all.zip
+	-distributionUrl=https\://services.gradle.org/distributions/gradle-2.14.1-all.zip
+	```
+
+6. Update `gradle.properties` and disable incremental resource processing
+
+	```diff
+	+# Disable incremental resource processing as it broke relase build
+	+android.enableAapt2=false
+	```
 
-4. In `MainActivity.java` it should extend `com.reactnativenavigation.NavigationActivity` instead of `ReactActivity`.
+7. In `MainActivity.java` it should extend `com.reactnativenavigation.NavigationActivity` instead of `ReactActivity`.
 
 	This file can be located in `android/app/src/main/java/com/yourproject/`.
 
 
 	If you have any **react-native** related methods, you can safely delete them.
 
-5. In `MainApplication.java`, add the following
+8. In `MainApplication.java`, add the following
+	
 	```java
 	import com.reactnativenavigation.NavigationApplication;
 
 		return BuildConfig.DEBUG;
 	}
 
-	@Nullable
 	@Override
 	public List<ReactPackage> createAdditionalReactPackages() {
 		return Arrays.<ReactPackage>asList(
 
 	Make sure that `isDebug` methods is implemented.
 
-6. Update `AndroidManifest.xml` and set **android:name** value to `.MainApplication`
+9. Update `AndroidManifest.xml` and set **android:name** value to `.MainApplication`
+	
 	```xml
 	<application
 		android:name=".MainApplication"

docs/docs/options/BottomTabs.md

 | currentTabId | <code>string</code> | 
 | currentTabIndex | <code>number</code> | 
 | hidden | <code>boolean</code> | 
-| animateHide | <code>boolean</code> | 
+| animate | <code>boolean</code> | 
 | testID | <code>string</code> | 
 | drawUnder | <code>boolean</code> | 
 

docs/docs/options/TopBar.md

 | textFontFamily | <code>string</code> | 
 | testID | <code>string</code> | 
 | hidden | <code>boolean</code> | 
-| animateHide | <code>boolean</code> | 
+| animate | <code>boolean</code> | 
 | hideOnScroll | <code>boolean</code> | 
 | transparent | <code>boolean</code> | 
 | translucent | <code>boolean</code> | 

docs/docs/usage.md

 
 ### Navigation
 ```js
-import Navigation from 'react-native-navigation';
+import { Navigation } from 'react-native-navigation';
 ```
 ### Events - On App Launched
 How to initiate your app.
 ```js
 Navigation.events().onAppLaunched(() => {
   Navigation.setRoot({
-    container: {
+    component: {
       name: 'navigation.playground.WelcomeScreen'
     }
   });
 });
 ```
 
-### registerContainer(screenID, generator)
+### registerComponent(screenID, generator)
 Every screen component in your app must be registered with a unique name. The component itself is a traditional React component extending React.Component.
 
 ```js
-Navigation.registerContainer(`navigation.playground.WelcomeScreen`, () => WelcomeScreen);
+Navigation.registerComponent(`navigation.playground.WelcomeScreen`, () => WelcomeScreen);
 ```
 
 ### setRoot({params})
 
 ```js
 Navigation.setRoot({
-  container: {
-    name: 'navigation.playground.WelcomeScreen'
-  },
   sideMenu: {
     left: {
-      container: {
+      component: {
         name: 'navigation.playground.TextScreen',
         passProps: {
           text: 'This is a left side menu screen'
         }
       }
     },
+    center: {
+      component: {
+        name: 'navigation.playground.WelcomeScreen'
+      },
+    },
     right: {
-      container: {
+      component: {
         name: 'navigation.playground.TextScreen',
         passProps: {
           text: 'This is a right side menu screen'
 
 ```js
 Navigation.setRoot({
-  bottomTabs: [
-    {
-      container: {
-        name: 'navigation.playground.TextScreen',
-        passProps: {
-          text: 'This is tab 1',
-          myFunction: () => 'Hello from a function!'
-        }
-      }
+  bottomTabs: {
+    children: [
+      {
+        component: {
+          name: 'navigation.playground.TextScreen',
+          passProps: {
+            text: 'This is tab 1',
+            myFunction: () => 'Hello from a function!',
+          },
+        },
+      },
+      {
+        component: {
+          name: 'navigation.playground.TextScreen',
+          passProps: {
+            text: 'This is tab 2',
+          },
+        },
+      },
+    ],
+  },
+});
+```
+
+Start a stack based app (with options):
+
+```js
+Navigation.setRoot({
+  stack: {
+    options: {
+      topBar: {
+        hidden: true,
+      },
     },
-    {
-      container: {
-        name: 'navigation.playground.TextScreen',
-        passProps: {
-          text: 'This is tab 2'
-        }
-      }
-    }
-  ]
+    children: [
+      {
+        component: {
+          name: 'navigation.playground.TextScreen',
+          passProps: {
+            text: 'This is tab 1',
+            myFunction: () => 'Hello from a function!',
+          },
+        },
+      },
+      {
+        component: {
+          name: 'navigation.playground.TextScreen',
+          passProps: {
+            text: 'This is tab 2',
+          },
+        },
+      },
+    ],
+  },
 });
 ```
 ## Screen API
 Push a new screen into this screen's navigation stack.
 
 ```js
-Navigation.push(this.props.containerId, {
-  name: 'navigation.playground.PushedScreen',
-  passProps: {}
+Navigation.push(this.props.componentId, {
+  component: {
+    name: 'navigation.playground.PushedScreen',
+    passProps: {}
+  }
 });
 ```
-### pop(containerId)
+### pop(componentId)
 Pop the top screen from this screen's navigation stack.
 
 ```js
-Navigation.pop(this.props.containerId);
+Navigation.pop(this.props.componentId);
 ```
-### popTo(containerId)
+### popTo(componentId)
 ```js
 Navigation.popTo(previousScreenId);
 ```
 Pop all the screens until the root from this screen's navigation stack
 
 ```js
-Navigation.popToRoot(this.props.containerId);
+Navigation.popToRoot(this.props.componentId);
 ```
 ### showModal(params = {})
 Show a screen as a modal.
 
 ```js
 Navigation.showModal({
-  container: {
+  component: {
     name: 'navigation.playground.ModalScreen',
     passProps: {
         key: 'value'
   }
 });
 ```
-### dismissModal(containerId)
+### dismissModal(componentId)
 Dismiss modal.
 
 ```js
-Navigation.dismissModal(this.props.containerId);
+Navigation.dismissModal(this.props.componentId);
 ```
 ### dismissAllModals()
 Dismiss all the current modals at the same time.

docs/docs/v1tov2diff.md

 There are ways to solve some of these problems in v1 but they are not straightforward. We want to change that.
 
 #### New API
-To solve this problem in v2, every screen receives as a prop it’s containerId. Whenever you want to perform an action from that screen you need to pass the containerId to the function:
+To solve this problem in v2, every screen receives as a prop it’s componentId. Whenever you want to perform an action from that screen you need to pass the componentId to the function:
 ```js
-Navigator.pop(this.props.containerId)
+Navigator.pop(this.props.componentId)
 ```
 ### Built for Contributors
 Currently, it requires a lot of work to accept pull requests. We need to manually make sure that everything works before we approve them because v1 is not thoroughly tested. <br>
 ```js
 Navigation.events().onAppLaunched(() => {
     Navigation.setRoot({
-      container: {
+      component: {
         name: 'navigation.playground.WelcomeScreen'
       }
     });
   });
 ```
 
-#### registerContainer(screenID, generator)
+#### registerComponent(screenID, generator)
 Every screen component in your app must be registered with a unique name. The component itself is a traditional React component extending React.Component.
 
 ```js
-Navigation.registerContainer(`navigation.playground.WelcomeScreen`, () => WelcomeScreen);
+Navigation.registerComponent(`navigation.playground.WelcomeScreen`, () => WelcomeScreen);
 ```
 
 #### setRoot({params})
 
 ```js
 Navigation.setRoot({
-      container: {
+      component: {
         name: 'navigation.playground.WelcomeScreen'
       },
       sideMenu: {
         left: {
-          container: {
+          component: {
             name: 'navigation.playground.TextScreen',
             passProps: {
               text: 'This is a left side menu screen'
           }
         },
         right: {
-          container: {
+          component: {
             name: 'navigation.playground.TextScreen',
             passProps: {
               text: 'This is a right side menu screen'
 Navigation.setRoot({
       tabs: [
         {
-          container: {
+          component: {
             name: 'navigation.playground.TextScreen',
             passProps: {
               text: 'This is tab 1',
           }
         },
         {
-          container: {
+          component: {
             name: 'navigation.playground.TextScreen',
             passProps: {
               text: 'This is tab 2'
 Push a new screen into this screen's navigation stack.
 
 ```js
-Navigation.push(this.props.containerId, {
+Navigation.push(this.props.componentId, {
       name: 'navigation.playground.PushedScreen',
       passProps: {}
     });
 ```
-#### pop(containerId)
+#### pop(componentId)
 Pop the top screen from this screen's navigation stack.
 
 ```js
-Navigation.pop(this.props.containerId);
+Navigation.pop(this.props.componentId);
 ```
 #### popTo(params)
 
 ```js
-Navigation.popTo(this.props.containerId, this.props.previousScreenIds[0]);
+Navigation.popTo(this.props.componentId, this.props.previousScreenIds[0]);
 ```
 #### popToRoot()
 Pop all the screens until the root from this screen's navigation stack
 
 ```js
-Navigation.popToRoot(this.props.containerId);
+Navigation.popToRoot(this.props.componentId);
 ```
 #### showModal(params = {})
 Show a screen as a modal.
 
 ```js
 Navigation.showModal({
-      container: {
+      component: {
         name: 'navigation.playground.ModalScreen',
         passProps: {
             key: 'value'
       }
     });
 ```
-#### dismissModal(containerId)
+#### dismissModal(componentId)
 Dismiss modal.
 
 ```js
-Navigation.dismissModal(this.props.containerId);
+Navigation.dismissModal(this.props.componentId);
 ```
 #### dismissAllModals()
 Dismiss all the current modals at the same time.

e2e/CustomTransition.js

 
 const Utils = require('./Utils');
+const testIDs = require('../playground/src/testIDs');
 
-const elementByLabel = Utils.elementByLabel;
+const elementById = Utils.elementById;
 
 describe('custom transition', () => {
   beforeEach(async () => {
   });
 
   it('sanity', async () => {
-    await elementByLabel('Push Options Screen').tap();
-    await elementByLabel('Custom Transition').tap();
+    await elementById(testIDs.PUSH_OPTIONS_BUTTON).tap();
+    await elementById(testIDs.CUSTOM_TRANSITION_BUTTON).tap();
     await expect(element(by.id('shared_image1'))).toExist();
     await element(by.id('shared_image1')).tap();
     await expect(element(by.id('shared_image2'))).toExist();

e2e/Orientations.test.js

 
 const { elementById } = Utils;
 
-describe('orientation', () => {
+describe(':ios: orientation', () => {
   beforeEach(async () => {
     await device.relaunchApp();
   });
 
-  afterEach(async () => {
-    await device.setOrientation('landscape');
-    await device.setOrientation('portrait');
-  });
-
   it('default allows all', async () => {
     await elementById(testIDs.ORIENTATION_BUTTON).tap();
     await elementById(testIDs.DEFAULT_ORIENTATION_BUTTON).tap();
-    await expect(element(by.id('currentOrientation'))).toHaveText('Portrait');
+    await expect(elementById(testIDs.PORTRAIT_ELEMENT)).toBeVisible();
     await device.setOrientation('landscape');
-    await expect(element(by.id('currentOrientation'))).toHaveText('Landscape');
+    await expect(elementById(testIDs.LANDSCAPE_ELEMENT)).toBeVisible();
     await device.setOrientation('portrait');
-    await expect(element(by.id('currentOrientation'))).toHaveText('Portrait');
+    await expect(elementById(testIDs.PORTRAIT_ELEMENT)).toBeVisible();
     await elementById(testIDs.DISMISS_BUTTON).tap();
   });
 
   it('landscape and portrait array', async () => {
     await elementById(testIDs.ORIENTATION_BUTTON).tap();
     await elementById(testIDs.LANDSCAPE_PORTRAIT_ORIENTATION_BUTTON).tap();
-    await expect(element(by.id('currentOrientation'))).toHaveText('Portrait');
+    await expect(element(by.id(testIDs.PORTRAIT_ELEMENT))).toBeVisible();
     await device.setOrientation('landscape');
-    await expect(element(by.id('currentOrientation'))).toHaveText('Landscape');
+    await expect(element(by.id(testIDs.LANDSCAPE_ELEMENT))).toBeVisible();
     await device.setOrientation('portrait');
-    await expect(element(by.id('currentOrientation'))).toHaveText('Portrait');
+    await expect(element(by.id(testIDs.PORTRAIT_ELEMENT))).toBeVisible();
     await elementById(testIDs.DISMISS_BUTTON).tap();
   });
 
   it('portrait only', async () => {
     await elementById(testIDs.ORIENTATION_BUTTON).tap();
     await elementById(testIDs.PORTRAIT_ORIENTATION_BUTTON).tap();
-    await expect(element(by.id('currentOrientation'))).toHaveText('Portrait');
+    await expect(elementById(testIDs.PORTRAIT_ELEMENT)).toBeVisible();
     await device.setOrientation('landscape');
-    await expect(element(by.id('currentOrientation'))).toHaveText('Portrait');
+    await expect(elementById(testIDs.PORTRAIT_ELEMENT)).toBeVisible();
     await device.setOrientation('portrait');
-    await expect(element(by.id('currentOrientation'))).toHaveText('Portrait');
+    await expect(elementById(testIDs.PORTRAIT_ELEMENT)).toBeVisible();
     await elementById(testIDs.DISMISS_BUTTON).tap();
   });
 
     await elementById(testIDs.ORIENTATION_BUTTON).tap();
     await elementById(testIDs.LANDSCAPE_ORIENTATION_BUTTON).tap();
     await device.setOrientation('landscape');
-    await expect(element(by.id('currentOrientation'))).toHaveText('Landscape');
+    await expect(element(by.id(testIDs.LANDSCAPE_ELEMENT))).toBeVisible();
     await device.setOrientation('portrait');
-    await expect(element(by.id('currentOrientation'))).toHaveText('Landscape');
+    await expect(element(by.id(testIDs.LANDSCAPE_ELEMENT))).toBeVisible();
     await elementById(testIDs.DISMISS_BUTTON).tap();
   });
 });

e2e/ScreenStack.test.js

     await elementById(testIDs.SHOW_MODAL_BUTTON).tap();
     await elementById(testIDs.MODAL_WITH_STACK_BUTTON).tap();
     await expect(elementByLabel('Screen 2')).toBeVisible();
-    await Utils.tapBackIos();
+    await elementById(testIDs.POP_BUTTON).tap();
     await expect(elementByLabel('Screen 1')).toBeVisible();
   });
+
+  it(':ios: push native component with options', async () => {
+    await elementById(testIDs.PUSH_NATIVE_COMPONENT_BUTTON).tap();
+    await expect(elementById('TestLabel')).toBeVisible();
+    await expect(elementById(testIDs.TOP_BAR_ELEMENT)).toBeVisible();
+  });
 });

e2e/ScreenStyle.test.js

 
   it('declare a options on component component', async () => {
     await elementById(testIDs.PUSH_OPTIONS_BUTTON).tap();
-    await expect(element(by.label('Static Title'))).toBeVisible();
+    await expect(elementByLabel('Static Title')).toBeVisible();
   });
 
   it('change title on component component', async () => {
     await elementById(testIDs.PUSH_OPTIONS_BUTTON).tap();
-    await expect(element(by.label('Static Title'))).toBeVisible();
+    await expect(elementByLabel('Static Title')).toBeVisible();
     await elementById(testIDs.DYNAMIC_OPTIONS_BUTTON).tap();
-    await expect(element(by.label('Dynamic Title'))).toBeVisible();
+    await expect(elementByLabel('Dynamic Title')).toBeVisible();
   });
 
   it('set dynamic options with valid options will do something and not crash', async () => {
     await expect(elementById(testIDs.TOP_BAR_ELEMENT)).toBeVisible();
   });
 
-  it('hides topBar onScroll down and shows it on scroll up', async () => {
+  it(':ios: hides topBar onScroll down and shows it on scroll up', async () => {
     await elementById(testIDs.PUSH_OPTIONS_BUTTON).tap();
     await elementById(testIDs.SCROLLVIEW_SCREEN_BUTTON).tap();
     await elementById(testIDs.TOGGLE_TOP_BAR_HIDE_ON_SCROLL).tap();
     await expect(elementById(testIDs.TOP_BAR_ELEMENT)).toBeVisible();
-    await element(by.id(testIDs.SCROLLVIEW_ELEMENT)).swipe('up', 'fast');
+    await element(by.id(testIDs.SCROLLVIEW_ELEMENT)).swipe('up', 'slow');
     await expect(elementById(testIDs.TOP_BAR_ELEMENT)).toBeNotVisible();
-    await element(by.id(testIDs.SCROLLVIEW_ELEMENT)).swipe('down', 'fast');
+    await element(by.id(testIDs.SCROLLVIEW_ELEMENT)).swipe('down', 'slow');
     await expect(elementById(testIDs.TOP_BAR_ELEMENT)).toBeVisible();
   });
 
-  it('makes topBar transparent and opaque', async () => {
-    await elementByLabel('Push Options Screen').tap();
-    await elementByLabel('Top Bar Transparent').tap();
-    await expect(element(by.type('_UIVisualEffectBackdropView'))).toBeNotVisible();
-    await elementByLabel('Top Bar Opaque').tap();
-    await expect(element(by.type('_UIVisualEffectBackdropView')).atIndex(1)).toBeVisible();
-  });
-
   it('set Tab Bar badge on a current Tab', async () => {
     await elementById(testIDs.TAB_BASED_APP_BUTTON).tap();
     await elementById(testIDs.SET_TAB_BADGE_BUTTON).tap();
     await expect(element(by.text('TeSt'))).toBeVisible();
   });
 
-  it('hide Tab Bar', async () => {
+  it(':ios: hide Tab Bar', async () => {
     await elementById(testIDs.TAB_BASED_APP_BUTTON).tap();
     await expect(elementById(testIDs.BOTTOM_TABS_ELEMENT)).toBeVisible();
     await elementById(testIDs.HIDE_BOTTOM_TABS_BUTTON).tap();
     await expect(elementById(testIDs.BOTTOM_TABS_ELEMENT)).toBeNotVisible();
   });
 
-  it('show Tab Bar', async () => {
+  it(':ios: show Tab Bar', async () => {
     await elementById(testIDs.TAB_BASED_APP_BUTTON).tap();
     await elementById(testIDs.HIDE_BOTTOM_TABS_BUTTON).tap();
     await expect(elementById(testIDs.BOTTOM_TABS_ELEMENT)).toBeNotVisible();
     await expect(elementById(testIDs.CENTERED_TEXT_HEADER)).toBeVisible();
   });
 
-  it('set right buttons', async () => {
+  it(':ios: set right buttons', async () => {
     await elementById(testIDs.PUSH_OPTIONS_BUTTON).tap();
     await expect(elementById('buttonOne')).toBeVisible();
     await elementById('buttonOne').tap();
     await elementById(testIDs.POP_BUTTON).tap();
     await expect(elementById(testIDs.TOP_BAR_ELEMENT)).toBeVisible();
   });
+
+  it('supports user-provided id', async () => {
+    await elementById(testIDs.PROVIDED_ID).tap();
+    await expect(elementByLabel('User provided id')).toBeVisible();
+  });
+
+  it('stack options should not override component options', async () => {
+    await elementById(testIDs.TAB_BASED_APP_BUTTON).tap();
+    await expect(elementById(testIDs.TOP_BAR_ELEMENT)).toBeNotVisible();
+    await elementById(testIDs.SECOND_TAB_BAR_BUTTON).tap();
+    await expect(elementById(testIDs.TOP_BAR_ELEMENT)).toBeVisible();
+  });
 });

e2e/TopLevelApi.test.js

     await expect(elementByLabel('Hello from a function!')).toBeVisible();
   });
 
-  it('switch to tabs with side menus', async () => {
+  it(':ios: switch to tabs with side menus', async () => {
     await elementById(testIDs.TAB_BASED_APP_SIDE_BUTTON).tap();
     await elementById(testIDs.CENTERED_TEXT_HEADER).swipe('right');
     await expect(elementById(testIDs.HIDE_LEFT_SIDE_MENU_BUTTON)).toBeVisible();
     await elementById(testIDs.PUSH_LIFECYCLE_BUTTON).tap();
     await expect(elementByLabel('didAppear')).toBeVisible();
     await elementById(testIDs.PUSH_TO_TEST_DID_DISAPPEAR_BUTTON).tap();
-    await expect(elementByLabel('Alert')).toBeVisible();
     await expect(elementByLabel('didDisappear')).toBeVisible();
   });
 
   it('unmount is called on pop', async () => {
     await elementById(testIDs.PUSH_LIFECYCLE_BUTTON).tap();
     await expect(elementByLabel('didAppear')).toBeVisible();
-    await Utils.tapBackIos();
+    await elementById(testIDs.POP_BUTTON).tap();
     await expect(elementByLabel('componentWillUnmount')).toBeVisible();
-    await element(by.traits(['button']).and(by.label('OK'))).atIndex(0).tap();
+    await elementByLabel('OK').atIndex(0).tap();
     await expect(elementByLabel('didDisappear')).toBeVisible();
   });
 });

lib/android/app/build.gradle

     implementation fileTree(include: ['*.jar'], dir: 'libs')
     implementation 'com.android.support:design:25.4.0'
     implementation 'com.android.support:appcompat-v7:25.4.0'
-    implementation "com.android.support:support-v4:25.4.0"
+    implementation 'com.android.support:support-v4:25.4.0'
+    implementation 'com.aurelhubert:ahbottomnavigation:2.1.0'
+    implementation 'com.github.clans:fab:1.6.4'
+
 
     // node_modules
     //noinspection GradleDynamicVersion

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

+package com.reactnativenavigation.anim;
+
+
+public interface AnimationListener {
+    void onAnimationEnd();
+}

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

+package com.reactnativenavigation.anim;
+
+
+public interface FabAnimator {
+    void show();
+
+    void hide();
+}

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

+package com.reactnativenavigation.anim;
+
+
+import android.support.annotation.NonNull;
+
+import com.reactnativenavigation.interfaces.ScrollEventListener;
+
+public class FabCollapseBehaviour implements ScrollEventListener.OnScrollListener, ScrollEventListener.OnDragListener {
+
+    private FabAnimator fabAnimator;
+    private ScrollEventListener scrollEventListener;
+
+    public FabCollapseBehaviour(FabAnimator fabAnimator) {
+        this.fabAnimator = fabAnimator;
+    }
+
+    public void enableCollapse(@NonNull ScrollEventListener scrollEventListener) {
+        this.scrollEventListener = scrollEventListener;
+        this.scrollEventListener.register(null, this, this);
+    }
+
+    public void disableCollapse() {
+        if (scrollEventListener != null) {
+            scrollEventListener.unregister();
+        }
+    }
+
+    @Override
+    public void onScrollUp(float nextTranslation) {
+        //empty
+    }
+
+    @Override
+    public void onScrollDown(float nextTranslation) {
+        //empty
+    }
+
+    @Override
+    public void onShow() {
+        fabAnimator.show();
+    }
+
+    @Override
+    public void onHide() {
+        fabAnimator.hide();
+    }
+}

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

 import android.animation.AnimatorSet;
 import android.animation.ObjectAnimator;
 import android.content.Context;
+import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
 import android.view.View;
 import android.view.animation.AccelerateInterpolator;
 import android.view.animation.DecelerateInterpolator;
 
+import com.reactnativenavigation.parse.AnimationsOptions;
 import com.reactnativenavigation.utils.UiUtils;
 
 @SuppressWarnings("ResourceType")
 public class NavigationAnimator {
 
-    public interface NavigationAnimationListener {
-        void onAnimationEnd();
-    }
+    private AnimationsOptions options = new AnimationsOptions();
 
     private static final int DURATION = 300;
     private static final DecelerateInterpolator DECELERATE_INTERPOLATOR = new DecelerateInterpolator();
         translationY = UiUtils.getWindowHeight(context);
     }
 
-    public void animatePush(final View view, @Nullable final NavigationAnimationListener animationListener) {
+    public void animatePush(final View view, @Nullable final AnimationListener animationListener) {
         view.setVisibility(View.INVISIBLE);
-        ObjectAnimator alpha = ObjectAnimator.ofFloat(view, View.ALPHA, 0, 1);
-        alpha.setInterpolator(DECELERATE_INTERPOLATOR);
-
-        AnimatorSet set = new AnimatorSet();
+        AnimatorSet set;
+        if (options.push.hasValue()) {
+            set = options.push.getAnimation(view);
+        } else {
+            set = getDefaultPushAnimation(view);
+        }
         set.addListener(new AnimatorListenerAdapter() {
             @Override
             public void onAnimationStart(Animator animation) {
                 }
             }
         });
+        set.start();
+    }
+
+    @NonNull
+    private AnimatorSet getDefaultPushAnimation(View view) {
+        ObjectAnimator alpha = ObjectAnimator.ofFloat(view, View.ALPHA, 0, 1);
+        alpha.setInterpolator(DECELERATE_INTERPOLATOR);
+
+        AnimatorSet set = new AnimatorSet();
         ObjectAnimator translationY = ObjectAnimator.ofFloat(view, View.TRANSLATION_Y, this.translationY, 0);
         translationY.setInterpolator(DECELERATE_INTERPOLATOR);
         translationY.setDuration(DURATION);
         alpha.setDuration(DURATION);
         set.playTogether(translationY, alpha);
-        set.start();
+        return set;
     }
 
-    public void animatePop(View view, @Nullable final NavigationAnimationListener animationListener) {
-        ObjectAnimator alpha = ObjectAnimator.ofFloat(view, View.ALPHA, 1, 0);
-        alpha.setInterpolator(ACCELERATE_INTERPOLATOR);
-
-        AnimatorSet set = new AnimatorSet();
+    public void animatePop(View view, @Nullable final AnimationListener animationListener) {
+        AnimatorSet set;
+        if (options.pop.hasValue()) {
+            set = options.pop.getAnimation(view);
+        } else {
+            set = getDefaultPopAnimation(view);
+        }
         set.addListener(new AnimatorListenerAdapter() {
             @Override
             public void onAnimationEnd(Animator animation) {
                 }
             }
         });
+        set.start();
+    }
+
+    @NonNull
+    private AnimatorSet getDefaultPopAnimation(View view) {
+        AnimatorSet set = new AnimatorSet();
+
+        ObjectAnimator alpha = ObjectAnimator.ofFloat(view, View.ALPHA, 1, 0);
+        alpha.setInterpolator(ACCELERATE_INTERPOLATOR);
+
         ObjectAnimator translationY = ObjectAnimator.ofFloat(view, View.TRANSLATION_Y, 0, this.translationY);
         translationY.setInterpolator(ACCELERATE_INTERPOLATOR);
         translationY.setDuration(DURATION);
         alpha.setDuration(DURATION);
         set.playTogether(translationY, alpha);
-        set.start();
+        return set;
+    }
+
+    public void setOptions(AnimationsOptions options) {
+        this.options = options;
     }
 }

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

 
     private TopBar topBar;
     private View contentView;
+    private ObjectAnimator hideAnimator;
+    private ObjectAnimator showAnimator;
 
     public TopBarAnimator(TopBar topBar) {
         this.topBar = topBar;
     }
 
-    public TopBarAnimator(TopBar topBar, View contentView) {
-        this.topBar = topBar;
-        this.contentView = contentView;
-    }
-
     public void show() {
         show(-1 * topBar.getMeasuredHeight(), decelerateInterpolator, DURATION_TOPBAR);
     }
 
     public void show(float startTranslation, TimeInterpolator interpolator, int duration) {
-        ObjectAnimator topbarAnim = ObjectAnimator.ofFloat(topBar, View.TRANSLATION_Y, startTranslation, 0);
-        topbarAnim.setInterpolator(interpolator);
-        topbarAnim.setDuration(duration);
+        showAnimator = ObjectAnimator.ofFloat(topBar, View.TRANSLATION_Y, startTranslation, 0);
+        showAnimator.setInterpolator(interpolator);
+        showAnimator.setDuration(duration);
 
-        topbarAnim.addListener(new AnimatorListenerAdapter() {
+        showAnimator.addListener(new AnimatorListenerAdapter() {
 
             @Override
             public void onAnimationStart(Animator animation) {
                 }
             }
         });
-        topbarAnim.start();
+        showAnimator.start();
     }
 
     public void hide() {
     }
 
     void hide(float startTranslation, TimeInterpolator interpolator, int duration) {
-        ObjectAnimator animator = ObjectAnimator.ofFloat(topBar, View.TRANSLATION_Y, startTranslation, -1 * topBar.getMeasuredHeight());
-        animator.setInterpolator(interpolator);
-        animator.setDuration(duration);
+        hideAnimator = ObjectAnimator.ofFloat(topBar, View.TRANSLATION_Y, startTranslation, -1 * topBar.getMeasuredHeight());
+        hideAnimator.setInterpolator(interpolator);
+        hideAnimator.setDuration(duration);
 
-        animator.addListener(new AnimatorListenerAdapter() {
+        hideAnimator.addListener(new AnimatorListenerAdapter() {
             @Override
             public void onAnimationEnd(Animator animation) {
                 if (contentView != null) {
                 topBar.setVisibility(View.GONE);
             }
         });
-        animator.start();
+        hideAnimator.start();
+    }
+
+    public boolean isRunning() {
+        return (hideAnimator != null && hideAnimator.isRunning()) || (showAnimator != null && showAnimator.isRunning());
     }
 }

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

 
 public class ViewAnimationSetBuilder implements Animation.AnimationListener {
 
-	private Runnable onComplete;
-	private List<View> views = new ArrayList<>();
-	private List<Animation> pendingAnimations = new ArrayList<>();
-	private boolean started = false;
-
-	public ViewAnimationSetBuilder withEndListener(Runnable onComplete) {
-		this.onComplete = onComplete;
-		return this;
-	}
-
-	public ViewAnimationSetBuilder add(View view, Animation animation) {
-		views.add(view);
-		pendingAnimations.add(animation);
-		animation.setAnimationListener(this);
-		view.setAnimation(animation);
-		return this;
-	}
-
-	public void start() {
-		for (Animation animation : pendingAnimations) {
-			animation.start();
-		}
-		started = true;
-		if (pendingAnimations.isEmpty()) finish();
-	}
-
-	@Override
-	public void onAnimationStart(final Animation animation) {
-		// nothing
-	}
-
-	@Override
-	public void onAnimationEnd(final Animation animation) {
-		pendingAnimations.remove(animation);
-		if (started && pendingAnimations.isEmpty()) finish();
-	}
-
-	@Override
-	public void onAnimationRepeat(final Animation animation) {
-		// nothing
-	}
-
-	private void finish() {
-		for (View view : views) {
-			view.clearAnimation();
-		}
-		views.clear();
-		if (onComplete != null) onComplete.run();
-	}
+    private Runnable onComplete;
+    private List<View> views = new ArrayList<>();
+    private List<Animation> pendingAnimations = new ArrayList<>();
+    private boolean started = false;
+
+    public ViewAnimationSetBuilder withEndListener(Runnable onComplete) {
+        this.onComplete = onComplete;
+        return this;
+    }
+
+    public ViewAnimationSetBuilder add(View view, Animation animation) {
+        views.add(view);
+        pendingAnimations.add(animation);
+        animation.setAnimationListener(this);
+        view.setAnimation(animation);
+        return this;
+    }
+
+    public void start() {
+        for (Animation animation : pendingAnimations) {
+            animation.start();
+        }
+        started = true;
+        if (pendingAnimations.isEmpty()) finish();
+    }
+
+    @Override
+    public void onAnimationStart(final Animation animation) {
+        // nothing
+    }
+
+    @Override
+    public void onAnimationEnd(final Animation animation) {
+        pendingAnimations.remove(animation);
+        if (started && pendingAnimations.isEmpty()) finish();
+    }
+
+    @Override
+    public void onAnimationRepeat(final Animation animation) {
+        // nothing
+    }
+
+    private void finish() {
+        for (View view : views) {
+            view.clearAnimation();
+        }
+        views.clear();
+        if (onComplete != null) onComplete.run();
+    }
 }

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

     private void onVerticalScroll(int scrollY, int oldScrollY) {
         if (scrollY < 0) return;
         if (!dragStarted) return;
+        if (view == null) return;
 
         final int scrollDiff = calcScrollDiff(scrollY, oldScrollY, view.getMeasuredHeight());
         final float translationY = view.getTranslationY() - scrollDiff;

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

+package com.reactnativenavigation.parse;
+
+
+import android.animation.Animator;
+import android.animation.AnimatorSet;
+import android.util.Property;
+import android.view.View;
+
+import org.json.JSONObject;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+
+public class AnimationOptions {
+
+    public static AnimationOptions parse(JSONObject json) {
+        AnimationOptions options = new AnimationOptions();
+        if (json == null) return options;
+
+        options.hasValue = true;
+        for (Iterator<String> it = json.keys(); it.hasNext(); ) {
+            String key = it.next();
+            options.valueOptions.add(ValueAnimationOptions.parse(json.optJSONObject(key), getAnimProp(key)));
+        }
+
+        return options;
+    }
+
+    private boolean hasValue = false;
+
+    private HashSet<ValueAnimationOptions> valueOptions = new HashSet<>();
+
+    void mergeWith(AnimationOptions other) {
+        if (other.hasValue()) {
+            hasValue = true;
+            valueOptions = other.valueOptions;
+        }
+    }
+
+    void mergeWithDefault(AnimationOptions defaultOptions) {
+        if (defaultOptions.hasValue()) {
+            hasValue = true;
+            valueOptions = defaultOptions.valueOptions;
+        }
+    }
+
+    public boolean hasValue() {
+        return hasValue;
+    }
+
+    public AnimatorSet getAnimation(View view) {
+        AnimatorSet animationSet = new AnimatorSet();
+        List<Animator> animators = new ArrayList<>();
+        for (ValueAnimationOptions options: valueOptions) {
+            animators.add(options.getAnimation(view));
+        }
+        animationSet.playTogether(animators);
+        return animationSet;
+    }
+
+    private static Property<View, Float> getAnimProp(String key) {
+        switch (key) {
+            case "y":
+                return View.TRANSLATION_Y;
+            case "x":
+                return View.TRANSLATION_X;
+            case "alpha":
+                return View.ALPHA;
+            case "scaleY":
+                return View.SCALE_Y;
+            case "scaleX":
+                return View.SCALE_X;
+            case "rotationX":
+                return View.ROTATION_X;
+            case "rotationY":
+                return View.ROTATION_Y;
+            case "rotation":
+                return View.ROTATION;
+        }
+        throw new IllegalArgumentException("This animation is not supported: " + key);
+    }
+}

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

+package com.reactnativenavigation.parse;
+
+
+import org.json.JSONObject;
+
+public class AnimationsOptions {
+
+    public static AnimationsOptions parse(JSONObject json) {
+        AnimationsOptions options = new AnimationsOptions();
+        if (json == null) return options;
+
+        options.push = AnimationOptions.parse(json.optJSONObject("push"));
+        options.pop = AnimationOptions.parse(json.optJSONObject("pop"));
+        options.startApp = AnimationOptions.parse(json.optJSONObject("startApp"));
+        options.showModal = AnimationOptions.parse(json.optJSONObject("showModal"));
+        options.dismissModal = AnimationOptions.parse(json.optJSONObject("dismissModal"));
+
+        return options;
+    }
+
+    public AnimationOptions push = new AnimationOptions();
+    public AnimationOptions pop = new AnimationOptions();
+    public AnimationOptions startApp = new AnimationOptions();
+    public AnimationOptions showModal = new AnimationOptions();
+    public AnimationOptions dismissModal = new AnimationOptions();
+
+    void mergeWith(AnimationsOptions other) {
+        push.mergeWith(other.push);
+        pop.mergeWith(other.pop);
+        startApp.mergeWith(other.startApp);
+        showModal.mergeWith(other.showModal);
+        dismissModal.mergeWith(other.dismissModal);
+
+    }
+
+    void mergeWithDefault(AnimationsOptions defaultOptions) {
+        push.mergeWithDefault(defaultOptions.push);
+        pop.mergeWithDefault(defaultOptions.pop);
+        startApp.mergeWithDefault(defaultOptions.startApp);
+        showModal.mergeWithDefault(defaultOptions.showModal);
+        dismissModal.mergeWithDefault(defaultOptions.dismissModal);
+    }
+}

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

+package com.reactnativenavigation.parse;
+
+import com.reactnativenavigation.parse.params.NullText;
+import com.reactnativenavigation.parse.params.Text;
+import com.reactnativenavigation.parse.parsers.TextParser;
+
+import org.json.JSONObject;
+
+public class BottomTabOptions implements DEFAULT_VALUES {
+
+    public static BottomTabOptions parse(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.badge = TextParser.parse(json, "badge");
+        options.testId = TextParser.parse(json, "testID");
+        return options;
+    }
+
+    public Text title = new NullText();
+    public Text icon = new NullText();
+    public Text testId = new NullText();
+    public Text badge = new NullText();
+
+    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;
+        }
+    }
+
+    void mergeWithDefault(final BottomTabOptions defaultOptions) {
+        if (!title.hasValue()) {
+            title = defaultOptions.title;
+        }
+        if (!icon.hasValue()) {
+            icon = defaultOptions.icon;
+        }
+        if (!badge.hasValue()) {
+            badge = defaultOptions.badge;
+        }
+    }
+}

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

 package com.reactnativenavigation.parse;
 
-
-import com.reactnativenavigation.parse.Options.BooleanOptions;
+import com.reactnativenavigation.parse.params.Bool;
+import com.reactnativenavigation.parse.params.Color;
+import com.reactnativenavigation.parse.params.NullBool;
+import com.reactnativenavigation.parse.params.NullColor;
+import com.reactnativenavigation.parse.params.NullNumber;
+import com.reactnativenavigation.parse.params.NullText;
+import com.reactnativenavigation.parse.params.Number;
+import com.reactnativenavigation.parse.params.Text;
+import com.reactnativenavigation.parse.parsers.BoolParser;
+import com.reactnativenavigation.parse.parsers.ColorParser;
+import com.reactnativenavigation.parse.parsers.NumberParser;
+import com.reactnativenavigation.parse.parsers.TextParser;
 
 import org.json.JSONObject;
 
 		BottomTabsOptions options = new BottomTabsOptions();
 		if (json == null) return options;
 
-		options.currentTabId = TextParser.parse(json, "currentTabId");
-		options.currentTabIndex = json.optInt("currentTabIndex", NO_INT_VALUE);
-		options.tabBadge = json.optInt("tabBadge", NO_INT_VALUE);
-		options.hidden = BooleanOptions.parse(json.optString("hidden"));
-		options.animateHide = BooleanOptions.parse(json.optString("animateHide"));
+        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");
+		options.animate = BoolParser.parse(json,"animate");
+        options.testId = TextParser.parse(json, "testID");
 
 		return options;
 	}
 
-	int tabBadge = NO_INT_VALUE;
-	BooleanOptions hidden = BooleanOptions.False;
-	BooleanOptions animateHide = BooleanOptions.False;
-	public int currentTabIndex = NO_INT_VALUE;
+    public Color backgroundColor = new NullColor();
+    public Color tabColor = new NullColor();
+    public Color selectedTabColor = new NullColor();
+	public Bool visible = new NullBool();
+	public Bool animate = new NullBool();
+	public Number currentTabIndex = new NullNumber();
 	public Text currentTabId = new NullText();
+    public Text testId = new NullText();
 
 	void mergeWith(final BottomTabsOptions other) {
 		if (other.currentTabId.hasValue()) {
 			currentTabId = other.currentTabId;
 		}
-		if (NO_INT_VALUE != other.currentTabIndex) {
+		if (other.currentTabIndex.hasValue()) {
             currentTabIndex = other.currentTabIndex;
 		}
-		if (NO_INT_VALUE != other.tabBadge) {
-			tabBadge = other.tabBadge;
-		}
-		if (other.hidden != BooleanOptions.NoValue) {
-			hidden = other.hidden;
+		if (other.visible.hasValue()) {
+			visible = other.visible;
 		}
-		if (other.animateHide != BooleanOptions.NoValue) {
-			animateHide = other.animateHide;
+		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;
+        }
+    }
 
     void mergeWithDefault(final BottomTabsOptions defaultOptions) {
         if (!currentTabId.hasValue()) {
             currentTabId = defaultOptions.currentTabId;
         }
-        if (NO_INT_VALUE == currentTabIndex) {
+        if (!currentTabIndex.hasValue()) {
             currentTabIndex = defaultOptions.currentTabIndex;
         }
-        if (NO_INT_VALUE == tabBadge) {
-            tabBadge = defaultOptions.tabBadge;
+        if (!visible.hasValue()) {
+            visible = defaultOptions.visible;
+        }
+        if (!animate.hasValue()) {
+            animate = defaultOptions.animate;
+        }
+        if (!tabColor.hasValue()) {
+            tabColor = defaultOptions.tabColor;
         }
-        if (hidden == BooleanOptions.NoValue) {
-            hidden = defaultOptions.hidden;
+        if (!selectedTabColor.hasValue()) {
+            selectedTabColor = defaultOptions.selectedTabColor;
         }
-        if (animateHide == BooleanOptions.NoValue) {
-            animateHide = defaultOptions.animateHide;
+        if (!backgroundColor.hasValue()) {
+            backgroundColor = defaultOptions.backgroundColor;
         }
     }
 }

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

+package com.reactnativenavigation.parse;
+
+
+import com.reactnativenavigation.parse.params.Bool;
+import com.reactnativenavigation.parse.params.Color;
+import com.reactnativenavigation.parse.params.NullBool;
+import com.reactnativenavigation.parse.params.NullColor;
+import com.reactnativenavigation.parse.params.NullText;
+import com.reactnativenavigation.parse.params.Text;
+import com.reactnativenavigation.parse.parsers.BoolParser;
+import com.reactnativenavigation.parse.parsers.ColorParser;
+import com.reactnativenavigation.parse.parsers.TextParser;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+import java.util.ArrayList;
+
+public class FabOptions implements DEFAULT_VALUES {
+
+    public static FabOptions parse(JSONObject json) {
+        FabOptions options = new FabOptions();
+        if (json == null) return options;
+
+        options.id = TextParser.parse(json, "id");
+        options.backgroundColor = ColorParser.parse(json, "backgroundColor");
+        options.clickColor = ColorParser.parse(json, "clickColor");
+        options.rippleColor = ColorParser.parse(json, "rippleColor");
+        options.visible = BoolParser.parse(json, "visible");
+        if (json.has("icon")) {
+            options.icon = TextParser.parse(json.optJSONObject("icon"), "uri");
+        }
+        if (json.has("actions")) {
+            JSONArray fabsArray = json.optJSONArray("actions");
+            for (int i = 0; i < fabsArray.length(); i++) {
+                options.actionsArray.add(FabOptions.parse(fabsArray.optJSONObject(i)));
+            }
+        }
+        options.alignHorizontally = TextParser.parse(json, "alignHorizontally");
+        options.alignVertically = TextParser.parse(json, "alignVertically");
+        options.hideOnScroll = BoolParser.parse(json, "hideOnScroll");
+        options.size = TextParser.parse(json, "size");
+
+        return options;
+    }
+
+    public Text id = new NullText();
+    public Color backgroundColor = new NullColor();
+    public Color clickColor = new NullColor();
+    public Color rippleColor = new NullColor();
+    public Text icon = new NullText();
+    public Bool visible = new NullBool();
+    public ArrayList<FabOptions> actionsArray = new ArrayList<>();
+    public Text alignHorizontally = new NullText();
+    public Text alignVertically = new NullText();
+    public Bool hideOnScroll = new NullBool();
+    public Text size = new NullText();
+
+    void mergeWith(final FabOptions other) {
+        if (other.id.hasValue()) {
+            id = other.id;
+        }
+        if (other.backgroundColor.hasValue()) {
+            backgroundColor = other.backgroundColor;
+        }
+        if (other.clickColor.hasValue()) {
+            clickColor = other.clickColor;
+        }
+        if (other.rippleColor.hasValue()) {
+            rippleColor = other.rippleColor;
+        }
+        if (other.visible.hasValue()) {
+            visible = other.visible;
+        }
+        if (other.icon.hasValue()) {
+            icon = other.icon;
+        }
+        if (other.actionsArray.size() > 0) {
+            actionsArray = other.actionsArray;
+        }
+        if (other.alignVertically.hasValue()) {
+            alignVertically = other.alignVertically;
+        }
+        if (other.alignHorizontally.hasValue()) {
+            alignHorizontally = other.alignHorizontally;
+        }
+        if (other.hideOnScroll.hasValue()) {
+            hideOnScroll = other.hideOnScroll;
+        }
+        if (other.size.hasValue()) {
+            size = other.size;
+        }
+    }
+
+    void mergeWithDefault(FabOptions defaultOptions) {
+        if (!id.hasValue()) {
+            id = defaultOptions.id;
+        }
+        if (!backgroundColor.hasValue()) {
+            backgroundColor = defaultOptions.backgroundColor;
+        }
+        if (!clickColor.hasValue()) {
+            clickColor = defaultOptions.clickColor;
+        }
+        if (!rippleColor.hasValue()) {
+            rippleColor = defaultOptions.rippleColor;
+        }
+        if (!visible.hasValue()) {
+            visible = defaultOptions.visible;
+        }
+        if (!icon.hasValue()) {
+            icon = defaultOptions.icon;
+        }
+        if (actionsArray.size() == 0) {
+            actionsArray = defaultOptions.actionsArray;
+        }
+        if (!alignHorizontally.hasValue()) {
+            alignHorizontally = defaultOptions.alignHorizontally;
+        }
+        if (!alignVertically.hasValue()) {
+            alignVertically = defaultOptions.alignVertically;
+        }
+        if (!hideOnScroll.hasValue()) {
+            hideOnScroll = defaultOptions.hideOnScroll;
+        }
+        if (!size.hasValue()) {
+            size = defaultOptions.size;
+        }
+    }
+}

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

 import android.app.Activity;
 
 import com.facebook.react.ReactInstanceManager;
+import com.reactnativenavigation.utils.ImageLoader;
 import com.reactnativenavigation.utils.NoOpPromise;
 import com.reactnativenavigation.utils.TypefaceLoader;
-import com.reactnativenavigation.viewcontrollers.BottomTabsController;
+import com.reactnativenavigation.viewcontrollers.bottomtabs.BottomTabsController;
 import com.reactnativenavigation.viewcontrollers.ComponentViewController;
 import com.reactnativenavigation.viewcontrollers.SideMenuController;
 import com.reactnativenavigation.viewcontrollers.StackController;
 	}
 
     private ViewController createSideMenuRoot(LayoutNode node) {
-		SideMenuController sideMenuLayout = new SideMenuController(activity, node.id);
+        final Options options = Options.parse(typefaceManager, node.getNavigationOptions(), defaultOptions);
+		SideMenuController sideMenuLayout = new SideMenuController(activity, node.id, options);
 		for (LayoutNode child : node.children) {
 			ViewController childLayout = create(child);
 			switch (child.type) {
 	}
 
 	private ViewController createStack(LayoutNode node) {
-		StackController stackController = new StackController(activity, node.id);
+        final Options options = Options.parse(typefaceManager, node.getNavigationOptions(), defaultOptions);
+		StackController stackController = new StackController(activity, node.id, options);
         for (int i = 0; i < node.children.size(); i++) {
             if (i < node.children.size() - 1) {
                 stackController.push(create(node.children.get(i)), new NoOpPromise());
 	}
 
 	private ViewController createBottomTabs(LayoutNode node) {
-		final BottomTabsController tabsComponent = new BottomTabsController(activity, node.id);
+        final Options options = Options.parse(typefaceManager, node.getNavigationOptions(), defaultOptions);
+		final BottomTabsController tabsComponent = new BottomTabsController(activity, new ImageLoader(), node.id, options);
 		List<ViewController> tabs = new ArrayList<>();
 		for (int i = 0; i < node.children.size(); i++) {
-			tabs.add(create(node.children.get(i)));
+            tabs.add(create(node.children.get(i)));
 		}
 		tabsComponent.setTabs(tabs);
 		return tabsComponent;

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

 		this(id, type, new JSONObject(), new ArrayList<>());
 	}
 
-	LayoutNode(String id, Type type, JSONObject data, List<LayoutNode> children) {
+	public LayoutNode(String id, Type type, JSONObject data, List<LayoutNode> children) {
 		this.id = id;
 		this.type = type;
 		this.data = data;

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

 package com.reactnativenavigation.parse;
 
+import android.support.annotation.CheckResult;
 import android.support.annotation.NonNull;
-import android.text.TextUtils;
 
 import com.reactnativenavigation.utils.TypefaceLoader;
 
 
 public class Options implements DEFAULT_VALUES {
 
-    public enum BooleanOptions {
-		True,
-		False,
-		NoValue;
-
-		static BooleanOptions parse(String value) {
-			if (!TextUtils.isEmpty(value)) {
-				return Boolean.valueOf(value) ? True : False;
-			}
-			return NoValue;
-		}
-	}
-
     @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;
+    @NonNull
+    public static Options parse(TypefaceLoader typefaceManager, JSONObject json, @NonNull Options defaultOptions) {
+        Options result = new Options();
+        if (json == null) return result;
 
-		result.topBarOptions = TopBarOptions.parse(typefaceManager, json.optJSONObject("topBar"));
-		result.topTabsOptions = TopTabsOptions.parse(json.optJSONObject("topTabs"));
+        result.topBarOptions = TopBarOptions.parse(typefaceManager, json.optJSONObject("topBar"));
+        result.topTabsOptions = TopTabsOptions.parse(json.optJSONObject("topTabs"));
         result.topTabOptions = TopTabOptions.parse(typefaceManager, json.optJSONObject("topTab"));
-		result.bottomTabsOptions = BottomTabsOptions.parse(json.optJSONObject("bottomTabs"));
+        result.bottomTabOptions = BottomTabOptions.parse(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.animationsOptions = AnimationsOptions.parse(json.optJSONObject("animations"));
+        result.sideMenuRootOptions = SideMenuRootOptions.parse(json.optJSONObject("sideMenu"));
 
-		return result.withDefaultOptions(defaultOptions);
-	}
+        return result.withDefaultOptions(defaultOptions);
+    }
 
     @NonNull public TopBarOptions topBarOptions = new TopBarOptions();
     @NonNull public TopTabsOptions topTabsOptions = new TopTabsOptions();
     @NonNull public TopTabOptions topTabOptions = new TopTabOptions();
+    @NonNull public BottomTabOptions bottomTabOptions = new BottomTabOptions();
     @NonNull public BottomTabsOptions bottomTabsOptions = new BottomTabsOptions();
     @NonNull public OverlayOptions overlayOptions = new OverlayOptions();
+    @NonNull public FabOptions fabOptions = new FabOptions();
+    @NonNull public AnimationsOptions animationsOptions = new AnimationsOptions();
+    @NonNull public SideMenuRootOptions sideMenuRootOptions = new SideMenuRootOptions();
 
     void setTopTabIndex(int i) {
         topTabOptions.tabIndex = i;
     }
 
-	public void mergeWith(final Options other) {
-        topBarOptions.mergeWith(other.topBarOptions);
-        topTabsOptions.mergeWith(other.topTabsOptions);
-        bottomTabsOptions.mergeWith(other.bottomTabsOptions);
+    @CheckResult
+    public Options copy() {
+        Options result = new Options();
+        result.topBarOptions.mergeWith(topBarOptions);
+        result.topTabsOptions.mergeWith(topTabsOptions);
+        result.topTabOptions.mergeWith(topTabOptions);
+        result.bottomTabOptions.mergeWith(bottomTabOptions);
+        result.bottomTabsOptions.mergeWith(bottomTabsOptions);
+        result.overlayOptions = overlayOptions;
+        result.fabOptions.mergeWith(fabOptions);
+        result.animationsOptions.mergeWith(animationsOptions);
+        result.sideMenuRootOptions.mergeWith(sideMenuRootOptions);
+        return result;
+    }
+
+    @CheckResult
+	public Options mergeWith(final Options other) {
+        Options result = copy();
+        result.topBarOptions.mergeWith(other.topBarOptions);
+        result.topTabsOptions.mergeWith(other.topTabsOptions);
+        result.topTabOptions.mergeWith(other.topTabOptions);
+        result.bottomTabOptions.mergeWith(other.bottomTabOptions);
+        result.bottomTabsOptions.mergeWith(other.bottomTabsOptions);
+        result.fabOptions.mergeWith(other.fabOptions);
+        result.animationsOptions.mergeWith(other.animationsOptions);
+        result.sideMenuRootOptions.mergeWith(other.sideMenuRootOptions);
+        return result;
     }
 
     Options withDefaultOptions(final Options other) {
         topBarOptions.mergeWithDefault(other.topBarOptions);
+        topTabOptions.mergeWithDefault(other.topTabOptions);
         topTabsOptions.mergeWithDefault(other.topTabsOptions);
+        bottomTabOptions.mergeWithDefault(other.bottomTabOptions);
         bottomTabsOptions.mergeWithDefault(other.bottomTabsOptions);
+        fabOptions.mergeWithDefault(other.fabOptions);
+        animationsOptions.mergeWithDefault(other.animationsOptions);
+        sideMenuRootOptions.mergeWithDefault(other.sideMenuRootOptions);
+        return this;
+    }
+
+    public Options clearTopBarOptions() {
+        topBarOptions = new TopBarOptions();
+        return this;
+    }
+
+    public Options clearBottomTabsOptions() {
+        bottomTabsOptions = new BottomTabsOptions();
+        return this;
+    }
+
+    public Options clearTopTabOptions() {
+        topTabOptions = new TopTabOptions();
+        return this;
+    }
+
+    public Options clearTopTabsOptions() {
+        topTabsOptions = new TopTabsOptions();
+        return this;
+    }
+
+    public Options clearBottomTabOptions() {
+        bottomTabOptions = new BottomTabOptions();
+        return this;
+    }
+
+    public Options clearSideMenuOptions() {
+        sideMenuRootOptions = new SideMenuRootOptions();
         return this;
     }
 }

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

 package com.reactnativenavigation.parse;
 
+import com.reactnativenavigation.parse.params.Bool;
+import com.reactnativenavigation.parse.params.NullBool;
+import com.reactnativenavigation.parse.parsers.BoolParser;
+
 import org.json.JSONObject;
 
 public class OverlayOptions {
-    public Options.BooleanOptions interceptTouchOutside = Options.BooleanOptions.False;
+    public Bool interceptTouchOutside = new NullBool();
 
     public static OverlayOptions parse(JSONObject json) {
         OverlayOptions options = new OverlayOptions();
         if (json == null) return options;
 
-        options.interceptTouchOutside = Options.BooleanOptions.parse(json.optString("interceptTouchOutside", ""));
+        options.interceptTouchOutside = BoolParser.parse(json,"interceptTouchOutside");
         return options;
     }
 }

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

+package com.reactnativenavigation.parse;
+
+import com.reactnativenavigation.parse.params.Bool;
+import com.reactnativenavigation.parse.params.NullBool;
+import com.reactnativenavigation.parse.parsers.BoolParser;
+
+import org.json.JSONObject;
+
+public class SideMenuOptions {
+    public Bool visible = new NullBool();
+
+    public static SideMenuOptions parse(JSONObject json) {
+        SideMenuOptions options = new SideMenuOptions();
+        if (json == null) return options;
+
+        options.visible = BoolParser.parse(json, "visible");
+        return options;
+    }
+
+    public void mergeWith(SideMenuOptions other) {
+        if (other.visible.hasValue()) {
+            visible = other.visible;
+        }
+    }
+}

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

+package com.reactnativenavigation.parse;
+
+import org.json.JSONObject;
+
+public class SideMenuRootOptions {
+    public SideMenuOptions left = new SideMenuOptions();
+    public SideMenuOptions right = new SideMenuOptions();
+
+    public static SideMenuRootOptions parse(JSONObject json) {
+        SideMenuRootOptions options = new SideMenuRootOptions();
+        if (json == null) return options;
+
+        options.left = SideMenuOptions.parse(json.optJSONObject("left"));
+        options.right = SideMenuOptions.parse(json.optJSONObject("right"));
+
+        return options;
+    }
+
+    public void mergeWith(SideMenuRootOptions other) {
+        left.mergeWith(other.left);
+        right.mergeWith(other.right);
+    }
+
+    public void mergeWithDefault(SideMenuRootOptions sideMenuRootOptions) {
+
+    }
+}

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

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

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

 import android.graphics.Typeface;
 import android.support.annotation.Nullable;
 
+import com.reactnativenavigation.parse.params.Bool;
+import com.reactnativenavigation.parse.params.Button;
+import com.reactnativenavigation.parse.params.Color;
+import com.reactnativenavigation.parse.params.Fraction;
+import com.reactnativenavigation.parse.params.NullBool;
+import com.reactnativenavigation.parse.params.NullColor;
+import com.reactnativenavigation.parse.params.NullFraction;
+import com.reactnativenavigation.parse.params.NullText;
+import com.reactnativenavigation.parse.params.Text;
+import com.reactnativenavigation.parse.parsers.BoolParser;
+import com.reactnativenavigation.parse.parsers.ColorParser;
+import com.reactnativenavigation.parse.parsers.FractionParser;
+import com.reactnativenavigation.parse.parsers.TextParser;
 import com.reactnativenavigation.utils.TypefaceLoader;
 
 import org.json.JSONObject;
         options.textColor = ColorParser.parse(json, "textColor");
         options.textFontSize = FractionParser.parse(json, "textFontSize");
         options.textFontFamily = typefaceManager.getTypeFace(json.optString("textFontFamily", ""));
-        options.hidden = Options.BooleanOptions.parse(json.optString("hidden"));
-        options.animateHide = Options.BooleanOptions.parse(json.optString("animateHide"));
-        options.hideOnScroll = Options.BooleanOptions.parse(json.optString("hideOnScroll"));
-        options.drawBehind = Options.BooleanOptions.parse(json.optString("drawBehind"));
+        options.visible = BoolParser.parse(json, "visible");
+        options.animate = BoolParser.parse(json,"animate");
+        options.hideOnScroll = BoolParser.parse(json,"hideOnScroll");
+        options.drawBehind = BoolParser.parse(json,"drawBehind");
         options.rightButtons = Button.parseJsonArray(json.optJSONArray("rightButtons"));
         options.leftButtons = Button.parseJsonArray(json.optJSONArray("leftButtons"));
+        options.testId = TextParser.parse(json, "testID");
 
         return options;
     }
 
     public Text title = new NullText();
+    public Text testId = new NullText();
     public Color backgroundColor = new NullColor();
     public Color textColor = new NullColor();
     public Fraction textFontSize = new NullFraction();
     @Nullable public Typeface textFontFamily;
-    public Options.BooleanOptions hidden = Options.BooleanOptions.NoValue;
-    public Options.BooleanOptions animateHide = Options.BooleanOptions.NoValue;
-    public Options.BooleanOptions hideOnScroll = Options.BooleanOptions.NoValue;
-    public Options.BooleanOptions drawBehind = Options.BooleanOptions.NoValue;
+    public Bool visible = new NullBool();
+    public Bool animate = new NullBool();
+    public Bool hideOnScroll = new NullBool();
+    public Bool drawBehind = new NullBool();
     public ArrayList<Button> leftButtons;
     public ArrayList<Button> rightButtons;
 
     void mergeWith(final TopBarOptions other) {
-        if (other.title != null) title = other.title;
+        if (other.title.hasValue())
+            title = other.title;
         if (other.backgroundColor.hasValue())
             backgroundColor = other.backgroundColor;
         if (other.textColor.hasValue())
             textFontSize = other.textFontSize;
         if (other.textFontFamily != null)
             textFontFamily = other.textFontFamily;
-        if (other.hidden != Options.BooleanOptions.NoValue) {
-            hidden = other.hidden;
+        if (other.visible.hasValue()) {
+            visible = other.visible;
         }
-        if (other.animateHide != Options.BooleanOptions.NoValue) {
-            animateHide = other.animateHide;
+        if (other.animate.hasValue()) {
+            animate = other.animate;
         }
-        if (other.hideOnScroll != Options.BooleanOptions.NoValue) {
+        if (other.hideOnScroll.hasValue()) {
             hideOnScroll = other.hideOnScroll;
         }
-        if (other.drawBehind != Options.BooleanOptions.NoValue) {
+        if (other.drawBehind.hasValue()) {
             drawBehind = other.drawBehind;
         }
         if (other.leftButtons != null)
             textFontSize = defaultOptions.textFontSize;
         if (textFontFamily == null)
             textFontFamily = defaultOptions.textFontFamily;
-        if (hidden == Options.BooleanOptions.NoValue)
-            hidden = defaultOptions.hidden;
-        if (animateHide == Options.BooleanOptions.NoValue)
-            animateHide = defaultOptions.animateHide;
-        if (hideOnScroll == Options.BooleanOptions.NoValue)
+        if (!visible.hasValue())
+            visible = defaultOptions.visible;
+        if (!animate.hasValue())
+            animate = defaultOptions.animate;
+        if (!hideOnScroll.hasValue())
             hideOnScroll = defaultOptions.hideOnScroll;
-        if (drawBehind == Options.BooleanOptions.NoValue)
+        if (!drawBehind.hasValue())
             drawBehind = defaultOptions.drawBehind;
         if (leftButtons == null)
             leftButtons = defaultOptions.leftButtons;

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

 import android.graphics.Typeface;
 import android.support.annotation.Nullable;
 
+import com.reactnativenavigation.parse.params.NullText;
+import com.reactnativenavigation.parse.params.Text;
+import com.reactnativenavigation.parse.parsers.TextParser;
 import com.reactnativenavigation.utils.TypefaceLoader;
 
 import org.json.JSONObject;
         return result;
     }
 
-    void mergeWith(TopTabOptions topTabsOptions) {
-
+    void mergeWith(TopTabOptions other) {
+        if (other.title.hasValue()) title = other.title;
+        if (other.fontFamily != null) fontFamily = other.fontFamily;
+        if (other.tabIndex >= 0) tabIndex = other.tabIndex;
     }
 
-    void mergeWithDefault(TopTabOptions topTabsOptions) {
-
+    void mergeWithDefault(TopTabOptions other) {
+        if (fontFamily == null) fontFamily = other.fontFamily;
     }
 }

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

 import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
 
+import com.reactnativenavigation.parse.params.Bool;
+import com.reactnativenavigation.parse.params.Color;
+import com.reactnativenavigation.parse.params.NullBool;
+import com.reactnativenavigation.parse.params.NullColor;
+import com.reactnativenavigation.parse.params.NullNumber;
+import com.reactnativenavigation.parse.params.Number;
+import com.reactnativenavigation.parse.parsers.BoolParser;
+import com.reactnativenavigation.parse.parsers.ColorParser;
+import com.reactnativenavigation.parse.parsers.NumberParser;
+
 import org.json.JSONObject;
 
 public class TopTabsOptions implements DEFAULT_VALUES {
     @NonNull public Color selectedTabColor = new NullColor();
     @NonNull public Color unselectedTabColor = new NullColor();
     @NonNull public Number fontSize = new NullNumber();
+    @NonNull public Bool visible = new NullBool();
 
     public static TopTabsOptions parse(@Nullable JSONObject json) {
         TopTabsOptions result = new TopTabsOptions();
         if (json == null) return result;
-        result.selectedTabColor = ColorParser.parse(json, "selectedTabColor");
+        result.selectedTabColor = ColorParser.parse(json, "selectedColor");
         result.unselectedTabColor = ColorParser.parse(json, "unselectedTabColor");
         result.fontSize = NumberParser.parse(json, "fontSize");
+        result.visible = BoolParser.parse(json, "visible");
         return result;
     }
 
         if (other.selectedTabColor.hasValue()) selectedTabColor = other.selectedTabColor;
         if (other.unselectedTabColor.hasValue()) unselectedTabColor = other.unselectedTabColor;
         if (other.fontSize.hasValue()) fontSize = other.fontSize;
+        if (other.visible.hasValue()) visible = other.visible;
     }
 
     void mergeWithDefault(TopTabsOptions defaultOptions) {
         if (!selectedTabColor.hasValue()) selectedTabColor = defaultOptions.selectedTabColor;
         if (!unselectedTabColor.hasValue()) unselectedTabColor = defaultOptions.unselectedTabColor;
         if (!fontSize.hasValue()) fontSize = defaultOptions.fontSize;
+        if (!visible.hasValue()) visible = defaultOptions.visible;
     }
 }

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

+package com.reactnativenavigation.parse;
+
+
+import android.animation.Animator;
+import android.animation.ObjectAnimator;
+import android.util.Property;
+import android.view.View;
+
+import com.reactnativenavigation.parse.params.FloatParam;
+import com.reactnativenavigation.parse.params.Interpolation;
+import com.reactnativenavigation.parse.params.NullFloatParam;
+import com.reactnativenavigation.parse.params.NullNumber;
+import com.reactnativenavigation.parse.params.Number;
+import com.reactnativenavigation.parse.parsers.FloatParser;
+import com.reactnativenavigation.parse.parsers.InterpolationParser;
+import com.reactnativenavigation.parse.parsers.NumberParser;
+
+import org.json.JSONObject;
+
+public class ValueAnimationOptions implements DEFAULT_VALUES {
+
+    public static ValueAnimationOptions parse(JSONObject json, Property<View, Float> property) {
+        ValueAnimationOptions options = new ValueAnimationOptions();
+
+        options.animProp = property;
+        options.from = FloatParser.parse(json, "from");
+        options.to = FloatParser.parse(json, "to");
+        options.duration = NumberParser.parse(json, "duration");
+        options.startDelay = NumberParser.parse(json, "startDelay");
+        options.interpolation = InterpolationParser.parse(json, "interpolation");
+
+        return options;
+    }
+
+    private Property<View, Float> animProp;
+
+    private FloatParam from = new NullFloatParam();
+    private FloatParam to = new NullFloatParam();
+    private Number duration = new NullNumber();
+    private Number startDelay = new NullNumber();
+    private Interpolation interpolation = Interpolation.NO_VALUE;
+
+    Animator getAnimation(View view) {
+        if (!this.from.hasValue() || !this.to.hasValue())
+            throw new IllegalArgumentException("Params 'from' and 'to' are mandatory");
+        ObjectAnimator animator = ObjectAnimator.ofFloat(view, animProp, this.from.get(), this.to.get());
+        animator.setInterpolator(this.interpolation.getInterpolator());
+        if (this.duration.hasValue())
+            animator.setDuration(this.duration.get());
+        if (this.startDelay.hasValue())
+            animator.setStartDelay(this.startDelay.get());
+        return animator;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        ValueAnimationOptions options = (ValueAnimationOptions) o;
+
+        return animProp.equals(options.animProp);
+    }
+
+    @Override
+    public int hashCode() {
+        return animProp.hashCode();
+    }
+}

lib/android/app/src/main/java/com/reactnativenavigation/parse/params/Bool.java

+package com.reactnativenavigation.parse.params;
+
+public class Bool extends Param<Boolean> {
+    public Bool(Boolean value) {
+        super(value);
+    }
+
+    public boolean isFalseOrUndefined() {
+        return !hasValue() || !get();
+    }
+
+    public boolean isTrueOrUndefined() {
+        return !hasValue() || get();
+    }
+
+    public boolean isTrue() {
+        return hasValue() && get();
+    }
+
+    public boolean isFalse() {
+        return hasValue() && !get();
+    }
+}

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

-package com.reactnativenavigation.parse;
+package com.reactnativenavigation.parse.params;
 
 import android.support.annotation.ColorInt;
 import android.view.MenuItem;
 
+import com.reactnativenavigation.parse.parsers.BoolParser;
+import com.reactnativenavigation.parse.parsers.TextParser;
+
 import org.json.JSONArray;
 import org.json.JSONObject;
 
 
 public class Button {
 	public String id;
-	public Text title;
-	public Options.BooleanOptions disabled;
-	public Options.BooleanOptions disableIconTint;
+	public Text title = new NullText();
+	public Bool enabled = new NullBool();
+	public Bool disableIconTint = new NullBool();
 	public int showAsAction;
 	@ColorInt public int buttonColor;
 	public int buttonFontSize;
-	public Text buttonFontWeight;
-	public Text icon;
+	private Text buttonFontWeight = new NullText();
+	public Text icon = new NullText();
+	public Text testId = new NullText();
 
 	private static Button parseJson(JSONObject json)  {
 		Button button = new Button();
 		button.id = json.optString("id");
 		button.title = TextParser.parse(json, "title");
-		button.disabled = Options.BooleanOptions.parse(json.optString("disabled", ""));
-		button.disableIconTint = Options.BooleanOptions.parse(json.optString("disableIconTint", ""));
+		button.enabled = BoolParser.parse(json,"enabled");
+		button.disableIconTint = BoolParser.parse(json,"disableIconTint");
 		button.showAsAction = parseShowAsAction(json);
 		button.buttonColor = json.optInt("buttonColor", NO_INT_VALUE);
 		button.buttonFontSize = json.optInt("buttonFontSize", NO_INT_VALUE);
 		button.buttonFontWeight = TextParser.parse(json, "buttonFontWeight");
+        button.testId = TextParser.parse(json, "testID");
 
 		if (json.has("icon")) {
 			button.icon = TextParser.parse(json.optJSONObject("icon"), "uri");
 		return button;
 	}
 
-	static ArrayList<Button> parseJsonArray(JSONArray jsonArray) {
+	public static ArrayList<Button> parseJsonArray(JSONArray jsonArray) {
 		ArrayList<Button> buttons = new ArrayList<>();
 
 		if (jsonArray == null) {

lib/android/app/src/main/java/com/reactnativenavigation/parse/Color.java → lib/android/app/src/main/java/com/reactnativenavigation/parse/params/Color.java

-package com.reactnativenavigation.parse;
+package com.reactnativenavigation.parse.params;
 
 import android.support.annotation.ColorInt;
 

lib/android/app/src/main/java/com/reactnativenavigation/parse/params/FloatParam.java

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

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

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

lib/android/app/src/main/java/com/reactnativenavigation/parse/params/Interpolation.java

+package com.reactnativenavigation.parse.params;
+
+
+import android.animation.TimeInterpolator;
+import android.view.animation.AccelerateDecelerateInterpolator;
+import android.view.animation.AccelerateInterpolator;
+import android.view.animation.DecelerateInterpolator;
+
+public enum Interpolation {
+    ACCELERATING,
+    DECELERATING,
+    DEFAULT,
+    NO_VALUE;
+
+    public TimeInterpolator getInterpolator() {
+        switch (this) {
+            case ACCELERATING:
+                return new AccelerateInterpolator();
+            case DECELERATING:
+                return new DecelerateInterpolator();
+            case DEFAULT:
+                return new AccelerateDecelerateInterpolator();
+        }
+        return null;
+    }
+}

lib/android/app/src/main/java/com/reactnativenavigation/parse/params/NullBool.java

+package com.reactnativenavigation.parse.params;
+
+public class NullBool extends Bool {
+    public NullBool() {
+        super(null);
+    }
+}

lib/android/app/src/main/java/com/reactnativenavigation/parse/NullColor.java → lib/android/app/src/main/java/com/reactnativenavigation/parse/params/NullColor.java

-package com.reactnativenavigation.parse;
+package com.reactnativenavigation.parse.params;
 
 public class NullColor extends Color {
 
-    NullColor() {
+    public NullColor() {
         super(0);
     }
 

lib/android/app/src/main/java/com/reactnativenavigation/parse/params/NullFloatParam.java

+package com.reactnativenavigation.parse.params;
+
+
+public class NullFloatParam extends FloatParam {
+
+    public NullFloatParam() {
+        super(0f);
+    }
+
+    @Override
+    public boolean hasValue() {
+        return false;
+    }
+}

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

-package com.reactnativenavigation.parse;
+package com.reactnativenavigation.parse.params;
 
 public class NullFraction extends Fraction {
-    NullFraction() {
+    public NullFraction() {
         super(0);
     }
 

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

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

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

-package com.reactnativenavigation.parse;
+package com.reactnativenavigation.parse.params;
 
 public class NullText extends Text {
     public NullText() {

lib/android/app/src/main/java/com/reactnativenavigation/parse/Number.java → lib/android/app/src/main/java/com/reactnativenavigation/parse/params/Number.java

-package com.reactnativenavigation.parse;
+package com.reactnativenavigation.parse.params;
 
 public class Number extends Param<Integer> {
 

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

-package com.reactnativenavigation.parse;
+package com.reactnativenavigation.parse.params;
 
 public abstract class Param<T> {
     protected T value;

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

+package com.reactnativenavigation.parse.params;
+
+public class Text extends Param<String> {
+    public Text(String value) {
+        super(value);
+    }
+
+    @Override
+    public String toString() {
+        return hasValue() ? value : "No Value";
+    }
+}

lib/android/app/src/main/java/com/reactnativenavigation/parse/parsers/BoolParser.java

+package com.reactnativenavigation.parse.parsers;
+
+import com.reactnativenavigation.parse.params.Bool;
+import com.reactnativenavigation.parse.params.NullBool;
+
+import org.json.JSONObject;
+
+public class BoolParser {
+    public static Bool parse(JSONObject json, String bool) {
+        return json.has(bool) ? new Bool(json.optBoolean(bool)) : new NullBool();
+    }
+}

lib/android/app/src/main/java/com/reactnativenavigation/parse/ColorParser.java → lib/android/app/src/main/java/com/reactnativenavigation/parse/parsers/ColorParser.java

-package com.reactnativenavigation.parse;
+package com.reactnativenavigation.parse.parsers;
+
+import com.reactnativenavigation.parse.params.Color;
+import com.reactnativenavigation.parse.params.NullColor;
 
 import org.json.JSONObject;
 

lib/android/app/src/main/java/com/reactnativenavigation/parse/parsers/FloatParser.java

+package com.reactnativenavigation.parse.parsers;
+
+import com.reactnativenavigation.parse.params.FloatParam;
+import com.reactnativenavigation.parse.params.NullFloatParam;
+import com.reactnativenavigation.parse.params.NullNumber;
+import com.reactnativenavigation.parse.params.Number;
+
+import org.json.JSONObject;
+
+public class FloatParser {
+    public static FloatParam parse(JSONObject json, String number) {
+        return json.has(number) ? new FloatParam((float) json.optDouble(number)) : new NullFloatParam();
+    }
+}

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

-package com.reactnativenavigation.parse;
+package com.reactnativenavigation.parse.parsers;
+
+import com.reactnativenavigation.parse.params.Fraction;
+import com.reactnativenavigation.parse.params.NullFraction;
 
 import org.json.JSONObject;
 

lib/android/app/src/main/java/com/reactnativenavigation/parse/parsers/InterpolationParser.java

+package com.reactnativenavigation.parse.parsers;
+
+
+import com.reactnativenavigation.parse.params.Interpolation;
+
+import org.json.JSONObject;
+
+public class InterpolationParser {
+    public static Interpolation parse(JSONObject json, String intepolation) {
+        Interpolation result = Interpolation.DEFAULT;
+        if (json.has(intepolation)) {
+            switch (json.optString(intepolation)) {
+                case "decelerate":
+                    result = Interpolation.DECELERATING;
+                    break;
+                case "accelerate":
+                    result = Interpolation.ACCELERATING;
+                    break;
+            }
+        }
+        return result;
+    }
+}

lib/android/app/src/main/java/com/reactnativenavigation/parse/JSONParser.java → lib/android/app/src/main/java/com/reactnativenavigation/parse/parsers/JSONParser.java

-package com.reactnativenavigation.parse;
+package com.reactnativenavigation.parse.parsers;
 
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;

lib/android/app/src/main/java/com/reactnativenavigation/parse/LayoutNodeParser.java → lib/android/app/src/main/java/com/reactnativenavigation/parse/parsers/LayoutNodeParser.java

-package com.reactnativenavigation.parse;
+package com.reactnativenavigation.parse.parsers;
 
 import android.support.annotation.NonNull;
 
+import com.reactnativenavigation.parse.LayoutNode;
+
 import org.json.JSONArray;
 import org.json.JSONObject;
 

lib/android/app/src/main/java/com/reactnativenavigation/parse/NumberParser.java → lib/android/app/src/main/java/com/reactnativenavigation/parse/parsers/NumberParser.java

-package com.reactnativenavigation.parse;
+package com.reactnativenavigation.parse.parsers;
+
+import com.reactnativenavigation.parse.params.NullNumber;
+import com.reactnativenavigation.parse.params.Number;
 
 import org.json.JSONObject;
 

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

-package com.reactnativenavigation.parse;
+package com.reactnativenavigation.parse.parsers;
+
+import com.reactnativenavigation.parse.params.NullText;
+import com.reactnativenavigation.parse.params.Text;
 
 import org.json.JSONObject;
 

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

+package com.reactnativenavigation.presentation;
+
+import com.reactnativenavigation.parse.BottomTabOptions;
+import com.reactnativenavigation.parse.BottomTabsOptions;
+import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.viewcontrollers.bottomtabs.BottomTabFinder;
+import com.reactnativenavigation.views.BottomTabs;
+
+public class BottomTabsOptionsPresenter {
+    private BottomTabs bottomTabs;
+    private BottomTabFinder bottomTabFinder;
+
+    public BottomTabsOptionsPresenter(BottomTabs bottomTabs, BottomTabFinder bottomTabFinder) {
+        this.bottomTabs = bottomTabs;
+        this.bottomTabFinder = bottomTabFinder;
+    }
+
+    public void present(Options options) {
+        applyBottomTabsOptions(options.bottomTabsOptions);
+    }
+
+    public void present(Options options, int tabIndex) {
+        applyBottomTabOptions(options.bottomTabOptions, tabIndex);
+    }
+
+    private void applyBottomTabOptions(BottomTabOptions options, int tabIndex) {
+        if (options.badge.hasValue()) {
+            bottomTabs.setBadge(tabIndex, options.badge);
+        }
+    }
+
+    private void applyBottomTabsOptions(BottomTabsOptions options) {
+        if (options.backgroundColor.hasValue()) {
+            bottomTabs.setBackgroundColor(options.backgroundColor.get());
+        }
+        if (options.currentTabIndex.hasValue()) {
+            bottomTabs.setCurrentItem(options.currentTabIndex.get());
+        }
+        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) bottomTabs.setCurrentItem(tabIndex);
+        }
+        if (options.visible.isTrueOrUndefined()) {
+            bottomTabs.restoreBottomNavigation(options.animate.isTrueOrUndefined());
+        }
+        if (options.visible.isFalse()) {
+            bottomTabs.hideBottomNavigation(options.animate.isTrueOrUndefined());
+        }
+    }
+}

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

+package com.reactnativenavigation.presentation;
+
+
+import android.support.annotation.NonNull;
+import android.view.Gravity;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.FrameLayout;
+import android.widget.RelativeLayout;
+
+import com.reactnativenavigation.R;
+import com.reactnativenavigation.parse.FabOptions;
+import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.views.Fab;
+import com.reactnativenavigation.views.FabMenu;
+import com.reactnativenavigation.views.ReactComponent;
+
+import static android.widget.RelativeLayout.ALIGN_PARENT_BOTTOM;
+import static android.widget.RelativeLayout.ALIGN_PARENT_LEFT;
+import static android.widget.RelativeLayout.ALIGN_PARENT_RIGHT;
+import static android.widget.RelativeLayout.ALIGN_PARENT_TOP;
+import static com.github.clans.fab.FloatingActionButton.SIZE_MINI;
+import static com.github.clans.fab.FloatingActionButton.SIZE_NORMAL;
+
+public class FabOptionsPresenter {
+    private ViewGroup viewGroup;
+    private ReactComponent component;
+
+    private Fab fab;
+    private FabMenu fabMenu;
+
+    public void applyOptions(FabOptions options, @NonNull ReactComponent component, @NonNull ViewGroup viewGroup) {
+        this.viewGroup = viewGroup;
+        this.component = component;
+
+        if (options.id.hasValue()) {
+            if (fabMenu != null && fabMenu.getFabId().equals(options.id.get())) {
+                setParams(fabMenu, options);
+                fabMenu.bringToFront();
+                applyFabMenuOptions(fabMenu, options);
+            } else if (fab != null && fab.getFabId().equals(options.id.get())) {
+                setParams(fab, options);
+                fab.bringToFront();
+                applyFabOptions(fab, options);
+                fab.setOnClickListener(v -> component.sendOnNavigationButtonPressed(options.id.get()));
+            } else {
+                createFab(options);
+            }
+        } else {
+            removeFab();
+            removeFabMenu();
+        }
+    }
+
+    private void createFab(FabOptions options) {
+        if (options.actionsArray.size() > 0) {
+            fabMenu = new FabMenu(viewGroup.getContext(), options.id.get());
+            setParams(fabMenu, options);
+            applyFabMenuOptions(fabMenu, options);
+            viewGroup.addView(fabMenu);
+        } else {
+            fab = new Fab(viewGroup.getContext(), options.id.get());
+            setParams(fab, options);
+            applyFabOptions(fab, options);
+            fab.setOnClickListener(v -> component.sendOnNavigationButtonPressed(options.id.get()));
+            viewGroup.addView(fab);
+        }
+    }
+
+    private void removeFabMenu() {
+        if (fabMenu != null) {
+            fabMenu.hideMenuButton(true);
+            viewGroup.removeView(fabMenu);
+            fabMenu = null;
+        }
+    }
+
+    private void removeFab() {
+        if (fab != null) {
+            fab.hide(true);
+            viewGroup.removeView(fab);
+            fab = null;
+        }
+    }
+
+    private void setParams(View fab, FabOptions options) {
+        ViewGroup.LayoutParams layoutParams = new ViewGroup.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT);
+        if (viewGroup instanceof RelativeLayout) {
+            RelativeLayout.LayoutParams layoutParamsRelative = new RelativeLayout.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT);
+            layoutParamsRelative.bottomMargin = (int) viewGroup.getContext().getResources().getDimension(R.dimen.margin);
+            layoutParamsRelative.rightMargin = (int) viewGroup.getContext().getResources().getDimension(R.dimen.margin);
+            layoutParamsRelative.leftMargin = (int) viewGroup.getContext().getResources().getDimension(R.dimen.margin);
+            layoutParamsRelative.topMargin = (int) viewGroup.getContext().getResources().getDimension(R.dimen.margin);
+            if (options.alignHorizontally.hasValue()) {
+                if ("right".equals(options.alignHorizontally.get())) {
+                    layoutParamsRelative.removeRule(ALIGN_PARENT_LEFT);
+                    layoutParamsRelative.addRule(ALIGN_PARENT_RIGHT);
+                }
+                if ("left".equals(options.alignHorizontally.get())) {
+                    layoutParamsRelative.removeRule(ALIGN_PARENT_RIGHT);
+                    layoutParamsRelative.addRule(ALIGN_PARENT_LEFT);
+                }
+            } else {
+                layoutParamsRelative.addRule(ALIGN_PARENT_RIGHT);
+            }
+            if (options.alignVertically.hasValue()) {
+                if ("top".equals(options.alignVertically.get())) {
+                    layoutParamsRelative.removeRule(ALIGN_PARENT_BOTTOM);
+                    layoutParamsRelative.addRule(ALIGN_PARENT_TOP);
+                }
+                if ("bottom".equals(options.alignVertically.get())) {
+                    layoutParamsRelative.removeRule(ALIGN_PARENT_TOP);
+                    layoutParamsRelative.addRule(ALIGN_PARENT_BOTTOM);
+                }
+            } else {
+                layoutParamsRelative.addRule(ALIGN_PARENT_BOTTOM);
+            }
+            layoutParams = layoutParamsRelative;
+        }
+        if (viewGroup instanceof FrameLayout) {
+            FrameLayout.LayoutParams layoutParamsFrame = new FrameLayout.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT);
+            layoutParamsFrame.bottomMargin = (int) viewGroup.getContext().getResources().getDimension(R.dimen.margin);
+            layoutParamsFrame.rightMargin = (int) viewGroup.getContext().getResources().getDimension(R.dimen.margin);
+            layoutParamsFrame.leftMargin = (int) viewGroup.getContext().getResources().getDimension(R.dimen.margin);
+            layoutParamsFrame.topMargin = (int) viewGroup.getContext().getResources().getDimension(R.dimen.margin);
+            if (options.alignHorizontally.hasValue()) {
+                if ("right".equals(options.alignHorizontally.get())) {
+                    removeGravityParam(layoutParamsFrame, Gravity.LEFT);
+                    setGravityParam(layoutParamsFrame, Gravity.RIGHT);
+                }
+                if ("left".equals(options.alignHorizontally.get())) {
+                    removeGravityParam(layoutParamsFrame, Gravity.RIGHT);
+                    setGravityParam(layoutParamsFrame, Gravity.LEFT);
+                }
+            } else {
+                setGravityParam(layoutParamsFrame, Gravity.RIGHT);
+            }
+            if (options.alignVertically.hasValue()) {
+                if ("top".equals(options.alignVertically.get())) {
+                    removeGravityParam(layoutParamsFrame, Gravity.BOTTOM);
+                    setGravityParam(layoutParamsFrame, Gravity.TOP);
+                }
+                if ("bottom".equals(options.alignVertically.get())) {
+                    removeGravityParam(layoutParamsFrame, Gravity.TOP);
+                    setGravityParam(layoutParamsFrame, Gravity.BOTTOM);
+                }
+            } else {
+                setGravityParam(layoutParamsFrame, Gravity.BOTTOM);
+            }
+            layoutParams = layoutParamsFrame;
+        }
+        fab.setLayoutParams(layoutParams);
+    }
+
+    private void applyFabOptions(Fab fab, FabOptions options) {
+        if (options.visible.isTrueOrUndefined()) {
+            fab.show(true);
+        }
+        if (options.visible.isFalse()) {
+            fab.hide(true);
+        }
+        if (options.backgroundColor.hasValue()) {
+            fab.setColorNormal(options.backgroundColor.get());
+        }
+        if (options.clickColor.hasValue()) {
+            fab.setColorPressed(options.clickColor.get());
+        }
+        if (options.rippleColor.hasValue()) {
+            fab.setColorRipple(options.rippleColor.get());
+        }
+        if (options.icon.hasValue()) {
+            fab.applyIcon(options.icon.get());
+        }
+        if (options.size.hasValue()) {
+            fab.setButtonSize("mini".equals(options.size.get()) ? SIZE_MINI : SIZE_NORMAL);
+        }
+        if (options.hideOnScroll.isTrue()) {
+            fab.enableCollapse(component.getScrollEventListener());
+        }
+        if (options.hideOnScroll.isFalseOrUndefined()) {
+            fab.disableCollapse();
+        }
+    }
+
+    private void applyFabMenuOptions(FabMenu fabMenu, FabOptions options) {
+        if (options.visible.isTrueOrUndefined()) {
+            fabMenu.showMenuButton(true);
+        }
+        if (options.visible.isFalse()) {
+            fabMenu.hideMenuButton(true);
+        }
+
+        if (options.backgroundColor.hasValue()) {
+            fabMenu.setMenuButtonColorNormal(options.backgroundColor.get());
+        }
+        if (options.clickColor.hasValue()) {
+            fabMenu.setMenuButtonColorPressed(options.clickColor.get());
+        }
+        if (options.rippleColor.hasValue()) {
+            fabMenu.setMenuButtonColorRipple(options.rippleColor.get());
+        }
+        for (Fab fabStored : fabMenu.getActions()) {
+            fabMenu.removeMenuButton(fabStored);
+        }
+        fabMenu.getActions().clear();
+        for (FabOptions fabOption : options.actionsArray) {
+            Fab fab = new Fab(viewGroup.getContext(), fabOption.id.get());
+            applyFabOptions(fab, fabOption);
+            fab.setOnClickListener(v -> component.sendOnNavigationButtonPressed(options.id.get()));
+
+            fabMenu.getActions().add(fab);
+            fabMenu.addMenuButton(fab);
+        }
+        if (options.hideOnScroll.isTrue()) {
+            fabMenu.enableCollapse(component.getScrollEventListener());
+        }
+        if (options.hideOnScroll.isFalseOrUndefined()) {
+            fabMenu.disableCollapse();
+        }
+    }
+
+    private void setGravityParam(FrameLayout.LayoutParams params, int gravityParam) {
+        params.gravity = params.gravity | gravityParam;
+    }
+
+    private void removeGravityParam(FrameLayout.LayoutParams params, int gravityParam) {
+        if ((params.gravity & gravityParam) == gravityParam) {
+            params.gravity = params.gravity & ~gravityParam;
+        }
+    }
+}

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

 package com.reactnativenavigation.presentation;
 
-import com.reactnativenavigation.parse.Button;
+import com.reactnativenavigation.parse.params.Button;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.TopBarOptions;
 import com.reactnativenavigation.parse.TopTabOptions;
 
 import java.util.ArrayList;
 
-import static com.reactnativenavigation.parse.Options.BooleanOptions.False;
-import static com.reactnativenavigation.parse.Options.BooleanOptions.True;
-
 public class OptionsPresenter {
     private TopBar topBar;
     private ReactComponent component;
         this.component = component;
     }
 
+    public OptionsPresenter(TopBar topBar) {
+        this.topBar = topBar;
+    }
+
     public void applyOptions(Options options) {
         applyButtons(options.topBarOptions.leftButtons, options.topBarOptions.rightButtons);
         applyTopBarOptions(options.topBarOptions);
         topBar.setBackgroundColor(options.backgroundColor);
         topBar.setTitleTextColor(options.textColor);
         topBar.setTitleFontSize(options.textFontSize);
+        if (options.testId.hasValue()) topBar.setTestId(options.testId.get());
 
         topBar.setTitleTypeface(options.textFontFamily);
-        if (options.hidden == True) {
-            topBar.hide(options.animateHide);
+        if (options.visible.isFalse()) {
+            topBar.hide(options.animate);
         }
-        if (options.hidden == False) {
-            topBar.show(options.animateHide);
+        if (options.visible.isTrueOrUndefined()) {
+            topBar.show(options.animate);
         }
-        if (options.drawBehind == True) {
+        if (options.drawBehind.isTrue()) {
             component.drawBehindTopBar();
-        } else if (options.drawBehind == False) {
+        } else if (options.drawBehind.isFalseOrUndefined()) {
             component.drawBelowTopBar(topBar);
         }
 
-        if (options.hideOnScroll == True) {
+        if (options.hideOnScroll.isTrue()) {
             topBar.enableCollapse(component.getScrollEventListener());
-        } else if (options.hideOnScroll == False) {
+        } else if (options.hideOnScroll.isTrue()) {
             topBar.disableCollapse();
         }
     }
     private void applyTopTabsOptions(TopTabsOptions options) {
         topBar.applyTopTabsColors(options.selectedTabColor, options.unselectedTabColor);
         topBar.applyTopTabsFontSize(options.fontSize);
+        topBar.setTopTabsVisible(options.visible.isTrueOrUndefined());
     }
 
     private void applyTopTabOptions(TopTabOptions topTabOptions) {
             topBar.setTopTabFontFamily(topTabOptions.tabIndex, topTabOptions.fontFamily);
         }
     }
+
+    public void onChildWillDisappear(Options disappearing, Options appearing) {
+        if (disappearing.topBarOptions.visible.isTrueOrUndefined() && appearing.topBarOptions.visible.isFalse()) {
+            topBar.hide(disappearing.topBarOptions.animate);
+        }
+    }
 }

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

+package com.reactnativenavigation.presentation;
+
+import android.support.v4.widget.DrawerLayout;
+import android.view.Gravity;
+
+import com.reactnativenavigation.parse.SideMenuRootOptions;
+
+public class SideMenuOptionsPresenter {
+
+    private DrawerLayout sideMenu;
+
+    public SideMenuOptionsPresenter(DrawerLayout sideMenu) {
+        this.sideMenu = sideMenu;
+    }
+
+    public void present(SideMenuRootOptions options) {
+        if (options.left.visible.isTrue()) {
+            sideMenu.openDrawer(Gravity.LEFT);
+        }
+        if (options.right.visible.isTrue()) {
+            sideMenu.openDrawer(Gravity.RIGHT);
+        }
+    }
+}

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

 package com.reactnativenavigation.react;
 
+import android.support.annotation.NonNull;
+
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.WritableMap;
-import com.facebook.react.bridge.WritableNativeArray;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
 
-import org.json.JSONException;
-import org.json.JSONObject;
-
 import static com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter;
 
 public class NavigationEvent {
 	private static final String componentDidAppear = "RNN.componentDidAppear";
 	private static final String componentDidDisappear = "RNN.componentDidDisappear";
 	private static final String onNavigationButtonPressed = "RNN.navigationButtonPressed";
+    private static final String componentLifecycle = "RNN.componentLifecycle";
 
 	private final RCTDeviceEventEmitter emitter;
 
 		emit(onAppLaunched);
 	}
 
-	public void componentDidDisappear(String id) {
+	public void componentDidDisappear(String id, String componentName) {
 		emit(componentDidDisappear, id);
+		emit(componentLifecycle, getLifecycleEventData(id, componentName, "didDisappear"));
 	}
 
-	public void componentDidAppear(String id) {
+	public void componentDidAppear(String id, String componentName) {
 		emit(componentDidAppear, id);
+        emit(componentLifecycle, getLifecycleEventData(id, componentName, "didAppear"));
 	}
 
-	public void sendOnNavigationButtonPressed(String id, String buttonId) {
+    @NonNull
+    private WritableMap getLifecycleEventData(String id, String componentName, String didAppear) {
+        WritableMap map = Arguments.createMap();
+        map.putString("componentId", id);
+        map.putString("componentName", componentName);
+        map.putString("event", didAppear);
+        return map;
+    }
+
+    public void sendOnNavigationButtonPressed(String id, String buttonId) {
 		WritableMap map = Arguments.createMap();
 		map.putString("componentId", id);
 		map.putString("buttonId", buttonId);

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

 import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.ReadableMap;
 import com.reactnativenavigation.NavigationActivity;
-import com.reactnativenavigation.parse.JSONParser;
+import com.reactnativenavigation.parse.parsers.JSONParser;
 import com.reactnativenavigation.parse.LayoutFactory;
 import com.reactnativenavigation.parse.LayoutNode;
-import com.reactnativenavigation.parse.LayoutNodeParser;
+import com.reactnativenavigation.parse.parsers.LayoutNodeParser;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.utils.TypefaceLoader;
 import com.reactnativenavigation.utils.UiThread;

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

 
 	@Override
 	public void sendComponentStart() {
-		new NavigationEvent(reactInstanceManager.getCurrentReactContext()).componentDidAppear(componentId);
+		new NavigationEvent(reactInstanceManager.getCurrentReactContext()).componentDidAppear(componentId, componentName);
 	}
 
 	@Override
 	public void sendComponentStop() {
-		new NavigationEvent(reactInstanceManager.getCurrentReactContext()).componentDidDisappear(componentId);
+		new NavigationEvent(reactInstanceManager.getCurrentReactContext()).componentDidDisappear(componentId, componentName);
 	}
 
     @Override

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

+package com.reactnativenavigation.utils;
+
+public class ArrayUtils {
+    public static boolean contains(Object[] array, Object item) {
+        if (isNullOrEmpty(array)) return false;
+        for (Object o : array) {
+            if (o == item) return true;
+        }
+        return false;
+    }
+
+    private static boolean isNullOrEmpty(Object[] array) {
+        return array == null || array.length == 0;
+    }
+}

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

 	private static final AtomicInteger viewId = new AtomicInteger(1);
 
 	public static int generateViewId() {
-		if (Build.VERSION.SDK_INT >= 17) {
+		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
 			return View.generateViewId();
 		} else {
 			while (true) {

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

 import java.io.InputStream;
 import java.net.URL;
 
-public class ImageUtils {
+public class ImageLoader {
 
 	public interface ImageLoadingListener {
 		void onComplete(@NonNull Drawable drawable);
 		void onError(Throwable error);
 	}
 
-	public static void loadIcon(final Context context, final String uri, final ImageLoadingListener listener) {
+	public void loadIcon(final Context context, final String uri, final ImageLoadingListener listener) {
         try {
             StrictMode.ThreadPolicy threadPolicy = adjustThreadPolicyDebug();
             
         }
     }
 
-    private static StrictMode.ThreadPolicy adjustThreadPolicyDebug() {
+    private StrictMode.ThreadPolicy adjustThreadPolicyDebug() {
         StrictMode.ThreadPolicy threadPolicy = null;
         if (NavigationApplication.instance.isDebug()) {
             threadPolicy = StrictMode.getThreadPolicy();
         return threadPolicy;
     }
 
-    private static void restoreThreadPolicyDebug(@Nullable StrictMode.ThreadPolicy threadPolicy) {
+    private void restoreThreadPolicyDebug(@Nullable StrictMode.ThreadPolicy threadPolicy) {
         if (NavigationApplication.instance.isDebug() && threadPolicy != null) {
             StrictMode.setThreadPolicy(threadPolicy);
         }

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

 package com.reactnativenavigation.utils;
 
 import android.content.Context;
+import android.content.res.Resources;
 import android.graphics.PorterDuff;
 import android.graphics.PorterDuffColorFilter;
 import android.graphics.drawable.Drawable;
+import android.os.Build;
 import android.os.Handler;
 import android.os.Looper;
 import android.util.DisplayMetrics;
 import android.view.ViewTreeObserver;
 import android.view.WindowManager;
 
+import com.reactnativenavigation.NavigationApplication;
+
 public class UiUtils {
+    public static final int STATUS_BAR_HEIGHT_M = 24;
+    public static final int STATUS_BAR_HEIGHT_L = 25;
+    private static int statusBarHeight = -1;
+
 	public static void runOnPreDrawOnce(final View view, final Runnable task) {
         view.getViewTreeObserver().addOnPreDrawListener(new ViewTreeObserver.OnPreDrawListener() {
             @Override
 		}
 		return metrics.heightPixels;
 	}
+
+    public static int getStatusBarHeight(Context context) {
+        if (statusBarHeight > 0) {
+            return statusBarHeight;
+        }
+        final Resources resources = context.getResources();
+        final int resourceId = resources.getIdentifier("status_bar_height", "dimen", "android");
+        statusBarHeight = resourceId > 0 ?
+                resources.getDimensionPixelSize(resourceId) :
+                (int) dpToPx(Build.VERSION.SDK_INT >= Build.VERSION_CODES.M ? STATUS_BAR_HEIGHT_M : STATUS_BAR_HEIGHT_L);
+        return statusBarHeight;
+    }
+
+    public static float dpToPx(float dp) {
+        float scale = NavigationApplication.instance.getResources().getDisplayMetrics().density;
+        return dp * scale + 0.5f;
+    }
+
 }

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

 import android.view.View;
 import android.view.ViewGroup;
 
+import java.util.ArrayList;
+import java.util.List;
+
 public class ViewUtils {
     @Nullable
     public static <T> T findChildByClass(ViewGroup root, Class clazz) {
         }
         return null;
     }
+
+    public static <T> List<T> findChildrenByClassRecursive(ViewGroup root, Class clazz) {
+        ArrayList<T> ret = new ArrayList<>();
+        for (int i = 0; i < root.getChildCount(); i++) {
+            View view = root.getChildAt(i);
+            if (view instanceof ViewGroup) {
+                ret.addAll(findChildrenByClassRecursive((ViewGroup) view, clazz));
+            }
+            if (clazz.isAssignableFrom(view.getClass())) {
+                ret.add((T) view);
+            }
+        }
+        return ret;
+    }
+
+    public static <T> List<T> findChildrenByClass(ViewGroup root, Class clazz) {
+        List<T> ret = new ArrayList<>();
+        for (int i = 0; i < root.getChildCount(); i++) {
+            View view = root.getChildAt(i);
+            if (clazz.isAssignableFrom(view.getClass())) {
+                ret.add((T) view);
+            }
+        }
+        return ret;
+    }
 }

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

-package com.reactnativenavigation.viewcontrollers;
-
-import android.app.Activity;
-import android.graphics.Color;
-import android.support.annotation.NonNull;
-import android.support.design.widget.BottomNavigationView;
-import android.view.Menu;
-import android.view.MenuItem;
-import android.view.View;
-import android.view.ViewGroup;
-import android.widget.RelativeLayout;
-
-import com.reactnativenavigation.parse.Options;
-import com.reactnativenavigation.parse.Text;
-import com.reactnativenavigation.presentation.NavigationOptionsListener;
-import com.reactnativenavigation.utils.CompatUtils;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-
-import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
-import static android.view.ViewGroup.LayoutParams.WRAP_CONTENT;
-import static android.widget.RelativeLayout.ABOVE;
-import static android.widget.RelativeLayout.ALIGN_PARENT_BOTTOM;
-import static com.reactnativenavigation.parse.DEFAULT_VALUES.NO_INT_VALUE;
-
-public class BottomTabsController extends ParentController
-		implements BottomNavigationView.OnNavigationItemSelectedListener, NavigationOptionsListener {
-	private BottomNavigationView bottomNavigationView;
-	private List<ViewController> tabs = new ArrayList<>();
-	private int selectedIndex = 0;
-
-	public BottomTabsController(final Activity activity, final String id) {
-		super(activity, id);
-	}
-
-	@NonNull
-	@Override
-	protected ViewGroup createView() {
-		RelativeLayout root = new RelativeLayout(getActivity());
-		bottomNavigationView = new BottomNavigationView(getActivity());
-		bottomNavigationView.setId(CompatUtils.generateViewId());
-		bottomNavigationView.setBackgroundColor(Color.DKGRAY);
-		bottomNavigationView.setOnNavigationItemSelectedListener(this);
-		RelativeLayout.LayoutParams lp = new RelativeLayout.LayoutParams(MATCH_PARENT, WRAP_CONTENT);
-		lp.addRule(ALIGN_PARENT_BOTTOM);
-		root.addView(bottomNavigationView, lp);
-		return root;
-	}
-
-	@Override
-	public boolean handleBack() {
-		return !tabs.isEmpty() && tabs.get(selectedIndex).handleBack();
-	}
-
-	@Override
-	public boolean onNavigationItemSelected(@NonNull final MenuItem item) {
-		selectTabAtIndex(item.getItemId());
-		return true;
-	}
-
-	void selectTabAtIndex(final int newIndex) {
-		tabs.get(selectedIndex).getView().setVisibility(View.GONE);
-		selectedIndex = newIndex;
-		tabs.get(selectedIndex).getView().setVisibility(View.VISIBLE);
-	}
-
-	public void setTabs(final List<ViewController> tabs) {
-		if (tabs.size() > 5) {
-			throw new RuntimeException("Too many tabs!");
-		}
-		this.tabs = tabs;
-		getView();
-		for (int i = 0; i < tabs.size(); i++) {
-			String title = String.valueOf(i);
-			createTab(tabs.get(i), i, title);
-		}
-		selectTabAtIndex(0);
-	}
-
-	private void createTab(ViewController tab, final int index, final String title) {
-		bottomNavigationView.getMenu().add(0, index, Menu.NONE, title);
-		RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT);
-		params.addRule(ABOVE, bottomNavigationView.getId());
-		tab.getView().setVisibility(View.GONE);
-		getView().addView(tab.getView(), params);
-	}
-
-	int getSelectedIndex() {
-		return selectedIndex;
-	}
-
-	@NonNull
-	@Override
-	public Collection<ViewController> getChildControllers() {
-		return tabs;
-	}
-
-	@Override
-	public void mergeOptions(Options options) {
-        if (options.bottomTabsOptions.currentTabIndex != NO_INT_VALUE) {
-            selectTabAtIndex(options.bottomTabsOptions.currentTabIndex);
-        }
-        if (options.bottomTabsOptions.currentTabId.hasValue()) {
-            Text id = options.bottomTabsOptions.currentTabId;
-            for (ViewController controller : tabs) {
-                if (controller.getId().equals(id.get())) {
-                    selectTabAtIndex(tabs.indexOf(controller));
-                }
-                if (controller instanceof StackController) {
-                    if (hasControlWithId((StackController) controller, id.get())) {
-                        selectTabAtIndex(tabs.indexOf(controller));
-                    }
-                }
-            }
-        }
-    }
-
-	private boolean hasControlWithId(StackController controller, String id) {
-		for (ViewController child : controller.getChildControllers()) {
-			if (id.equals(child.getId())) {
-				return true;
-			}
-			if (child instanceof StackController) {
-				return hasControlWithId((StackController) child, id);
-			}
-		}
-		return false;
-	}
-}

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

                                    final String id,
                                    final String componentName,
                                    final ReactViewCreator viewCreator,
-                                   final Options initialNavigationOptions) {
-        super(activity, id);
+                                   final Options initialOptions) {
+        super(activity, id, initialOptions);
         this.componentName = componentName;
         this.viewCreator = viewCreator;
-        options = initialNavigationOptions;
     }
 
     @Override
     public void onViewAppeared() {
         super.onViewAppeared();
-        view.applyOptions(options);
         view.sendComponentStart();
     }
 
         super.onViewDisappear();
     }
 
+    @Override
+    public void sendOnNavigationButtonPressed(String buttonId) {
+        getView().sendOnNavigationButtonPressed(buttonId);
+    }
+
+    @Override
+    public void applyOptions(Options options) {
+        view.applyOptions(options);
+    }
+
     @Override
     protected boolean isViewShown() {
         return super.isViewShown() && view.isReady();
 
     @Override
     public void mergeOptions(Options options) {
-        this.options.mergeWith(options);
+        this.options = this.options.mergeWith(options);
         view.applyOptions(this.options);
         applyOnParentController(parentController -> parentController.applyOptions(this.options, view));
     }
 
-    Options getOptions() {
-        return options;
-    }
-
     ReactComponent getComponent() {
         return view;
     }

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

 package com.reactnativenavigation.viewcontrollers;
 
-import android.app.Dialog;
-import android.content.DialogInterface;
 import android.support.annotation.Nullable;
-import android.view.KeyEvent;
-import android.view.View;
 
 import com.facebook.react.bridge.Promise;
-import com.reactnativenavigation.R;
+import com.reactnativenavigation.viewcontrollers.modal.Modal;
+import com.reactnativenavigation.viewcontrollers.modal.ModalCreator;
 
 import java.util.ArrayList;
 import java.util.List;
 
-import static android.view.View.MeasureSpec.EXACTLY;
-import static android.view.View.MeasureSpec.makeMeasureSpec;
-
 public class ModalStack {
 
 	private List<Modal> modals = new ArrayList<>();
+    private ModalCreator creator;
+
+    public ModalStack(ModalCreator creator) {
+        this.creator = creator;
+    }
 
-	public void showModal(final ViewController viewController, Promise promise) {
-		Modal modal = new Modal(viewController);
-		modals.add(modal);
+    public void showModal(final ViewController viewController, Promise promise) {
+        Modal modal = creator.create(viewController);
+        modals.add(modal);
 		modal.show();
 		if (promise != null) {
 			promise.resolve(viewController.getId());
 	}
 
 	@Nullable
-	private Modal findModalByComponentId(String componentId) {
+	public Modal findModalByComponentId(String componentId) {
 		for (Modal modal : modals) {
 			if (modal.containsDeepComponentId(componentId)) {
 				return modal;
 	@Nullable
     ViewController findControllerById(String id) {
         Modal modal = findModalByComponentId(id);
-        return modal != null ? modal.viewController : null;
-    }
-
-    private static class Modal implements DialogInterface.OnKeyListener {
-		public final ViewController viewController;
-		private final Dialog dialog;
-
-		Modal(final ViewController viewController) {
-			this.viewController = viewController;
-			dialog = new Dialog(viewController.getActivity(), R.style.Modal);
-			dialog.setOnKeyListener(this);
-		}
-
-		void show() {
-			preMeasureView();
-			dialog.setContentView(viewController.getView());
-			dialog.show();
-		}
-
-		void dismiss() {
-			dialog.dismiss();
-		}
-
-		boolean containsDeepComponentId(String componentId) {
-			return viewController.findControllerById(componentId) != null;
-		}
-
-		private void preMeasureView() {
-			View decorView = viewController.getActivity().getWindow().getDecorView();
-			viewController.getView().measure(makeMeasureSpec(decorView.getMeasuredWidth(), EXACTLY), makeMeasureSpec(decorView.getMeasuredHeight(), EXACTLY));
-		}
-
-        @Override
-        public boolean onKey(DialogInterface dialog, int keyCode, KeyEvent event) {
-            if (keyCode == KeyEvent.KEYCODE_BACK) {
-                if (event.getAction() == KeyEvent.ACTION_UP) {
-                    if (viewController.handleBack()) {
-                        return true;
-                    }
-                    dialog.dismiss();
-                }
-            }
-            return false;
-        }
+        return modal != null ? modal.viewController.findControllerById(id) : null;
     }
 }

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

 import com.reactnativenavigation.presentation.OverlayManager;
 import com.reactnativenavigation.utils.CompatUtils;
 import com.reactnativenavigation.utils.NoOpPromise;
+import com.reactnativenavigation.viewcontrollers.modal.ModalCreator;
 
 import java.util.Collection;
 import java.util.Collections;
 public class Navigator extends ParentController {
 
     private static final NoOpPromise NO_OP = new NoOpPromise();
-    private final ModalStack modalStack = new ModalStack();
-	private ViewController root;
+    private final ModalStack modalStack = new ModalStack(new ModalCreator());
+    private ViewController root;
     private OverlayManager overlayManager = new OverlayManager();
     private Options defaultOptions = new Options();
 
     public Navigator(final Activity activity) {
-		super(activity, "navigator" + CompatUtils.generateViewId());
-	}
+        super(activity, "navigator" + CompatUtils.generateViewId(), new Options());
+    }
+
+    @NonNull
+    @Override
+    protected ViewGroup createView() {
+        return new FrameLayout(getActivity());
+    }
 
     @NonNull
-	@Override
-	protected ViewGroup createView() {
-		return new FrameLayout(getActivity());
-	}
-
-	@NonNull
-	@Override
-	public Collection<ViewController> getChildControllers() {
-		return root == null ? Collections.emptyList() : Collections.singletonList(root);
-	}
-
-	@Override
-	public boolean handleBack() {
-		return root != null && root.handleBack();
-	}
-
-	@Override
-	public void destroy() {
-		modalStack.dismissAll(NO_OP);
-		super.destroy();
-	}
-
-	public void setRoot(final ViewController viewController, Promise promise) {
-		if (root != null) {
-			root.destroy();
-		}
-
-		root = viewController;
-		getView().addView(viewController.getView());
+    @Override
+    public Collection<ViewController> getChildControllers() {
+        return root == null ? Collections.emptyList() : Collections.singletonList(root);
+    }
+
+    @Override
+    public boolean handleBack() {
+        return root != null && root.handleBack();
+    }
+
+    @Override
+    public void destroy() {
+        modalStack.dismissAll(NO_OP);
+        super.destroy();
+    }
+
+    @Override
+    public void sendOnNavigationButtonPressed(String buttonId) {
+
+    }
+
+    public void setRoot(final ViewController viewController, Promise promise) {
+        if (root != null) {
+            root.destroy();
+        }
+
+        root = viewController;
+        getView().addView(viewController.getView());
         promise.resolve(viewController.getId());
-	}
+    }
 
     public void setDefaultOptions(Options defaultOptions) {
         this.defaultOptions = defaultOptions;
         return defaultOptions;
     }
 
-	public void setOptions(final String componentId, Options options) {
-		ViewController target = findControllerById(componentId);
-		if (target instanceof NavigationOptionsListener) {
-			((NavigationOptionsListener) target).mergeOptions(options);
-		}
-		if (root instanceof NavigationOptionsListener) {
-			((NavigationOptionsListener) root).mergeOptions(options);
-		}
-	}
-
-	public void push(final String fromId, final ViewController viewController, Promise promise) {
-		ViewController from = findControllerById(fromId);
-		if (from != null) {
-		    from.performOnParentStack(stack -> ((StackController) stack).animatePush(viewController, promise));
-		}
-	}
-
-	void pop(final String fromId, Promise promise) {
-		ViewController from = findControllerById(fromId);
-		if (from != null) {
-		    from.performOnParentStack(stack -> ((StackController) stack).pop(promise));
-		}
-	}
-
-	public void popSpecific(final String id, Promise promise) {
-		ViewController from = findControllerById(id);
-		if (from != null) {
-		    from.performOnParentStack(stack -> ((StackController) stack).popSpecific(from, promise), () -> rejectPromise(promise));
-		} else {
-			rejectPromise(promise);
-		}
-	}
-
-	public void popToRoot(final String id, Promise promise) {
-		ViewController from = findControllerById(id);
-		if (from != null) {
-		    from.performOnParentStack(stack -> ((StackController) stack).popToRoot(promise));
-		}
-	}
-
-	public void popTo(final String componentId, Promise promise) {
-		ViewController target = findControllerById(componentId);
-		if (target != null) {
-		    target.performOnParentStack(stack -> ((StackController) stack).popTo(target, promise), () -> rejectPromise(promise));
-		} else {
-			rejectPromise(promise);
-		}
-	}
-
-	public void showModal(final ViewController viewController, Promise promise) {
-		modalStack.showModal(viewController, promise);
-	}
-
-	public void dismissModal(final String componentId, Promise promise) {
-		modalStack.dismissModal(componentId, promise);
-	}
-
-	public void dismissAllModals(Promise promise) {
-		modalStack.dismissAll(promise);
-	}
-
-	public void showOverlay(ViewController overlay) {
-        overlayManager.show(root.getView(), overlay);
-	}
-
-	public void dismissOverlay(final String componentId) {
-		overlayManager.dismiss(root.getView(), componentId);
-	}
-
-	static void rejectPromise(Promise promise) {
+    public void setOptions(final String componentId, Options options) {
+        ViewController target = findControllerById(componentId);
+        if (target instanceof NavigationOptionsListener) {
+            ((NavigationOptionsListener) target).mergeOptions(options);
+        }
+        if (root instanceof NavigationOptionsListener) {
+            ((NavigationOptionsListener) root).mergeOptions(options);
+        }
+    }
+
+    public void push(final String fromId, final ViewController viewController, Promise promise) {
+        ViewController from = findControllerById(fromId);
+        if (from != null) {
+            from.performOnParentStack(stack -> ((StackController) stack).animatePush(viewController, promise));
+        }
+    }
+
+    void pop(final String fromId, Promise promise) {
+        ViewController from = findControllerById(fromId);
+        if (from != null) {
+            from.performOnParentStack(stack -> ((StackController) stack).pop(promise));
+        }
+    }
+
+    public void popSpecific(final String id, Promise promise) {
+        ViewController from = findControllerById(id);
+        if (from != null) {
+            from.performOnParentStack(stack -> ((StackController) stack).popSpecific(from, promise), () -> rejectPromise(promise));
+        } else {
+            rejectPromise(promise);
+        }
+    }
+
+    public void popToRoot(final String id, Promise promise) {
+        ViewController from = findControllerById(id);
+        if (from != null) {
+            from.performOnParentStack(stack -> ((StackController) stack).popToRoot(promise));
+        }
+    }
+
+    public void popTo(final String componentId, Promise promise) {
+        ViewController target = findControllerById(componentId);
+        if (target != null) {
+            target.performOnParentStack(stack -> ((StackController) stack).popTo(target, promise), () -> rejectPromise(promise));
+        } else {
+            rejectPromise(promise);
+        }
+    }
+
+    public void showModal(final ViewController viewController, Promise promise) {
+        modalStack.showModal(viewController, promise);
+    }
+
+    public void dismissModal(final String componentId, Promise promise) {
+        modalStack.dismissModal(componentId, promise);
+    }
+
+    public void dismissAllModals(Promise promise) {
+        modalStack.dismissAll(promise);
+    }
+
+    public void showOverlay(ViewController overlay) {
+        overlayManager.show(getView(), overlay);
+    }
+
+    public void dismissOverlay(final String componentId) {
+        overlayManager.dismiss(getView(), componentId);
+    }
+
+    static void rejectPromise(Promise promise) {
         promise.reject(new Throwable("Nothing to pop"));
-	}
+    }
 
     @Nullable
     @Override

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

 package com.reactnativenavigation.viewcontrollers;
 
 import android.app.Activity;
+import android.support.annotation.CallSuper;
 import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
 import android.support.v4.view.ViewPager;
 
 public abstract class ParentController<T extends ViewGroup> extends ViewController {
 
-	public ParentController(final Activity activity, final String id) {
-		super(activity, id);
+	public ParentController(final Activity activity, final String id, Options initialOptions) {
+		super(activity, id, initialOptions);
 	}
 
 	@NonNull
 		return null;
 	}
 
+	@Override
+    public boolean containsComponent(ReactComponent component) {
+        if (super.containsComponent(component)) {
+            return true;
+        }
+        for (ViewController child : getChildControllers()) {
+            if (child.containsComponent(component)) return true;
+        }
+        return false;
+    }
+
+    @CallSuper
     public void applyOptions(Options options, ReactComponent childComponent) {
+        mergeChildOptions(options);
+    }
 
+    private void mergeChildOptions(Options options) {
+        this.options = this.options.mergeWith(options);
     }
 
 	@Override
 		}
 	}
 
+	@CallSuper
     void clearOptions() {
-
+	    applyOnParentController(parent -> ((ParentController) parent).clearOptions());
+        options = initialOptions.copy();
     }
 
     public void setupTopTabsWithViewPager(ViewPager viewPager) {
 
     }
+
+    public void clearTopTabs() {
+
+    }
 }

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

 import android.support.v4.widget.DrawerLayout;
 import android.view.Gravity;
 import android.view.View;
-import android.view.ViewGroup;
+
+import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.presentation.NavigationOptionsListener;
+import com.reactnativenavigation.presentation.SideMenuOptionsPresenter;
+import com.reactnativenavigation.views.ReactComponent;
 
 import java.util.ArrayList;
 import java.util.Collection;
 import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
 import static android.widget.ListPopupWindow.WRAP_CONTENT;
 
-public class SideMenuController extends ParentController {
+public class SideMenuController extends ParentController<DrawerLayout> implements NavigationOptionsListener {
 
 	private ViewController centerController;
 	private ViewController leftController;
 	private ViewController rightController;
 
-	public SideMenuController(final Activity activity, final String id) {
-		super(activity, id);
+	public SideMenuController(final Activity activity, final String id, Options initialOptions) {
+		super(activity, id, initialOptions);
 	}
 
 	@NonNull
 	@Override
-	protected ViewGroup createView() {
+	protected DrawerLayout createView() {
         return new DrawerLayout(getActivity());
 	}
 
-	@NonNull
+    @Override
+    public void sendOnNavigationButtonPressed(String buttonId) {
+        centerController.sendOnNavigationButtonPressed(buttonId);
+    }
+
+    @NonNull
 	@Override
 	public Collection<ViewController> getChildControllers() {
 		ArrayList<ViewController> children = new ArrayList<>();
 		return children;
 	}
 
-	public void setCenterController(ViewController centerController) {
+    @Override
+    public void applyOptions(Options options, ReactComponent childComponent) {
+        super.applyOptions(options, childComponent);
+        applyOnParentController(parentController ->
+                ((ParentController) parentController).applyOptions(this.options, childComponent)
+        );
+    }
+
+    @Override
+    public void mergeOptions(Options options) {
+        this.options = this.options.mergeWith(options);
+        new SideMenuOptionsPresenter(getView()).present(this.options.sideMenuRootOptions);
+        this.options = this.options.copy().clearSideMenuOptions();
+    }
+
+    public void setCenterController(ViewController centerController) {
 		this.centerController = centerController;
 		View childView = centerController.getView();
 		getView().addView(childView);

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

 import java.util.Collection;
 import java.util.Iterator;
 
+import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
+
 public class StackController extends ParentController <StackLayout> {
 
     private static final NoOpPromise NO_OP = new NoOpPromise();
     private final IdStack<ViewController> stack = new IdStack<>();
     private final NavigationAnimator animator;
-    private StackLayout stackLayout;
 
-    public StackController(final Activity activity, String id) {
-		super(activity, id);
+    public StackController(final Activity activity, String id, Options initialOptions) {
+        super(activity, id, initialOptions);
         animator = new NavigationAnimator(activity);
     }
 
     @RestrictTo(RestrictTo.Scope.TESTS)
     TopBar getTopBar() {
-        return stackLayout.getTopBar();
+        return getView().getTopBar();
     }
 
+    @RestrictTo(RestrictTo.Scope.TESTS)
+    StackLayout getStackLayout() {return getView();}
+
     @Override
     public void applyOptions(Options options, ReactComponent component) {
-        stackLayout.applyOptions(options, component);
+        super.applyOptions(options, component);
+        getView().applyOptions(this.options, component);
+        applyOnParentController(parentController ->
+                ((ParentController) parentController).applyOptions(this.options.copy().clearTopBarOptions(), component)
+        );
+        fabOptionsPresenter.applyOptions(options.fabOptions, component, getView());
+        animator.setOptions(options.animationsOptions);
     }
 
     @Override
     void clearOptions() {
-        stackLayout.clearOptions();
+        super.clearOptions();
+        getView().clearOptions();
     }
 
     public void push(ViewController child, final Promise promise) {
         child.setParentController(this);
         stack.push(child.getId(), child);
         View enteringView = child.getView();
-        getView().addView(enteringView);
+        getView().addView(enteringView, MATCH_PARENT, MATCH_PARENT);
 
         if (toRemove != null) {
             getView().removeView(toRemove.getView());
     }
 
     public void animatePush(final ViewController child, final Promise promise) {
-		final ViewController toRemove = stack.peek();
+        final ViewController toRemove = stack.peek();
 
 		child.setParentController(this);
 		stack.push(child.getId(), child);
 		View enteringView = child.getView();
-		getView().addView(enteringView);
+		getView().addView(enteringView, MATCH_PARENT, MATCH_PARENT);
 
-		if (toRemove != null) {
+        if (toRemove != null) {
             animator.animatePush(enteringView, () -> {
                 getView().removeView(toRemove.getView());
                 promise.resolve(child.getId());
             });
-		} else {
-			promise.resolve(child.getId());
-		}
-	}
+        } else {
+            promise.resolve(child.getId());
+        }
+    }
 
     void pop(final Promise promise) {
         if (!canPop()) {
             return;
         }
 
-        final ViewController poppedTop = stack.pop();
-        ViewController newTop = stack.peek();
+        final ViewController exitingController = stack.pop();
+        final ViewController enteringController = stack.peek();
+        popInternal(exitingController, enteringController);
 
-        View enteringView = newTop.getView();
-        final View exitingView = poppedTop.getView();
-        getView().addView(enteringView, getView().getChildCount() - 1);
-
-        finishPopping(exitingView, poppedTop, promise);
+        finishPopping(exitingController.getView(), exitingController, promise);
     }
 
-	private void animatePop(final Promise promise) {
+	void animatePop(final Promise promise) {
 		if (!canPop()) {
 			Navigator.rejectPromise(promise);
 			return;
 		}
 
-		final ViewController poppedTop = stack.pop();
-		ViewController newTop = stack.peek();
-
-		View enteringView = newTop.getView();
-		final View exitingView = poppedTop.getView();
-		getView().addView(enteringView, getView().getChildCount() - 1);
+		final ViewController exitingController = stack.pop();
+        final ViewController enteringController = stack.peek();
+        popInternal(exitingController, enteringController);
 
-        animator.animatePop(exitingView, () -> finishPopping(exitingView, poppedTop, promise));
+        animator.animatePop(exitingController.getView(), () -> finishPopping(exitingController.getView(), exitingController, promise));
 	}
 
+    private void popInternal(ViewController disappearing, ViewController appearing) {
+        disappearing.onViewWillDisappear();
+        appearing.onViewWillAppear();
+        getView().onChildWillDisappear(disappearing.options, appearing.options);
+        getView().addView(appearing.getView(), getView().indexOfChild(disappearing.getView()));
+    }
+
     boolean canPop() {
         return stack.size() > 1;
     }
         return false;
 	}
 
+    @Override
+    public void sendOnNavigationButtonPressed(String buttonId) {
+        peek().sendOnNavigationButtonPressed(buttonId);
+    }
+
     @NonNull
     @Override
     protected StackLayout createView() {
-        stackLayout = new StackLayout(getActivity());
-        return stackLayout;
+        return new StackLayout(getActivity(), this::sendOnNavigationButtonPressed);
     }
 
 	@NonNull
 
     @Override
     public void setupTopTabsWithViewPager(ViewPager viewPager) {
-        stackLayout.setupTopTabsWithViewPager(viewPager);
+        getView().initTopTabs(viewPager);
+    }
+
+    @Override
+    public void clearTopTabs() {
+        getView().clearTopTabs();
     }
 }

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

 package com.reactnativenavigation.viewcontrollers;
 
 import android.app.Activity;
+import android.support.annotation.CallSuper;
 import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
 import android.support.annotation.VisibleForTesting;
 import android.view.ViewTreeObserver;
 
 import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.presentation.FabOptionsPresenter;
 import com.reactnativenavigation.utils.CompatUtils;
 import com.reactnativenavigation.utils.StringUtils;
 import com.reactnativenavigation.utils.Task;
         boolean onViewDisappear(View view);
     }
 
+    Options initialOptions;
     public Options options;
 
     private final Activity activity;
     private boolean isShown;
     private boolean isDestroyed;
     private ViewVisibilityListener viewVisibilityListener = new ViewVisibilityListenerAdapter();
+    FabOptionsPresenter fabOptionsPresenter;
 
-    public ViewController(Activity activity, String id) {
+    public ViewController(Activity activity, String id, Options initialOptions) {
         this.activity = activity;
         this.id = id;
+        fabOptionsPresenter = new FabOptionsPresenter();
+        this.initialOptions = initialOptions;
+        options = initialOptions.copy();
     }
 
     protected abstract T createView();
         return isSameId(id) ? this : null;
     }
 
+    public boolean containsComponent(ReactComponent component) {
+        return getView().equals(component);
+    }
+
+    public void onViewWillAppear() {
+
+    }
+
     public void onViewAppeared() {
         isShown = true;
+        applyOptions(options);
         applyOnParentController(parentController -> {
             parentController.clearOptions();
-            parentController.applyOptions(options, (ReactComponent) getView());
+            if (getView() instanceof ReactComponent) parentController.applyOptions(options, (ReactComponent) getView());
         });
     }
 
+    public void onViewWillDisappear() {
+
+    }
+
     public void onViewDisappear() {
         isShown = false;
     }
 
+    @CallSuper
     public void destroy() {
         if (isShown) {
             isShown = false;
         }
     }
 
+    public abstract void sendOnNavigationButtonPressed(String buttonId);
+
     protected boolean isViewShown() {
         return !isDestroyed && getView().isShown();
     }

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

+package com.reactnativenavigation.viewcontrollers.bottomtabs;
+
+import android.support.annotation.IntRange;
+
+import com.reactnativenavigation.viewcontrollers.ViewController;
+import com.reactnativenavigation.views.ReactComponent;
+
+import java.util.List;
+
+public class BottomTabFinder {
+    private List<ViewController> tabs;
+
+    @IntRange(from = -1)
+    public int findByComponent(ReactComponent component) {
+        for (int i = 0; i < tabs.size(); i++) {
+            if (tabs.get(i).containsComponent(component)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    @IntRange(from = -1)
+    public int findByControllerId(String id) {
+        for (int i = 0; i < tabs.size(); i++) {
+            if (tabs.get(i).findControllerById(id) != null) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    void setTabs(List<ViewController> tabs) {
+        this.tabs = tabs;
+    }
+}

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

+package com.reactnativenavigation.viewcontrollers.bottomtabs;
+
+import android.app.Activity;
+import android.graphics.drawable.Drawable;
+import android.support.annotation.NonNull;
+import android.view.ViewGroup;
+import android.widget.RelativeLayout;
+
+import com.aurelhubert.ahbottomnavigation.AHBottomNavigation;
+import com.aurelhubert.ahbottomnavigation.AHBottomNavigationItem;
+import com.reactnativenavigation.parse.BottomTabOptions;
+import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.presentation.BottomTabsOptionsPresenter;
+import com.reactnativenavigation.presentation.NavigationOptionsListener;
+import com.reactnativenavigation.utils.ImageLoader;
+import com.reactnativenavigation.viewcontrollers.ParentController;
+import com.reactnativenavigation.viewcontrollers.ViewController;
+import com.reactnativenavigation.views.BottomTabs;
+import com.reactnativenavigation.views.ReactComponent;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
+import static android.view.ViewGroup.LayoutParams.WRAP_CONTENT;
+import static android.widget.RelativeLayout.ABOVE;
+import static android.widget.RelativeLayout.ALIGN_PARENT_BOTTOM;
+
+public class BottomTabsController extends ParentController implements AHBottomNavigation.OnTabSelectedListener, NavigationOptionsListener {
+	private BottomTabs bottomTabs;
+	private List<ViewController> tabs = new ArrayList<>();
+    private ImageLoader imageLoader;
+    private BottomTabFinder bottomTabFinder = new BottomTabFinder();
+
+    public BottomTabsController(final Activity activity, ImageLoader imageLoader, final String id, Options initialOptions) {
+		super(activity, id, initialOptions);
+        this.imageLoader = imageLoader;
+    }
+
+	@NonNull
+	@Override
+	protected ViewGroup createView() {
+		RelativeLayout root = new RelativeLayout(getActivity());
+		bottomTabs = new BottomTabs(getActivity());
+        bottomTabs.setOnTabSelectedListener(this);
+		RelativeLayout.LayoutParams lp = new RelativeLayout.LayoutParams(MATCH_PARENT, WRAP_CONTENT);
+		lp.addRule(ALIGN_PARENT_BOTTOM);
+		root.addView(bottomTabs, lp);
+		return root;
+	}
+
+    @Override
+    public void applyOptions(Options options) {
+        super.applyOptions(options);
+        new BottomTabsOptionsPresenter(bottomTabs, bottomTabFinder).present(options);
+    }
+
+    @Override
+    public void applyOptions(Options options, ReactComponent childComponent) {
+        super.applyOptions(options, childComponent);
+        int tabIndex = bottomTabFinder.findByComponent(childComponent);
+        if (tabIndex >= 0) new BottomTabsOptionsPresenter(bottomTabs, bottomTabFinder).present(this.options, tabIndex);
+        applyOnParentController(parentController ->
+                ((ParentController) parentController).applyOptions(this.options.copy().clearBottomTabsOptions().clearBottomTabOptions(), childComponent)
+        );
+    }
+
+    @Override
+	public boolean handleBack() {
+		return !tabs.isEmpty() && tabs.get(bottomTabs.getCurrentItem()).handleBack();
+	}
+
+    @Override
+    public void sendOnNavigationButtonPressed(String buttonId) {
+        getCurrentTab().sendOnNavigationButtonPressed(buttonId);
+    }
+
+    private ViewController getCurrentTab() {
+        return tabs.get(bottomTabs.getCurrentItem());
+    }
+
+    @Override
+    public boolean onTabSelected(int index, boolean wasSelected) {
+        if (wasSelected) return false;
+        selectTabAtIndex(index);
+        return true;
+	}
+	
+	public void setTabs(final List<ViewController> tabs) {
+		if (tabs.size() > 5) {
+			throw new RuntimeException("Too many tabs!");
+		}
+		this.tabs = tabs;
+        bottomTabFinder.setTabs(tabs);
+        getView();
+		for (int i = 0; i < tabs.size(); i++) {
+		    tabs.get(i).setParentController(this);
+			createTab(i, tabs.get(i).options.bottomTabOptions);
+		}
+		selectTabAtIndex(0);
+	}
+
+	private void createTab(int index, final BottomTabOptions tabOptions) {
+	    if (!tabOptions.icon.hasValue()) {
+            throw new RuntimeException("BottomTab must have an icon");
+        }
+        imageLoader.loadIcon(getActivity(), tabOptions.icon.get(), new ImageLoader.ImageLoadingListener() {
+            @Override
+            public void onComplete(@NonNull Drawable drawable) {
+                AHBottomNavigationItem item = new AHBottomNavigationItem(tabOptions.title.get(""), drawable);
+                bottomTabs.addItem(item);
+                bottomTabs.post(() -> bottomTabs.setTabTag(index, tabOptions.testId));
+            }
+
+            @Override
+            public void onError(Throwable error) {
+                error.printStackTrace();
+            }
+        });
+
+        RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT);
+        params.addRule(ABOVE, bottomTabs.getId());
+	}
+
+    public int getSelectedIndex() {
+		return bottomTabs.getCurrentItem();
+	}
+
+	@NonNull
+	@Override
+	public Collection<ViewController> getChildControllers() {
+		return tabs;
+	}
+
+	@Override
+	public void mergeOptions(Options options) {
+        this.options = this.options.mergeWith(options);
+        new BottomTabsOptionsPresenter(bottomTabs, bottomTabFinder).present(this.options);
+    }
+
+    public void selectTabAtIndex(final int newIndex) {
+        getView().removeView(getCurrentView());
+        bottomTabs.setCurrentItem(newIndex, false);
+        getView().addView(getCurrentView());
+    }
+
+    @NonNull
+    private ViewGroup getCurrentView() {
+        return tabs.get(bottomTabs.getCurrentItem()).getView();
+    }
+}

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

+package com.reactnativenavigation.viewcontrollers.modal;
+
+import android.app.Dialog;
+import android.content.DialogInterface;
+import android.view.KeyEvent;
+import android.view.View;
+
+import com.reactnativenavigation.R;
+import com.reactnativenavigation.viewcontrollers.ViewController;
+
+import static android.view.View.MeasureSpec.EXACTLY;
+import static android.view.View.MeasureSpec.makeMeasureSpec;
+
+public class Modal implements DialogInterface.OnKeyListener {
+    public final ViewController viewController;
+    private final Dialog dialog;
+
+    public Modal(final ViewController viewController) {
+        this.viewController = viewController;
+        dialog = new Dialog(viewController.getActivity(), R.style.Modal);
+        dialog.setOnKeyListener(this);
+    }
+
+    public void show() {
+        preMeasureView();
+        dialog.setContentView(viewController.getView());
+        dialog.show();
+    }
+
+    public void dismiss() {
+        dialog.dismiss();
+    }
+
+    public boolean containsDeepComponentId(String componentId) {
+        return viewController.findControllerById(componentId) != null;
+    }
+
+    private void preMeasureView() {
+        View decorView = viewController.getActivity().getWindow().getDecorView();
+        viewController.getView().measure(makeMeasureSpec(decorView.getMeasuredWidth(), EXACTLY), makeMeasureSpec(decorView.getMeasuredHeight(), EXACTLY));
+    }
+
+    @Override
+    public boolean onKey(DialogInterface dialog, int keyCode, KeyEvent event) {
+        if (keyCode == KeyEvent.KEYCODE_BACK) {
+            if (event.getAction() == KeyEvent.ACTION_UP) {
+                if (viewController.handleBack()) {
+                    return true;
+                }
+                dialog.dismiss();
+            }
+        }
+        return false;
+    }
+}

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

+package com.reactnativenavigation.viewcontrollers.modal;
+
+import com.reactnativenavigation.viewcontrollers.ViewController;
+
+public class ModalCreator {
+    public Modal create(ViewController viewController) {
+        return new Modal(viewController);
+    }
+}

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

 
     private List<ViewController> tabs;
     private TopTabsLayoutCreator viewCreator;
-    private Options options;
 
     public TopTabsController(Activity activity, String id, List<ViewController> tabs, TopTabsLayoutCreator viewCreator, Options options) {
-        super(activity, id);
+        super(activity, id, options);
         this.viewCreator = viewCreator;
-        this.options = options;
         this.tabs = tabs;
         for (ViewController tab : tabs) {
             tab.setParentController(this);
         performOnCurrentTab(ViewController::onViewAppeared);
     }
 
+    @Override
+    public void onViewWillDisappear() {
+        super.onViewWillDisappear();
+    }
+
     @Override
     public void onViewDisappear() {
         performOnCurrentTab(ViewController::onViewDisappear);
+        applyOnParentController(parentController -> ((ParentController) parentController).clearTopTabs());
+    }
+
+    @Override
+    public void sendOnNavigationButtonPressed(String buttonId) {
+        performOnCurrentTab(tab -> tab.sendOnNavigationButtonPressed(buttonId));
     }
 
     @Override
 
     @Override
     public void applyOptions(Options options, ReactComponent childComponent) {
-        applyOnParentController(parentController -> ((ParentController) parentController).applyOptions(options, childComponent));
+        super.applyOptions(options, childComponent);
+        applyOnParentController(parentController -> {
+                Options opt = this.options.copy();
+                ((ParentController) parentController).applyOptions(opt.clearTopTabOptions().clearTopTabsOptions(), childComponent);
+            }
+        );
     }
 
     @Override

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

+package com.reactnativenavigation.views;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.support.annotation.IntRange;
+
+import com.aurelhubert.ahbottomnavigation.AHBottomNavigation;
+import com.reactnativenavigation.parse.params.Text;
+import com.reactnativenavigation.utils.CompatUtils;
+
+@SuppressLint("ViewConstructor")
+public class BottomTabs extends AHBottomNavigation {
+    public BottomTabs(Context context) {
+        super(context);
+        setId(CompatUtils.generateViewId());
+        setContentDescription("BottomTabs");
+    }
+
+    public void setTabTag(int index, Text testId) {
+        if (!testId.hasValue()) return;
+        if (testId.hasValue()) getViewAtPosition(index).setTag(testId.get());
+        if (testId.hasValue()) getViewAtPosition(index).setContentDescription(testId.get());
+    }
+
+    public void setBadge(int bottomTabIndex, Text badge) {
+        setNotification(badge.get(), bottomTabIndex);
+    }
+
+    @Override
+    public void setCurrentItem(@IntRange(from = 0) int position) {
+        super.setCurrentItem(position);
+    }
+}

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

 		super(context);
 		this.reactView = reactView;
         addView(reactView.asView(), MATCH_PARENT, MATCH_PARENT);
+        setContentDescription("ComponentLayout");
         touchDelegate = new OverlayTouchDelegate(reactView);
     }
 
 
     @Override
     public void applyOptions(Options options) {
-        touchDelegate.setInterceptTouchOutside(options.overlayOptions.interceptTouchOutside == Options.BooleanOptions.True);
+        touchDelegate.setInterceptTouchOutside(options.overlayOptions.interceptTouchOutside.isTrue());
     }
 
     @Override
 
     @Override
     public void drawBehindTopBar() {
-        RelativeLayout.LayoutParams layoutParams = (RelativeLayout.LayoutParams) getLayoutParams();
-        layoutParams.removeRule(BELOW);
-        reactView.asView().setLayoutParams(layoutParams);
+        if (getParent() instanceof RelativeLayout) {
+            RelativeLayout.LayoutParams layoutParams = (RelativeLayout.LayoutParams) getLayoutParams();
+            layoutParams.removeRule(BELOW);
+            setLayoutParams(layoutParams);
+        }
     }
 
     @Override
     public void drawBelowTopBar(TopBar topBar) {
-        RelativeLayout.LayoutParams layoutParams = (RelativeLayout.LayoutParams) getLayoutParams();
-        layoutParams.addRule(BELOW, topBar.getId());
-        reactView.asView().setLayoutParams(layoutParams);
+        if (getParent() instanceof RelativeLayout) {
+            RelativeLayout.LayoutParams layoutParams = (RelativeLayout.LayoutParams) getLayoutParams();
+            layoutParams.addRule(BELOW, topBar.getId());
+            setLayoutParams(layoutParams);
+        }
     }
 
     @Override
 
     @Override
     public boolean onInterceptTouchEvent(MotionEvent ev) {
-        return touchDelegate.onInterceptTouchEvent(ev) || super.onInterceptTouchEvent(ev);
+        return touchDelegate.onInterceptTouchEvent(ev);
     }
 }

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

+package com.reactnativenavigation.views;
+
+import android.content.Context;
+import android.graphics.drawable.Drawable;
+import android.support.annotation.NonNull;
+
+import com.github.clans.fab.FloatingActionButton;
+import com.reactnativenavigation.anim.FabAnimator;
+import com.reactnativenavigation.anim.FabCollapseBehaviour;
+import com.reactnativenavigation.interfaces.ScrollEventListener;
+import com.reactnativenavigation.utils.ImageLoader;
+
+
+public class Fab extends FloatingActionButton implements FabAnimator {
+
+    private String id = "";
+    private FabCollapseBehaviour collapseBehaviour;
+
+    public Fab(Context context, String id) {
+        super(context);
+        collapseBehaviour = new FabCollapseBehaviour(this);
+        this.id = id;
+    }
+
+    public void applyIcon(String icon) {
+        new ImageLoader().loadIcon(getContext(), icon, new ImageLoader.ImageLoadingListener() {
+            @Override
+            public void onComplete(@NonNull Drawable drawable) {
+                setImageDrawable(drawable);
+            }
+
+            @Override
+            public void onError(Throwable error) {
+                error.printStackTrace();
+            }
+        });
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        Fab fab = (Fab) o;
+
+        return id.equals(fab.id);
+    }
+
+    @Override
+    public int hashCode() {
+        return id.hashCode();
+    }
+
+    @Override
+    public void show() {
+        show(true);
+    }
+
+    @Override
+    public void hide() {
+        hide(true);
+    }
+
+    public void enableCollapse(@NonNull ScrollEventListener scrollEventListener) {
+        collapseBehaviour.enableCollapse(scrollEventListener);
+    }
+
+    public void disableCollapse() {
+        collapseBehaviour.disableCollapse();
+    }
+
+    public String getFabId() {
+        return id;
+    }
+}

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

+package com.reactnativenavigation.views;
+
+import android.content.Context;
+
+import com.github.clans.fab.FloatingActionMenu;
+import com.reactnativenavigation.anim.FabAnimator;
+import com.reactnativenavigation.anim.FabCollapseBehaviour;
+import com.reactnativenavigation.interfaces.ScrollEventListener;
+
+import java.util.HashSet;
+
+
+public class FabMenu extends FloatingActionMenu implements FabAnimator {
+
+    private String id = "";
+    private HashSet<Fab> actions = new HashSet<>();
+
+    private FabCollapseBehaviour collapseBehaviour;
+
+    public FabMenu(Context context, String id) {
+        super(context);
+        this.id = id;
+        collapseBehaviour = new FabCollapseBehaviour(this);
+        onFinishInflate();
+        setOnMenuButtonClickListener(v -> toggle(true));
+    }
+
+    @Override
+    public void show() {
+        showMenu(true);
+    }
+
+    @Override
+    public void hide() {
+        hideMenu(true);
+    }
+
+    public void enableCollapse(ScrollEventListener scrollEventListener) {
+        collapseBehaviour.enableCollapse(scrollEventListener);
+    }
+
+    public void disableCollapse() {
+        collapseBehaviour.disableCollapse();
+    }
+
+    public HashSet<Fab> getActions() {
+        return actions;
+    }
+
+    public String getFabId() {
+        return id;
+    }
+}

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

 package com.reactnativenavigation.views;
 
+import android.annotation.SuppressLint;
 import android.content.Context;
 import android.support.annotation.RestrictTo;
 import android.support.v4.view.ViewPager;
 import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
 import static android.view.ViewGroup.LayoutParams.WRAP_CONTENT;
 
-public class StackLayout extends RelativeLayout implements TitleBarButton.OnClickListener {
+@SuppressLint("ViewConstructor")
+public class StackLayout extends RelativeLayout {
+    private TopBar topBar;
 
-    private final TopBar topBar;
-
-    public StackLayout(Context context) {
+    public StackLayout(Context context, TitleBarButton.OnClickListener topBarButtonClickListener) {
         super(context);
-        topBar = new TopBar(context, this);
+        topBar = new TopBar(context, topBarButtonClickListener, this);
         topBar.setId(CompatUtils.generateViewId());
         createLayout();
+        setContentDescription("StackLayout");
     }
 
     void createLayout() {
         addView(topBar, MATCH_PARENT, WRAP_CONTENT);
     }
 
-    @Override
-    public void onPress(String buttonId) {
-
-    }
-
     public void applyOptions(Options options, ReactComponent component) {
         new OptionsPresenter(topBar, component).applyOptions(options);
     }
 
-    @RestrictTo(RestrictTo.Scope.TESTS)
-    public TopBar getTopBar() {
-        return topBar;
+    public void onChildWillDisappear(Options disappearing, Options appearing) {
+        new OptionsPresenter(topBar).onChildWillDisappear(disappearing, appearing);
     }
 
     public void clearOptions() {
         topBar.clear();
     }
 
-    public void setupTopTabsWithViewPager(ViewPager viewPager) {
-        topBar.setupTopTabsWithViewPager(viewPager);
+    public void initTopTabs(ViewPager viewPager) {
+        topBar.initTopTabs(viewPager);
+    }
+
+    public void clearTopTabs() {
+        topBar.clearTopTabs();
+    }
+
+    @RestrictTo(RestrictTo.Scope.TESTS)
+    public TopBar getTopBar() {
+        return topBar;
+    }
+
+    @RestrictTo(RestrictTo.Scope.TESTS)
+    public void setTopBar(TopBar topBar) {
+        this.topBar = topBar;
     }
 }

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

 import android.graphics.Color;
 import android.graphics.drawable.Drawable;
 import android.support.annotation.NonNull;
+import android.support.v7.widget.ActionMenuView;
 import android.support.v7.widget.Toolbar;
 import android.text.Spannable;
 import android.text.SpannableString;
 import android.view.Menu;
 import android.view.MenuItem;
 import android.view.View;
+import android.widget.ImageButton;
 import android.widget.TextView;
 
-import com.reactnativenavigation.parse.Button;
-import com.reactnativenavigation.parse.Options;
-import com.reactnativenavigation.utils.ImageUtils;
+import com.reactnativenavigation.parse.params.Button;
+import com.reactnativenavigation.parse.params.Text;
+import com.reactnativenavigation.utils.ArrayUtils;
+import com.reactnativenavigation.utils.ImageLoader;
 import com.reactnativenavigation.utils.UiUtils;
+import com.reactnativenavigation.utils.ViewUtils;
 
 import java.util.ArrayList;
+import java.util.List;
 
 public class TitleBarButton implements MenuItem.OnMenuItemClickListener {
     public interface OnClickListener {
 	void addToMenu(Context context, final Menu menu) {
 		MenuItem menuItem = menu.add(button.title.get(""));
 		menuItem.setShowAsAction(button.showAsAction);
-		menuItem.setEnabled(button.disabled != Options.BooleanOptions.True);
+		menuItem.setEnabled(button.enabled.isTrueOrUndefined());
 		menuItem.setOnMenuItemClickListener(this);
 
 		if (hasIcon()) {
 			setTextColor();
 			setFontSize(menuItem);
 		}
-	}
 
-	void applyNavigationIcon(Context context) {
+        setTestId(button.testId);
+    }
+
+    void applyNavigationIcon(Context context) {
 		if (!hasIcon()) {
 			Log.w("RNN", "Left button needs to have an icon");
 			return;
 		}
 
-		ImageUtils.loadIcon(context, button.icon.get(), new ImageUtils.ImageLoadingListener() {
+		new ImageLoader().loadIcon(context, button.icon.get(), new ImageLoader.ImageLoadingListener() {
 			@Override
 			public void onComplete(@NonNull Drawable drawable) {
 				icon = drawable;
                 setIconColor();
                 setNavigationClickListener();
                 toolbar.setNavigationIcon(icon);
-			}
+                setLeftButtonTestId();
+            }
 
 			@Override
 			public void onError(Throwable error) {
 		});
 	}
 
-	private void applyIcon(Context context, final MenuItem menuItem) {
-		ImageUtils.loadIcon(context, button.icon.get(), new ImageUtils.ImageLoadingListener() {
+    private void setLeftButtonTestId() {
+        if (!button.testId.hasValue()) return;
+        toolbar.post(() -> {
+            ImageButton leftButton = ViewUtils.findChildByClass(toolbar, ImageButton.class);
+            if (leftButton != null) {
+                leftButton.setTag(button.testId.get());
+            }
+        });
+    }
+
+    private void applyIcon(Context context, final MenuItem menuItem) {
+        new ImageLoader().loadIcon(context, button.icon.get(), new ImageLoader.ImageLoadingListener() {
 			@Override
 			public void onComplete(@NonNull Drawable drawable) {
 				icon = drawable;
 	}
 
 	private void setIconColor() {
-		if (button.disabled == Options.BooleanOptions.False || button.disabled == Options.BooleanOptions.NoValue) {
+		if (button.enabled.isTrueOrUndefined()) {
 			UiUtils.tintDrawable(icon, button.buttonColor);
 			return;
 		}
-
-		if (button.disableIconTint == Options.BooleanOptions.True) {
+		if (button.disableIconTint.isTrue()) {
 			UiUtils.tintDrawable(icon, button.buttonColor);
 		} else {
 			UiUtils.tintDrawable(icon, Color.LTGRAY);
 
 	private void setTextColor() {
 		UiUtils.runOnPreDrawOnce(this.toolbar, () -> {
-            ArrayList<View> outViews = findActualTextViewInMenuByLabel();
+            ArrayList<View> outViews = findActualTextViewInMenuByText();
             setTextColorForFoundButtonViews(outViews);
         });
 	}
 		return true;
 	}
 
-	@NonNull
-	private ArrayList<View> findActualTextViewInMenuByLabel() {
-		ArrayList<View> outViews = new ArrayList<>();
-		this.toolbar.findViewsWithText(outViews, button.title.get(), View.FIND_VIEWS_WITH_TEXT);
-		return outViews;
-	}
-
 	private void setTextColorForFoundButtonViews(ArrayList<View> buttons) {
 		for (View button : buttons) {
 			((TextView) button).setTextColor(this.button.buttonColor);
 	}
 
 	private boolean hasIcon() {
-		return button.icon != null;
+		return button.icon.hasValue();
 	}
+
+    private void setTestId(Text testId) {
+        if (!testId.hasValue()) return;
+        UiUtils.runOnPreDrawOnce(this.toolbar, () -> {
+            ActionMenuView buttonsLayout = ViewUtils.findChildByClass(toolbar, ActionMenuView.class);
+            List<TextView> buttons = ViewUtils.findChildrenByClass(buttonsLayout, TextView.class);
+            for (TextView view : buttons) {
+                if (button.title.hasValue() && button.title.get().equals(view.getText())) {
+                    view.setTag(testId.get());
+                } else if (button.icon.hasValue() && ArrayUtils.contains(view.getCompoundDrawables(), icon)) {
+                    view.setTag(testId.get());
+                }
+            }
+        });
+    }
+
+    @NonNull
+    private ArrayList<View> findActualTextViewInMenuByText() {
+        ArrayList<View> outViews = new ArrayList<>();
+        this.toolbar.findViewsWithText(outViews, button.title.get(), View.FIND_VIEWS_WITH_TEXT);
+        return outViews;
+    }
 }

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

 import android.content.Context;
 import android.graphics.Typeface;
 import android.support.annotation.Nullable;
+import android.support.annotation.VisibleForTesting;
 import android.support.design.widget.AppBarLayout;
 import android.support.v4.view.ViewPager;
 import android.support.v7.widget.Toolbar;
 import com.reactnativenavigation.anim.TopBarAnimator;
 import com.reactnativenavigation.anim.TopBarCollapseBehavior;
 import com.reactnativenavigation.interfaces.ScrollEventListener;
-import com.reactnativenavigation.parse.Button;
-import com.reactnativenavigation.parse.Color;
-import com.reactnativenavigation.parse.Fraction;
-import com.reactnativenavigation.parse.Number;
-import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.parse.params.Button;
+import com.reactnativenavigation.parse.params.Color;
+import com.reactnativenavigation.parse.params.Fraction;
+import com.reactnativenavigation.parse.params.Number;
+import com.reactnativenavigation.parse.params.Bool;
 
 import java.util.ArrayList;
 
+import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
+import static android.view.ViewGroup.LayoutParams.WRAP_CONTENT;
+
 @SuppressLint("ViewConstructor")
 public class TopBar extends AppBarLayout implements ScrollEventListener.ScrollAwareView {
     private final Toolbar titleBar;
     private TitleBarButton.OnClickListener onClickListener;
     private final TopBarCollapseBehavior collapsingBehavior;
-    private final TopBarAnimator animator;
+    private TopBarAnimator animator;
     private TopTabs topTabs;
+    private StackLayout parentView;
 
-    public TopBar(final Context context, TitleBarButton.OnClickListener onClickListener) {
+    public TopBar(final Context context, TitleBarButton.OnClickListener onClickListener, StackLayout parentView) {
         super(context);
         this.onClickListener = onClickListener;
         collapsingBehavior = new TopBarCollapseBehavior(this);
         titleBar.getMenu();
         topTabs = new TopTabs(getContext());
         this.animator = new TopBarAnimator(this);
+        this.parentView = parentView;
         addView(titleBar);
     }
 
         return titleBar.getTitle() != null ? titleBar.getTitle().toString() : "";
     }
 
+    public void setTestId(String testId) {
+        setTag(testId);
+    }
+
     public void setTitleTextColor(Color color) {
         if (color.hasValue()) titleBar.setTitleTextColor(color.get());
     }
         topTabs.applyTopTabsFontSize(fontSize);
     }
 
+    public void setTopTabsVisible(boolean visible) {
+        topTabs.setVisibility(this, visible);
+    }
+
     public void setButtons(ArrayList<Button> leftButtons, ArrayList<Button> rightButtons) {
         setLeftButtons(leftButtons);
         setRightButtons(rightButtons);
         return titleBar;
     }
 
-    public void setupTopTabsWithViewPager(ViewPager viewPager) {
-        initTopTabs();
-        topTabs.setupWithViewPager(viewPager);
-    }
-
-    private void initTopTabs() {
+    public void initTopTabs(ViewPager viewPager) {
         topTabs = new TopTabs(getContext());
+        topTabs.init(viewPager);
         addView(topTabs);
     }
 
         collapsingBehavior.disableCollapse();
     }
 
-    public void show(Options.BooleanOptions animated) {
+    public void show(Bool animated) {
         if (getVisibility() == View.VISIBLE) {
             return;
         }
-        if (animated == Options.BooleanOptions.True) {
+        if (animated.isTrueOrUndefined()) {
             animator.show();
-        } else {
+        } else if (!animator.isRunning()) {
             setVisibility(View.VISIBLE);
         }
     }
 
-    public void hide(Options.BooleanOptions animated) {
+    public void hide(Bool animated) {
         if (getVisibility() == View.GONE) {
             return;
         }
-        if (animated == Options.BooleanOptions.True) {
+        if (animated.isTrueOrUndefined()) {
             animator.hide();
-        } else {
+        } else if (!animator.isRunning()){
             setVisibility(View.GONE);
         }
     }
 
+    @Override
+    public void setVisibility(int visibility) {
+        super.setVisibility(visibility);
+        if (visibility == View.GONE) {
+            this.parentView.removeView(this);
+        } else if (visibility == View.VISIBLE && this.getParent() == null) {
+            this.parentView.addView(this, MATCH_PARENT, WRAP_CONTENT);
+        }
+    }
+
     public void clear() {
         titleBar.setTitle(null);
         titleBar.setNavigationIcon(null);
         titleBar.getMenu().clear();
-        removeView(topTabs);
+    }
+
+    public void clearTopTabs() {
+        topTabs.clear(this);
+    }
+
+    @VisibleForTesting()
+    public TopTabs getTopTabs() {
+        return topTabs;
+    }
+
+    @VisibleForTesting
+    public void setAnimator(TopBarAnimator animator) {
+        this.animator = animator;
     }
 }