merged branch v2.0, master is the next release

.eslintrc

@@ -0,0 +1,529 @@
+{
+  "parser": "babel-eslint",
+  "env": {
+    "es6": true,
+    "node": true
+  },
+  "parserOptions": {
+    "ecmaVersion": 7,
+    "sourceType": "module",
+    "ecmaFeatures": {
+      "impliedStrict": true,
+      "jsx": true,
+      "experimentalObjectRestSpread": true
+    }
+  },
+  "plugins": [
+    "react",
+    "react-native",
+    "babel"
+  ],
+  "rules": {
+    /*
+     *                          possible errors
+     */
+    "comma-dangle": "error",
+    "no-cond-assign": [
+      "error",
+      "except-parens"
+    ],
+    "no-console": "warn",
+    "no-constant-condition": "error",
+    "no-control-regex": "error",
+    "no-debugger": "warn",
+    "no-dupe-args": "error",
+    "no-dupe-keys": "error",
+    "no-duplicate-case": "error",
+    "no-empty": "error",
+    "no-empty-character-class": "error",
+    "no-ex-assign": "error",
+    "no-extra-boolean-cast": "error",
+    "no-extra-parens": 0,
+    "no-extra-semi": "error",
+    "no-func-assign": "error",
+    "no-inner-declarations": "error",
+    "no-invalid-regexp": "error",
+    "no-irregular-whitespace": "error",
+    "no-negated-in-lhs": "error",
+    "no-obj-calls": "error",
+    "no-regex-spaces": "error",
+    "no-sparse-arrays": "error",
+    "no-unexpected-multiline": "error",
+    "no-unreachable": "error",
+    "use-isnan": "error",
+    "valid-jsdoc": 0,
+    "valid-typeof": "error",
+    /*
+     *                          best practices
+     */
+    "accessor-pairs": "warn",
+    "array-callback-return": 0,
+    "block-scoped-var": "error",
+    "complexity": 0,
+    "consistent-return": "error",
+    "curly": [
+      "error",
+      "all"
+    ],
+    "default-case": "error",
+    "dot-location": [
+      "error",
+      "property"
+    ],
+    "dot-notation": "error",
+    "eqeqeq": "error",
+    "guard-for-in": "error",
+    "no-alert": "error",
+    "no-caller": "error",
+    "no-case-declarations": "error",
+    "no-div-regex": 0,
+    "no-else-return": 0,
+    "no-empty-function": "error",
+    "no-empty-pattern": "error",
+    "no-eq-null": "error",
+    "no-eval": "error",
+    "no-extend-native": "error",
+    "no-extra-bind": "error",
+    "no-extra-label": "error",
+    "no-fallthrough": "error",
+    "no-floating-decimal": "error",
+    "no-implicit-coercion": "error",
+    "no-implicit-globals": 0,
+    "no-implied-eval": "error",
+    "no-invalid-this": 0,
+    "no-iterator": "error",
+    "no-labels": "error",
+    "no-lone-blocks": "error",
+    "no-loop-func": "error",
+    "no-magic-numbers": 0,
+    "no-multi-spaces": "error",
+    "no-multi-str": 0,
+    "no-native-reassign": "error",
+    "no-new": "error",
+    "no-new-func": "error",
+    "no-new-wrappers": "error",
+    "no-octal": "error",
+    "no-octal-escape": "error",
+    "no-param-reassign": "error",
+    "no-proto": "error",
+    "no-redeclare": 0,
+    "no-return-assign": "error",
+    "no-script-url": "error",
+    "no-self-assign": "error",
+    "no-self-compare": "error",
+    "no-sequences": "error",
+    "no-throw-literal": "error",
+    "no-unmodified-loop-condition": 0,
+    "no-unused-expressions": "error",
+    "no-unused-labels": 0,
+    "no-useless-call": "error",
+    "no-useless-concat": "error",
+    "no-void": "error",
+    "no-warning-comments": 0,
+    "no-with": "error",
+    "radix": 0,
+    "vars-on-top": 0,
+    "wrap-iife": "error",
+    "yoda": 0,
+    "strict": [
+      "error",
+      "never"
+    ],
+    /*
+     *                           variables
+     */
+    "init-declarations": 0,
+    "no-catch-shadow": "error",
+    "no-delete-var": "error",
+    "no-label-var": "error",
+    "no-restricted-globals": "error",
+    "no-shadow": "error",
+    "no-shadow-restricted-names": "error",
+    "no-undef": 0,
+    "no-undef-init": "error",
+    "no-undefined": 0,
+    "no-unused-vars": 0,
+    "no-use-before-define": 0,
+    /*
+     *                          Node.js
+     */
+    "callback-return": 0,
+    "global-require": 0,
+    "handle-callback-err": 0,
+    "no-mixed-requires": "error",
+    "no-new-require": "error",
+    "no-path-concat": "error",
+    "no-process-env": 0,
+    "no-process-exit": "error",
+    "no-restricted-modules": 0,
+    "no-sync": 0,
+    /*
+     *                          style
+     */
+    "array-bracket-spacing": [
+      "error",
+      "never"
+    ],
+    "block-spacing": "error",
+    "brace-style": [
+      "error",
+      "1tbs"
+    ],
+    "camelcase": [
+      "error",
+      {
+        "properties": "never"
+      }
+    ],
+    "comma-spacing": [
+      "error",
+      {
+        "before": false,
+        "after": true
+      }
+    ],
+    "comma-style": [
+      "error",
+      "last"
+    ],
+    "computed-property-spacing": [
+      "error",
+      "never"
+    ],
+    "consistent-this": [
+      "error",
+      "self"
+    ],
+    "eol-last": [
+      "error",
+      "unix"
+    ],
+    "func-names": 0,
+    "func-style": 0,
+    "id-blacklist": 0,
+    "id-length": 0,
+    "id-match": 0,
+    "indent": [
+      "error",
+      2,
+      {
+        "SwitchCase": 1
+      }
+    ],
+    "jsx-quotes": "error",
+    "key-spacing": [
+      "error",
+      {
+        "singleLine": {
+          "beforeColon": false,
+          "afterColon": true,
+          "mode": "strict"
+        },
+        "multiLine": {
+          "beforeColon": false,
+          "afterColon": true,
+          "mode": "strict"
+        }
+      }
+    ],
+    "keyword-spacing": [
+      "error",
+      {
+        "before": true,
+        "after": true
+      }
+    ],
+    "linebreak-style": [
+      "error",
+      "unix"
+    ],
+    "lines-around-comment": 0,
+    "max-depth": [
+      "error",
+      4
+    ],
+    "max-len": [
+      "warn",
+      150
+    ],
+    "max-nested-callbacks": [
+      "error",
+      4
+    ],
+    "max-params": [
+      "error",
+      6
+    ],
+    "max-statements": [
+      "error",
+      15,
+      {
+        "ignoreTopLevelFunctions": true
+      }
+    ],
+    "new-cap": [
+      "error",
+      {
+        "capIsNewExceptions": [
+          "Immutable"
+        ]
+      }
+    ],
+    "new-parens": "error",
+    "newline-after-var": 0,
+    "newline-before-return": 0,
+    "newline-per-chained-call": 0,
+    "no-array-constructor": "error",
+    "no-bitwise": 0,
+    "no-continue": 0,
+    "no-inline-comments": 0,
+    "no-lonely-if": "error",
+    "no-mixed-spaces-and-tabs": 0,
+    "no-multiple-empty-lines": [
+      "error",
+      {
+        "max": 1
+      }
+    ],
+    "no-negated-condition": 0,
+    "no-nested-ternary": "error",
+    "no-new-object": "error",
+    "no-plusplus": 0,
+    "no-restricted-syntax": 0,
+    "no-spaced-func": "error",
+    "no-ternary": 0,
+    "no-trailing-spaces": [
+      "error",
+      {
+        "skipBlankLines": true
+      }
+    ],
+    "no-underscore-dangle": 0,
+    "no-unneeded-ternary": "error",
+    "no-whitespace-before-property": "error",
+    "object-curly-spacing": [
+      "error",
+      "never"
+    ],
+    "one-var": 0,
+    "one-var-declaration-per-line": 0,
+    "operator-assignment": 0,
+    "operator-linebreak": [
+      "error",
+      "before"
+    ],
+    "padded-blocks": [
+      "error",
+      "never"
+    ],
+    "quote-props": [
+      "error",
+      "consistent-as-needed"
+    ],
+    "quotes": 0,
+    "require-jsdoc": 0,
+    "semi": [
+      "error",
+      "always"
+    ],
+    "semi-spacing": [
+      "error",
+      {
+        "before": false,
+        "after": true
+      }
+    ],
+    "sort-imports": 0,
+    "sort-vars": 0,
+    "space-before-blocks": [
+      "error",
+      "always"
+    ],
+    "space-before-function-paren": [
+      "error",
+      "never"
+    ],
+    "space-in-parens": [
+      "error",
+      "never"
+    ],
+    "space-infix-ops": "error",
+    "space-unary-ops": "error",
+    "spaced-comment": 0,
+    "wrap-regex": "error",
+    /*
+     *                             ECMAScript 6
+     */
+    "arrow-body-style": 0,
+    "arrow-parens": 0,
+    "arrow-spacing": [
+      "error",
+      {
+        "before": true,
+        "after": true
+      }
+    ],
+    "constructor-super": "error",
+    "generator-star-spacing": 0,
+    "no-class-assign": "error",
+    "no-confusing-arrow": "error",
+    "no-const-assign": "error",
+    "no-dupe-class-members": "error",
+    "no-new-symbol": "error",
+    "no-restricted-imports": 0,
+    "no-this-before-super": "error",
+    "no-useless-constructor": 0,
+    "no-var": "error",
+    "object-shorthand": 0,
+    "prefer-arrow-callback": 0,
+    "prefer-const": "error",
+    "prefer-reflect": 0,
+    "prefer-rest-params": "error",
+    "prefer-spread": "error",
+    "prefer-template": 0,
+    "require-yield": 0,
+    "template-curly-spacing": [
+      "error",
+      "never"
+    ],
+    "yield-star-spacing": [
+      "error",
+      "after"
+    ],
+    /*
+     *                              react plugin
+     */
+    "react/display-name": 0,
+    "react/forbid-prop-types": [
+      "error",
+      {
+        "forbid": [
+          "any"
+        ]
+      }
+    ],
+    "react/no-danger": "error",
+    "react/no-deprecated": "error",
+    "react/no-did-mount-set-state": [
+      "error",
+      "allow-in-func"
+    ],
+    "react/no-did-update-set-state": [
+      "error",
+      "allow-in-func"
+    ],
+    "react/no-direct-mutation-state": "error",
+    "react/no-is-mounted": "error",
+    "react/no-multi-comp": "error",
+    "react/no-set-state": 0,
+    "react/no-string-refs": 0,
+    "react/no-unknown-property": 0,
+    "react/prefer-es6-class": [
+      "error",
+      "always"
+    ],
+    "react/prefer-stateless-function": 0,
+    "react/prop-types": "error",
+    "react/react-in-jsx-scope": "error",
+    "react/require-extension": 0,
+    "react/self-closing-comp": "error",
+    "react/sort-comp": [
+      "error",
+      {
+        "order": [
+          "static-methods",
+          "lifecycle",
+          "/^on.+$/",
+          "/^(get|set)(?!(InitialState$|DefaultProps$|ChildContext$)).+$/",
+          "everything-else",
+          "/^render.+$/",
+          "render"
+        ]
+      }
+    ],
+    "react/sort-prop-types": 0,
+    "react/wrap-multilines": "error",
+    "react/jsx-boolean-value": [
+      "error",
+      "always"
+    ],
+    "react/jsx-closing-bracket-location": "error",
+    "react/jsx-curly-spacing": [
+      "error",
+      "never"
+    ],
+    "react/jsx-equals-spacing": [
+      "error",
+      "never"
+    ],
+    "react/jsx-handler-names": [
+      "error",
+      {
+        "eventHandlerPropPrefix": "handle"
+      }
+    ],
+    "react/jsx-indent-props": [
+      0,
+      2
+    ],
+    "react/jsx-indent": [
+      "error",
+      2
+    ],
+    "react/jsx-key": "error",
+    "react/jsx-max-props-per-line": [
+      "error",
+      {
+        "maximum": 2
+      }
+    ],
+    "react/jsx-no-bind": 0,
+    "react/jsx-no-duplicate-props": [
+      "error",
+      {
+        "ignoreCase": true
+      }
+    ],
+    "react/jsx-no-literals": "error",
+    "react/jsx-no-undef": "error",
+    "react/jsx-pascal-case": "error",
+    "react/jsx-sort-props": 0,
+    "react/jsx-space-before-closing": 0,
+    "react/jsx-uses-react": "error",
+    "react/jsx-uses-vars": "error",
+    /*
+     *                              react-native plugin
+     */
+    "react-native/no-unused-styles": "error",
+    "react-native/split-platform-components": "error",
+    /*
+     *                              babel plugin
+     */
+    "babel/generator-star-spacing": [
+      "error",
+      "after"
+    ],
+    "babel/new-cap": [
+      "error",
+      {
+        "capIsNewExceptions": [
+          "Immutable"
+        ]
+      }
+    ],
+    "babel/array-bracket-spacing": [
+      "error",
+      "never"
+    ],
+    "babel/object-curly-spacing": [
+      "error",
+      "never"
+    ],
+    "babel/object-shorthand": 0,
+    "babel/arrow-parens": [
+      "error",
+      "always"
+    ],
+    "babel/no-await-in-loop": 0
+  }
+}

.watchmanconfig

@@ -0,0 +1,15 @@
+{
+  "ignore_dirs": [
+    ".git",
+    "node_modules",
+    ".gradle",
+    ".idea",
+    "gradle",
+    "build",
+    "example",
+    "example-redux",
+    "android/.gradle",
+    "android/gradle",
+    "android/app/build"
+  ]
+}

RELEASES.md → CHANGELOG.md

@@ -5,3 +5,7 @@
 * **Breaking change:** in order to handle nav button press events, you now need to register your event handler explicitly. Until now, you've just had to have `onNavigatorEvent(event)` method on your screen component. From now on, explicitly register your handler with `navigator.setOnNavigatorEvent(this.onNavigatorEvent.bind(this));`. A good place to do this is in your screen's constructor. See the example for an example.
 * Simplified API significantly. You now don't need to have your screen components extend `Screen`. You can leave them extending React's traditional `Component`. When you register your screen, instead of using `Navigation.registerScreen` directly, you can now use `Navigation.registerComponent`. This wrapper will wrap your regular component with a `Screen` automatically and pass the navigator instance through props. The benefit of this change is that your screen components now have *zero(!)* references to react-native-navigation. All of the changes required by this package are now purely concentrated in one place - your app bootstrap.
 * Added redux example and optional redux support
+
+### 2.0.0
+
+* Android native code redesign

README.md

@@ -68,11 +68,90 @@ For example, this package replaces the native [NavigatorIOS](https://facebook.gi
 }
 ```
 
-3. Have your `MainActivity.java` extend `com.reactnativenavigation.activities.RootActivity`. 
-`RootActivity` is used as a proxy activity to start your actuall app.
+3. Your `MainActivity` should extend `com.reactnativenavigation.controllers.SplashActivity` instead of `ReactActivity`. If you have any `react-native` related methods in your `MainActivity` you can safely delete them.
 
-	The only method you might need to override is `getPackages()`, make sure you add `RnnPackage` as well.
+4. Create a custom Application class and update the `Application` element in `AndroidManifest.xml`
+	
+	```java
+	import com.reactnativenavigation.NavigationApplication;
+	
+	public class MyApplication extends NavigationApplication {
+	
+	}
+	```
+	
+	```xml
+	<application
+        android:name=".MyApplication"
+        ...
+        />
+	```
+5. Implement `isDebug` and `createAdditionalReactPackages` methods
+
+	```java
+	import com.reactnativenavigation.NavigationApplication;
+	
+	public class MyApplication extends NavigationApplication {
+ 
+    	@Override
+		public boolean isDebug() {
+			// Make sure you are using BuildConfig from your own application
+			return BuildConfig.DEBUG;
+		}
+
+	    @NonNull
+	    @Override
+	    public List<ReactPackage> createAdditionalReactPackages() {
+		    // Add the packages you require here.
+			// No need to add RnnPackage and MainReactPackage
+	        return null;
+	    }
+	}
+	```
+
+## Migrating to version 2.0
+Migrating your code base to version 2.0 will require a few changes to your native Java code. The actual navigation API has not changed so there will be no changes to your JS code base.
 
+* Your `MainActivity` should now extend `com.reactnativenavigation.controllers.SplashActivity`
+* Delete the `getPackages()` from `MainActivity`. Don't forget to delete unused imports after this step.
+* Create a custom Application class and update the `Application` element in `AndroidManifest.xml`
+	
+	```java
+	import com.reactnativenavigation.NavigationApplication;
+	
+	public class MyApplication extends NavigationApplication {
+	
+	}
+	```
+	
+	```xml
+	<application
+        android:name=".MyApplication"
+        ...
+        />
+	```
+* Implement `isDebug` and `createAdditionalReactPackages`
+
+	```java
+	import com.reactnativenavigation.NavigationApplication;
+	
+	public class MyApplication extends NavigationApplication {
+ 
+    	@Override
+		public boolean isDebug() {
+			// Make sure you are using BuildConfig from your own application
+			return BuildConfig.DEBUG;
+		}
+
+	    @NonNull
+	    @Override
+	    public List<ReactPackage> createAdditionalReactPackages() {
+		    // Add the packages you require here.
+			// No need to add RnnPackage and MainReactPackage
+	        return null;
+	    }
+	}
+	```
 
 ## Usage
 

android/app/build.gradle

@@ -24,6 +24,9 @@ android {
             minifyEnabled false
         }
     }
+    lintOptions {
+        abortOnError false
+    }
 }
 
 repositories {
@@ -33,10 +36,22 @@ repositories {
     }
 }
 
+allprojects { p ->
+    p.tasks.whenTaskAdded { task ->
+        if (task.name.toLowerCase().contains('lint')) {
+            task.enabled = false;
+        }
+    }
+}
+
 dependencies {
     compile fileTree(dir: "libs", include: ["*.jar"])
-    compile "com.aurelhubert:ahbottomnavigation:1.2.3"
+    compile "com.aurelhubert:ahbottomnavigation:1.3.3"
     compile "com.android.support:appcompat-v7:23.0.1"
     compile 'com.android.support:design:23.1.1'
     compile "com.facebook.react:react-native:+"  // From node_modules
+    compile 'com.balysv.materialmenu:material-menu-toolbar:1.5.4'
+
+    testCompile "junit:junit:4.12"
+    testCompile "org.robolectric:robolectric:3.1.1"
 }

android/app/src/main/AndroidManifest.xml

@@ -2,11 +2,7 @@
     package="com.reactnativenavigation">
 
     <application>
-        <activity android:name="com.reactnativenavigation.activities.TabActivity" />
-        <activity android:name="com.reactnativenavigation.activities.BottomTabActivity"
-                  android:label=""/>
-        <activity android:name="com.reactnativenavigation.activities.SingleScreenActivity"
-                  android:label=""/>
+        <activity android:name=".controllers.NavigationActivity" />
     </application>
 
 </manifest>

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

@@ -0,0 +1,96 @@
+package com.reactnativenavigation;
+
+import android.app.Application;
+import android.os.Handler;
+import android.support.annotation.Nullable;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.WritableMap;
+import com.reactnativenavigation.react.NavigationReactGateway;
+import com.reactnativenavigation.react.ReactGateway;
+
+import java.util.List;
+
+public abstract class NavigationApplication extends Application {
+
+    public static NavigationApplication instance;
+
+    private ReactGateway reactGateway;
+    private Handler handler;
+
+    @Override
+    public void onCreate() {
+        super.onCreate();
+        instance = this;
+        reactGateway = new NavigationReactGateway();
+        handler = new Handler(getMainLooper());
+    }
+
+    public void startReactContext() {
+        reactGateway.startReactContextOnceInBackgroundAndExecuteJS();
+    }
+
+    public void runOnMainThread(Runnable runnable) {
+        handler.post(runnable);
+    }
+
+    public void runOnMainThread(Runnable runnable, long delay) {
+        handler.postDelayed(runnable, delay);
+    }
+
+    public ReactGateway getReactGateway() {
+        return reactGateway;
+    }
+
+    public boolean isReactContextInitialized() {
+        return reactGateway.isInitialized();
+    }
+
+    public void onReactInitialized(ReactContext reactContext) {
+        // nothing
+    }
+
+    public String getJsEntryFileName() {
+        return "index.android";
+    }
+
+    public String getBundleAssetName() {
+        return "index.android.bundle";
+    }
+
+    public abstract boolean isDebug();
+
+    @Nullable
+    public abstract List<ReactPackage> createAdditionalReactPackages();
+
+    //TODO move all these navigator junk elsewhere
+    public void sendNavigatorEvent(String eventId, String navigatorEventId) {
+        if (!isReactContextInitialized()) {
+            return;
+        }
+        reactGateway.getReactEventEmitter().sendNavigatorEvent(eventId, navigatorEventId);
+    }
+
+    public void sendNavigatorEvent(String eventId, String navigatorEventId, WritableMap data) {
+        if (!isReactContextInitialized()) {
+            return;
+        }
+        reactGateway.getReactEventEmitter().sendNavigatorEvent(eventId, navigatorEventId, data);
+    }
+
+    public void sendEvent(String eventId, String navigatorEventId) {
+        if (!isReactContextInitialized()) {
+            return;
+        }
+        reactGateway.getReactEventEmitter().sendEvent(eventId, navigatorEventId);
+    }
+
+    public void sendNavigatorEvent(String eventId, WritableMap arguments) {
+        if (!isReactContextInitialized()) {
+            return;
+        }
+        reactGateway.getReactEventEmitter().sendEvent(eventId, arguments);
+    }
+
+}

android/app/src/main/java/com/reactnativenavigation/activities/BaseReactActivity.java

@@ -1,470 +0,0 @@
-package com.reactnativenavigation.activities;
-
-import android.content.Intent;
-import android.content.res.Configuration;
-import android.os.Build;
-import android.os.Bundle;
-import android.os.Handler;
-import android.provider.Settings;
-import android.support.annotation.CallSuper;
-import android.support.v4.widget.DrawerLayout;
-import android.support.v7.app.ActionBarDrawerToggle;
-import android.support.v7.app.AppCompatActivity;
-import android.util.Log;
-import android.view.KeyEvent;
-import android.view.Menu;
-import android.view.MenuItem;
-import android.widget.EditText;
-import android.widget.FrameLayout;
-import android.widget.Toast;
-
-import com.facebook.common.logging.FLog;
-import com.facebook.react.ReactInstanceManager;
-import com.facebook.react.ReactPackage;
-import com.facebook.react.ReactRootView;
-import com.facebook.react.bridge.Arguments;
-import com.facebook.react.bridge.ReadableMap;
-import com.facebook.react.bridge.WritableMap;
-import com.facebook.react.common.ReactConstants;
-import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
-import com.facebook.react.shell.MainReactPackage;
-import com.reactnativenavigation.BuildConfig;
-import com.reactnativenavigation.controllers.ModalController;
-import com.reactnativenavigation.core.RctManager;
-import com.reactnativenavigation.core.objects.Button;
-import com.reactnativenavigation.core.objects.Drawer;
-import com.reactnativenavigation.core.objects.Screen;
-import com.reactnativenavigation.modal.RnnModal;
-import com.reactnativenavigation.packages.RnnPackage;
-import com.reactnativenavigation.utils.ContextProvider;
-import com.reactnativenavigation.utils.StyleHelper;
-import com.reactnativenavigation.views.RnnToolBar;
-import com.reactnativenavigation.views.ScreenStack;
-
-import java.util.Arrays;
-import java.util.List;
-
-import javax.annotation.Nullable;
-
-public abstract class BaseReactActivity extends AppCompatActivity implements DefaultHardwareBackBtnHandler {
-
-    protected static final String KEY_ANIMATED = "animated";
-    protected static final String KEY_BADGE = "badge";
-    protected static final String KEY_HIDDEN = "hidden";
-    protected static final String KEY_SIDE = "side";
-    protected static final String KEY_TAB_INDEX = "tabIndex";
-    protected static final String KEY_TITLE = "title";
-    protected static final String KEY_TO = "to";
-    protected static final String KEY_NAVIGATOR_ID = "navigatorID";
-
-    private static final String TAG = "BaseReactActivity";
-    private static final String REDBOX_PERMISSION_MESSAGE =
-            "Overlay permissions needs to be granted in order for react native apps to run in dev mode";
-
-    @Nullable
-    protected ReactInstanceManager mReactInstanceManager;
-    private boolean mDoRefresh = false;
-    private Menu mMenu;
-    protected RnnToolBar mToolbar;
-    protected ActionBarDrawerToggle mDrawerToggle;
-    protected DrawerLayout mDrawerLayout;
-    protected ScreenStack mDrawerStack;
-
-    /**
-     * Returns the name of the bundle in assets. If this is null, and no file path is specified for
-     * the bundle, the app will only work with {@code getUseDeveloperSupport} enabled and will
-     * always try to load the JS bundle from the packager server.
-     * e.g. "index.android.bundle"
-     */
-    @Nullable
-    public String getBundleAssetName() {
-        return "index.android.bundle";
-    }
-
-    /**
-     * Returns a custom path of the bundle file. This is used in cases the bundle should be loaded
-     * from a custom path. By default it is loaded from Android assets, from a path specified
-     * by {getBundleAssetName}.
-     * e.g. "file://sdcard/myapp_cache/index.android.bundle"
-     */
-    @Nullable
-    public String getJSBundleFile() {
-        return null;
-    }
-
-    /**
-     * Returns the name of the main module. Determines the URL used to fetch the JS bundle
-     * from the packager server. It is only used when dev support is enabled.
-     * This is the first file to be executed once the {@link ReactInstanceManager} is created.
-     * e.g. "index.android"
-     */
-    public String getJSMainModuleName() {
-        return "index.android";
-    }
-
-    /**
-     * Returns the launchOptions which will be passed to the {@link ReactInstanceManager}
-     * when the application is started. By default, this will return null and an empty
-     * object will be passed to your top level component as its initial props.
-     * If your React Native application requires props set outside of JS, override
-     * this method to return the Android.os.Bundle of your desired initial props.
-     */
-    @Nullable
-    protected Bundle getLaunchOptions() {
-        return null;
-    }
-
-    /**
-     * Returns the name of the main component registered from JavaScript.
-     * This is used to schedule rendering of the component.
-     * e.g. "MoviesApp"
-     */
-    protected String getMainComponentName() {
-        return "";
-    }
-
-    /**
-     * Returns whether dev mode should be enabled. This enables e.g. the dev menu.
-     */
-    public boolean getUseDeveloperSupport() {
-        return BuildConfig.DEBUG;
-    }
-
-    /**
-     * Returns a list of {@link ReactPackage} used by the app.
-     * You'll most likely want to return at least the {@code MainReactPackage}.
-     * If your app uses additional views or modules besides the default ones,
-     * you'll want to include more packages here.
-     */
-    public List<ReactPackage> getPackages() {
-        return Arrays.asList(
-                new MainReactPackage(),
-                new RnnPackage()
-        );
-    }
-
-    /**
-     * A subclass may override this method if it needs to use a custom {@link ReactRootView}.
-     */
-    protected ReactRootView createRootView() {
-        return new ReactRootView(this);
-    }
-
-    @Override
-    protected void onCreate(Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-        ContextProvider.setActivityContext(this);
-        mReactInstanceManager = createReactInstanceManager();
-        handleOnCreate();
-
-    }
-
-    /**
-     * A subclass may override this method if it needs to use a custom instance.
-     */
-    protected ReactInstanceManager createReactInstanceManager() {
-        return getReactInstanceManager();
-    }
-
-    protected ReactInstanceManager getReactInstanceManager() {
-        RctManager rctManager = RctManager.getInstance();
-        if (!rctManager.isInitialized()) {
-            rctManager.init(this);
-        }
-        return rctManager.getReactInstanceManager();
-    }
-
-    @CallSuper
-    protected void handleOnCreate() {
-        permissionToShowRedboxIfNeeded();
-    }
-
-    private void permissionToShowRedboxIfNeeded() {
-        if (getUseDeveloperSupport() && Build.VERSION.SDK_INT >= 23 && !Settings.canDrawOverlays(this)) {
-            Intent serviceIntent = new Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION);
-            startActivity(serviceIntent);
-            FLog.w(ReactConstants.TAG, REDBOX_PERMISSION_MESSAGE);
-            Toast.makeText(this, REDBOX_PERMISSION_MESSAGE, Toast.LENGTH_LONG).show();
-        }
-    }
-
-    @Override
-    protected void onResume() {
-        super.onResume();
-        ContextProvider.setActivityContext(this);
-
-        if (mReactInstanceManager != null) {
-            mReactInstanceManager.onHostResume(this, this);
-        }
-    }
-
-    @Override
-    protected void onPause() {
-        super.onPause();
-
-        if (mReactInstanceManager != null) {
-            mReactInstanceManager.onHostPause();
-        }
-
-        ContextProvider.clearActivityContext();
-    }
-
-    @Override
-    protected void onDestroy() {
-        super.onDestroy();
-
-        // Destroy react instance manager only if there are no resumed react activities
-        BaseReactActivity activity = ContextProvider.getActivityContext();
-        if (mReactInstanceManager != null && (activity == null || activity.isFinishing())) {
-            Log.i(TAG, "Destroying ReactInstanceManager");
-            mReactInstanceManager.onHostDestroy();
-            RctManager.getInstance().onDestroy();
-        } else {
-            Log.d(TAG, "Not destroying ReactInstanceManager");
-        }
-    }
-
-    @CallSuper
-    public void push(Screen screen) {
-        StyleHelper.updateStyles(mToolbar, screen);
-        if (mToolbar != null) {
-            mToolbar.update(screen);
-
-            if (getCurrentNavigatorId().equals(screen.navigatorId) &&
-                    getScreenStackSize() >= 1) {
-                mToolbar.setNavUpButton(screen);
-            }
-        }
-    }
-
-    @CallSuper
-    public Screen pop(String navigatorId) {
-        if (mToolbar != null &&
-                getCurrentNavigatorId().equals(navigatorId) &&
-                getScreenStackSize() <= 2) {
-            mToolbar.setNavUpButton();
-        }
-
-        return null;
-    }
-
-    @CallSuper
-    public Screen popToRoot(String navigatorId) {
-        if (mToolbar != null) {
-            mToolbar.setNavUpButton();
-        }
-
-        return null;
-    }
-
-    @CallSuper
-    public Screen resetTo(Screen screen) {
-        StyleHelper.updateStyles(mToolbar, screen);
-        if (mToolbar != null) {
-            mToolbar.setNavUpButton();
-        }
-
-        return null;
-    }
-
-    protected abstract String getCurrentNavigatorId();
-
-    @CallSuper
-    public Screen getCurrentScreen() {
-        ModalController modalController = ModalController.getInstance();
-        if (modalController.isModalDisplayed()) {
-            RnnModal modal = modalController.get();
-            assert modal != null;
-            return modal.getCurrentScreen();
-        }
-
-        return null;
-    }
-
-    public abstract int getScreenStackSize();
-
-    @Override
-    public void onConfigurationChanged(Configuration newConfig) {
-        super.onConfigurationChanged(newConfig);
-        if (mDrawerToggle != null) {
-            mDrawerToggle.onConfigurationChanged(newConfig);
-        }
-    }
-
-    @Override
-    public boolean onCreateOptionsMenu(Menu menu) {
-        mMenu = menu;
-        Screen currentScreen = getCurrentScreen();
-        if (mToolbar != null && currentScreen != null && !isFinishing()) {
-            mToolbar.setupToolbarButtonsAsync(currentScreen);
-        }
-        return super.onCreateOptionsMenu(menu);
-    }
-
-    @Override
-    public boolean onOptionsItemSelected(MenuItem item) {
-        if (mDrawerToggle != null &&
-                getScreenStackSize() == 1 &&
-                mDrawerToggle.onOptionsItemSelected(item)) {
-            return true;
-        }
-
-        if (item.getItemId() == android.R.id.home) {
-            onBackPressed();
-        } else {
-            String eventId = Button.getButtonEventId(item);
-            assert eventId != null;
-
-            WritableMap params = Arguments.createMap();
-            RctManager.getInstance().sendEvent(eventId, getCurrentScreen(), params);
-        }
-        return super.onOptionsItemSelected(item);
-    }
-
-    @Override
-    public void onPostCreate(Bundle savedInstanceState) {
-        super.onPostCreate(savedInstanceState);
-        if (mDrawerToggle != null) {
-            mDrawerToggle.syncState();
-        }
-    }
-
-    public Menu getMenu() {
-        return mMenu;
-    }
-
-    @Override
-    public void onActivityResult(int requestCode, int resultCode, Intent data) {
-        if (mReactInstanceManager != null) {
-            mReactInstanceManager.onActivityResult(requestCode, resultCode, data);
-        }
-    }
-
-    @Override
-    public boolean onKeyUp(int keyCode, KeyEvent event) {
-        if (mReactInstanceManager != null &&
-                mReactInstanceManager.getDevSupportManager().getDevSupportEnabled()) {
-            if (keyCode == KeyEvent.KEYCODE_MENU) {
-                mReactInstanceManager.showDevOptionsDialog();
-                return true;
-            }
-            if (keyCode == KeyEvent.KEYCODE_R && !(getCurrentFocus() instanceof EditText)) {
-                // Enable double-tap-R-to-reload
-                if (mDoRefresh) {
-                    mReactInstanceManager.getDevSupportManager().handleReloadJS();
-                    mDoRefresh = false;
-                } else {
-                    mDoRefresh = true;
-                    new Handler().postDelayed(
-                            new Runnable() {
-                                @Override
-                                public void run() {
-                                    mDoRefresh = false;
-                                }
-                            },
-                            200);
-                }
-            }
-        }
-        return super.onKeyUp(keyCode, event);
-    }
-
-    /**
-     * Called after bundle was reloaded. This is a good chance to clean up previously connected react views.
-     */
-    public void onJSBundleReloaded() {
-        removeAllReactViews();
-    }
-
-    protected abstract void removeAllReactViews();
-
-    @Override
-    public void onBackPressed() {
-        ModalController modalController = ModalController.getInstance();
-        if (modalController.isModalDisplayed()) {
-            modalController.dismissModal();
-            return;
-        }
-
-        if (getScreenStackSize() > 1) {
-            pop(getCurrentNavigatorId());
-        } else if (mReactInstanceManager != null) {
-            mReactInstanceManager.onBackPressed();
-        } else {
-            super.onBackPressed();
-        }
-    }
-
-    @Override
-    public void invokeDefaultOnBackPressed() {
-        super.onBackPressed();
-    }
-
-    protected void setupDrawer(Screen screen, Drawer drawer, int drawerFrameId, int drawerLayoutId) {
-        if (drawer == null || drawer.left == null) {
-            return;
-        }
-
-        mDrawerStack = new ScreenStack(this);
-        FrameLayout drawerFrame = (FrameLayout) findViewById(drawerFrameId);
-        drawerFrame.addView(mDrawerStack);
-        mDrawerStack.push(drawer.left);
-
-        mDrawerLayout = (DrawerLayout) findViewById(drawerLayoutId);
-        mDrawerToggle = mToolbar.setupDrawer(mDrawerLayout, drawer.left, screen);
-    }
-
-    public void setNavigationButtons(ReadableMap buttons) {
-        if (mToolbar == null) {
-            return;
-        }
-        getCurrentScreen().setButtons(buttons);
-        mToolbar.setupToolbarButtonsAsync(getCurrentScreen());
-    }
-
-    public void setNavigationTitle(ReadableMap title) {
-        if (mToolbar == null) {
-            return;
-        }
-
-        mToolbar.setTitle(title.getString(KEY_TITLE));
-    }
-
-    public void toggleNavigationBar(ReadableMap params) {
-        if (mToolbar == null) {
-            return;
-        }
-
-        boolean hide = params.getBoolean(KEY_HIDDEN);
-        boolean animated = params.getBoolean(KEY_ANIMATED);
-        if (hide) {
-            mToolbar.hideToolbar(animated);
-        } else {
-            mToolbar.showToolbar(animated);
-        }
-    }
-
-    public void toggleDrawer(ReadableMap params) {
-        if (mToolbar == null || mDrawerToggle == null) {
-            return;
-        }
-
-        boolean animated = params.getBoolean(KEY_ANIMATED);
-        String side = params.getString(KEY_SIDE);
-        String to = params.getString(KEY_TO);
-        switch (to) {
-            case "open":
-                mToolbar.showDrawer(animated);
-                break;
-            case "closed":
-                mToolbar.hideDrawer(animated);
-                break;
-            default:
-                mToolbar.toggleDrawer(animated);
-                break;
-        }
-    }
-
-    public void showFAB(ReadableMap params) {
-    }
-}

android/app/src/main/java/com/reactnativenavigation/activities/BottomTabActivity.java

@@ -1,309 +0,0 @@
-package com.reactnativenavigation.activities;
-
-import android.graphics.Color;
-import android.graphics.drawable.Drawable;
-import android.os.AsyncTask;
-import android.os.Bundle;
-import android.support.design.widget.CoordinatorLayout;
-
-import com.aurelhubert.ahbottomnavigation.AHBottomNavigation;
-import com.aurelhubert.ahbottomnavigation.AHBottomNavigationItem;
-import com.facebook.react.bridge.ReadableMap;
-import com.reactnativenavigation.R;
-import com.reactnativenavigation.core.RctManager;
-import com.reactnativenavigation.core.objects.Drawer;
-import com.reactnativenavigation.core.objects.Screen;
-import com.reactnativenavigation.utils.StyleHelper;
-import com.reactnativenavigation.views.BottomNavigation;
-import com.reactnativenavigation.views.RnnToolBar;
-import com.reactnativenavigation.views.ScreenStack;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Map;
-
-public class BottomTabActivity extends BaseReactActivity implements AHBottomNavigation.OnTabSelectedListener {
-    private static final String TAG = "BottomTabActivity";
-    public static final String DRAWER_PARAMS = "drawerParams";
-    public static final String EXTRA_SCREENS = "extraScreens";
-
-    private static final String TAB_STYLE_BUTTON_COLOR = "tabBarButtonColor";
-    private static final String TAB_STYLE_SELECTED_COLOR = "tabBarSelectedButtonColor";
-    private static final String TAB_STYLE_BAR_BG_COLOR = "tabBarBackgroundColor";
-    private static final String TAB_STYLE_INACTIVE_TITLES = "tabShowInactiveTitles";
-
-    private static int DEFAULT_TAB_BAR_BG_COLOR = 0xFFFFFFFF;
-    private static int DEFAULT_TAB_BUTTON_COLOR = Color.GRAY;
-    private static int DEFAULT_TAB_SELECTED_COLOR = 0xFF0000FF;
-    private static boolean DEFAULT_TAB_INACTIVE_TITLES = true;
-
-    private BottomNavigation mBottomNavigation;
-    private CoordinatorLayout mContentFrame;
-    private ArrayList<ScreenStack> mScreenStacks;
-    private int mCurrentStackPosition = -1;
-
-    @Override
-    protected void handleOnCreate() {
-        super.handleOnCreate();
-        mReactInstanceManager = RctManager.getInstance().getReactInstanceManager();
-
-        setContentView(R.layout.bottom_tab_activity);
-        mToolbar = (RnnToolBar) findViewById(R.id.toolbar);
-        mBottomNavigation = (BottomNavigation) findViewById(R.id.bottom_tab_bar);
-        mContentFrame = (CoordinatorLayout) findViewById(R.id.contentFrame);
-
-        final ArrayList<Screen> screens = (ArrayList<Screen>) getIntent().getSerializableExtra(EXTRA_SCREENS);
-        final Drawer drawer = (Drawer) getIntent().getSerializableExtra(DRAWER_PARAMS);
-        mBottomNavigation.setForceTint(true);
-        setupDrawer(screens.get(0), drawer, R.id.drawerFrame, R.id.drawerLayout);
-        setupTabs(getIntent().getExtras());
-        setupPages(screens);
-
-        // Setup Toolbar after it's measured since icon height is dependent on Toolbar height
-        mContentFrame.post(new Runnable() {
-            @Override
-            public void run() {
-                setupToolbar(screens);
-            }
-        });
-    }
-
-    private void setupPages(ArrayList<Screen> screens) {
-        new SetupTabsTask(this, mToolbar, screens).execute();
-    }
-
-    private void setupToolbar(ArrayList<Screen> screens) {
-        mToolbar.setScreens(screens);
-        Screen initialScreen = screens.get(0);
-        mToolbar.update(initialScreen);
-        StyleHelper.updateStyles(mToolbar, initialScreen);
-    }
-
-    @Override
-    protected void onResume() {
-        super.onResume();
-        if (mScreenStacks != null) {
-            StyleHelper.updateStyles(mToolbar, getCurrentScreen());
-        }
-    }
-
-    private void setupTabs(Bundle style) {
-        mBottomNavigation.setForceTitlesDisplay(style.getBoolean(TAB_STYLE_INACTIVE_TITLES, DEFAULT_TAB_INACTIVE_TITLES));
-        mBottomNavigation.setForceTint(true);
-        mBottomNavigation.setDefaultBackgroundColor(getColor(style, TAB_STYLE_BAR_BG_COLOR, DEFAULT_TAB_BAR_BG_COLOR));
-        mBottomNavigation.setInactiveColor(getColor(style, TAB_STYLE_BUTTON_COLOR, DEFAULT_TAB_BUTTON_COLOR));
-        mBottomNavigation.setAccentColor(getColor(style, TAB_STYLE_SELECTED_COLOR, DEFAULT_TAB_SELECTED_COLOR));
-    }
-
-    private static int getColor(Bundle bundle, String key, int defaultColor) {
-        if (bundle.containsKey(key)) {
-            return Color.parseColor(bundle.getString(key));
-        } else {
-            return defaultColor;
-        }
-    }
-
-    @Override
-    public void push(Screen screen) {
-        super.push(screen);
-        for (ScreenStack stack : mScreenStacks) {
-            if (stack.peek().navigatorId.equals(screen.navigatorId)) {
-                stack.push(screen);
-            }
-        }
-        StyleHelper.updateStyles(mToolbar, getCurrentScreen());
-
-        if (shouldToggleTabs(screen)) {
-            mBottomNavigation.toggleTabs(screen.bottomTabsHidden, false);
-        }
-    }
-
-    @Override
-    public Screen pop(String navigatorId) {
-        super.pop(navigatorId);
-        for (ScreenStack stack : mScreenStacks) {
-            if (stack.peek().navigatorId.equals(navigatorId)) {
-                Screen popped = stack.pop();
-                Screen currentScreen = getCurrentScreen();
-                StyleHelper.updateStyles(mToolbar, currentScreen);
-
-                if (shouldToggleTabs(currentScreen)) {
-                    mBottomNavigation.toggleTabs(currentScreen.bottomTabsHidden, false);
-                }
-
-                return popped;
-            }
-        }
-        return null;
-    }
-
-    @Override
-    public Screen popToRoot(String navigatorId) {
-        super.popToRoot(navigatorId);
-        for (ScreenStack stack : mScreenStacks) {
-            if (stack.peek().navigatorId.equals(navigatorId)) {
-                Screen popped = stack.popToRoot();
-                Screen currentScreen = getCurrentScreen();
-                StyleHelper.updateStyles(mToolbar, currentScreen);
-
-                if (shouldToggleTabs(currentScreen)) {
-                    mBottomNavigation.toggleTabs(currentScreen.bottomTabsHidden, false);
-                }
-
-                return popped;
-            }
-        }
-        return null;
-    }
-
-    @Override
-    public Screen getCurrentScreen() {
-        Screen currentScreen = super.getCurrentScreen();
-        if (currentScreen != null) {
-            return currentScreen;
-        }
-
-        return mScreenStacks != null ? mScreenStacks.get(mCurrentStackPosition).peek() : null;
-    }
-
-    public Screen resetTo(Screen screen) {
-        super.resetTo(screen);
-        StyleHelper.updateStyles(mToolbar, screen);
-        return mScreenStacks.get(mCurrentStackPosition).resetTo(screen);
-    }
-
-    @Override
-    protected String getCurrentNavigatorId() {
-        return mScreenStacks.get(mCurrentStackPosition).peek().navigatorId;
-    }
-
-    @Override
-    public int getScreenStackSize() {
-        return mScreenStacks.get(mCurrentStackPosition).getStackSize();
-    }
-
-    @Override
-    public void onTabSelected(int position, boolean wasSelected) {
-        if (wasSelected) {
-            return;
-        }
-
-        // Remove current ScreenStack
-        if (mCurrentStackPosition >= 0) {
-            mScreenStacks.get(mCurrentStackPosition).removeFromScreen(mContentFrame);
-        }
-
-        // Add new ScreenStack
-        mScreenStacks.get(position).addToScreen(mContentFrame);
-
-        mCurrentStackPosition = position;
-        StyleHelper.updateStyles(mToolbar, getCurrentScreen());
-
-        // Hide or show back button if needed
-        if (getScreenStackSize() > 1) {
-            mToolbar.setNavUpButton(getCurrentScreen());
-        } else {
-            mToolbar.setNavUpButton();
-        }
-    }
-
-    public void setTabBadge(ReadableMap params) {
-        // Badge comes across as int, but if it's 0 clear the notification
-        int badgeCount = params.getInt(KEY_BADGE);
-        String badge = (badgeCount > 0) ? Integer.toString(badgeCount) : "";
-
-        // Tab index is optional, so default to current tab
-        int tabIndex = mBottomNavigation.getCurrentItem();
-        if (params.hasKey(KEY_TAB_INDEX)) {
-            tabIndex = params.getInt(KEY_TAB_INDEX);
-        }
-
-        mBottomNavigation.setNotification(badge, tabIndex);
-    }
-
-    public void switchToTab(ReadableMap params) {
-        Integer tabIndex;
-        if (params.hasKey(KEY_TAB_INDEX)) {
-            tabIndex = params.getInt(KEY_TAB_INDEX);
-        } else {
-            final String navigatorId = params.getString(KEY_NAVIGATOR_ID);
-            tabIndex = findNavigatorTabIndex(navigatorId);
-        }
-        mBottomNavigation.setCurrentItem(tabIndex);
-    }
-
-    public void toggleTabs(ReadableMap params) {
-        boolean hide = params.getBoolean(KEY_HIDDEN);
-        boolean animated = params.getBoolean(KEY_ANIMATED);
-        mBottomNavigation.toggleTabs(hide, animated);
-    }
-
-    private boolean shouldToggleTabs(Screen newScreen) {
-        return mBottomNavigation.isShown() == newScreen.bottomTabsHidden;
-    }
-
-    public void onScrollChanged(int direction) {
-        mBottomNavigation.onScroll(direction);
-    }
-
-    private static class SetupTabsTask extends AsyncTask<Void, Void, Map<Screen, Drawable>> {
-        private BottomTabActivity mActivity;
-        private RnnToolBar mToolBar;
-        private ArrayList<Screen> mScreens;
-
-        public SetupTabsTask(BottomTabActivity context, RnnToolBar toolBar, ArrayList<Screen> screens) {
-            mActivity = context;
-            mToolBar = toolBar;
-            mScreens = screens;
-        }
-
-        @Override
-        protected Map<Screen, Drawable> doInBackground(Void... params) {
-            Map<Screen, Drawable> icons = new HashMap<>();
-            for (Screen screen : mScreens) {
-                if (screen.icon != null) {
-                    icons.put(screen, screen.getIcon(this.mActivity));
-                }
-            }
-            return icons;
-        }
-
-        @Override
-        protected void onPostExecute(Map<Screen, Drawable> icons) {
-            mActivity.setTabsWithIcons(mScreens, icons);
-            StyleHelper.updateStyles(mToolBar, mActivity.getCurrentScreen());
-        }
-    }
-
-    protected Integer findNavigatorTabIndex(String navigatorId) {
-        for (int i = 0; i < mScreenStacks.size(); i++) {
-            ScreenStack stack = mScreenStacks.get(i);
-            if (!stack.isEmpty() && stack.peek().navigatorId.equals(navigatorId)) {
-                return i;
-            }
-        }
-
-        return null;
-    }
-
-    private void setTabsWithIcons(ArrayList<Screen> screens, Map<Screen, Drawable> icons) {
-        mScreenStacks = new ArrayList<>();
-        for (int i = 0; i < screens.size(); i++) {
-            final Screen screen = screens.get(i);
-            ScreenStack stack = new ScreenStack(this);
-            stack.push(screen);
-            mScreenStacks.add(stack);
-            AHBottomNavigationItem item = new AHBottomNavigationItem(screen.label, icons.get(screen), Color.GRAY);
-            mBottomNavigation.addItem(item);
-            mBottomNavigation.setOnTabSelectedListener(this);
-        }
-        this.onTabSelected(0, false);
-    }
-
-    @Override
-    protected void removeAllReactViews() {
-        for (ScreenStack screenStack : mScreenStacks) {
-            screenStack.removeAllReactViews();
-        }
-    }
-}

android/app/src/main/java/com/reactnativenavigation/activities/RootActivity.java

@@ -1,54 +0,0 @@
-package com.reactnativenavigation.activities;
-
-import android.view.ViewGroup;
-
-import com.facebook.react.ReactRootView;
-import com.reactnativenavigation.core.objects.Screen;
-
-/**
- * This activity is used to start the JS execution where we load our actual app/screens (index.android.js)
- * Triggering react context initialization execute global code before any {@link ReactRootView}
- * are displayed.
- * <p>Only your MainActivity or activities with {@code action.MAIN} and {@code category.LAUNCHER}
- * should extend this activity.
- * Created by guyc on 13/04/16.
- */
-public class RootActivity extends BaseReactActivity {
-
-    @Override
-    protected void handleOnCreate() {
-        super.handleOnCreate();
-        if (!getReactInstanceManager().hasStartedCreatingInitialContext()) {
-            // Trigger react context initialization, global javascript code will now execute
-            getReactInstanceManager().createReactContextInBackground();
-        }
-    }
-
-    @Override
-    protected void onPause() {
-        super.onPause();
-        finish();
-    }
-
-    // No need to implement stack interface since this activity is only used to start other
-    // activities such as TabActivity or SingleScreenActivity.
-    @Override
-    public Screen getCurrentScreen() {
-        return null;
-    }
-
-    @Override
-    public String getCurrentNavigatorId() {
-        return null;
-    }
-
-    @Override
-    public int getScreenStackSize() {
-        return 0;
-    }
-
-    @Override
-    public void removeAllReactViews() {
-
-    }
-}

android/app/src/main/java/com/reactnativenavigation/activities/SingleScreenActivity.java

@@ -1,125 +0,0 @@
-package com.reactnativenavigation.activities;
-
-import android.support.design.widget.CoordinatorLayout;
-
-import com.facebook.react.bridge.ReadableMap;
-import com.reactnativenavigation.R;
-import com.reactnativenavigation.core.RctManager;
-import com.reactnativenavigation.core.objects.Drawer;
-import com.reactnativenavigation.core.objects.Screen;
-import com.reactnativenavigation.utils.StyleHelper;
-import com.reactnativenavigation.views.RnnToolBar;
-import com.reactnativenavigation.views.ScreenStack;
-
-public class SingleScreenActivity extends BaseReactActivity {
-
-    public static final String DRAWER_PARAMS = "drawerParams";
-    public static final String EXTRA_SCREEN = "extraScreen";
-
-    private ScreenStack mScreenStack;
-    private String mNavigatorId;
-
-    @Override
-    protected void handleOnCreate() {
-        super.handleOnCreate();
-        mReactInstanceManager = RctManager.getInstance().getReactInstanceManager();
-
-        setContentView(R.layout.single_screen_activity);
-        mToolbar = (RnnToolBar) findViewById(R.id.toolbar);
-
-        final Screen screen = (Screen) getIntent().getSerializableExtra(EXTRA_SCREEN);
-        final Drawer drawer = (Drawer) getIntent().getSerializableExtra(DRAWER_PARAMS);
-
-        mNavigatorId = screen.navigatorId;
-        setupToolbar(screen);
-        setupDrawer(screen, drawer, R.id.drawerFrame, R.id.drawerLayout);
-
-        mScreenStack = new ScreenStack(this);
-        CoordinatorLayout contentFrame = (CoordinatorLayout) findViewById(R.id.contentFrame);
-        assert contentFrame != null;
-        contentFrame.addView(mScreenStack);
-        mScreenStack.push(screen);
-
-        // Setup Toolbar after it's measured since icon height is dependent on Toolbar height
-        contentFrame.post(new Runnable() {
-            @Override
-            public void run() {
-                setupToolbar(screen);
-            }
-        });
-    }
-
-    protected void setupToolbar(Screen screen) {
-        StyleHelper.updateStyles(mToolbar, screen);
-    }
-
-    @Override
-    public void push(Screen screen) {
-        super.push(screen);
-        mScreenStack.push(screen);
-        StyleHelper.updateStyles(mToolbar, screen);
-    }
-
-    @Override
-    public Screen pop(String navigatorId) {
-        super.pop(navigatorId);
-        Screen popped = mScreenStack.pop();
-        StyleHelper.updateStyles(mToolbar, getCurrentScreen());
-        return popped;
-    }
-
-    @Override
-    public Screen popToRoot(String navigatorId) {
-        super.popToRoot(navigatorId);
-        Screen screen = mScreenStack.popToRoot();
-        StyleHelper.updateStyles(mToolbar, getCurrentScreen());
-        return screen;
-    }
-
-    @Override
-    public Screen resetTo(Screen screen) {
-        super.resetTo(screen);
-        Screen popped = mScreenStack.resetTo(screen);
-        StyleHelper.updateStyles(mToolbar, screen);
-        return popped;
-    }
-
-    @Override
-    public String getCurrentNavigatorId() {
-        return mNavigatorId;
-    }
-
-    @Override
-    public Screen getCurrentScreen() {
-        Screen currentScreen = super.getCurrentScreen();
-        if (currentScreen != null) {
-            return currentScreen;
-        }
-
-        return mScreenStack.peek();
-    }
-
-    @Override
-    public int getScreenStackSize() {
-        return mScreenStack.getStackSize();
-    }
-
-    @Override
-    protected void removeAllReactViews() {
-        mScreenStack.removeAllReactViews();
-    }
-
-    @Override
-    public void showFAB(ReadableMap params) {
-//        FloatingActionButton fab = new FloatingActionButton(this);
-//        fab.setImageDrawable(IconUtils.getIcon(this, params.getString("icon")));
-//        fab.setBackgroundColor(Color.parseColor(params.getString("backgroundColor")));
-//        fab.setImageResource(R.drawable.notification_background);
-//        CoordinatorLayout content = (CoordinatorLayout) findViewById(R.id.contentFrame);
-//        CoordinatorLayout.LayoutParams layoutParams = new CoordinatorLayout.LayoutParams(WRAP_CONTENT, WRAP_CONTENT);
-//        layoutParams.gravity = Gravity.BOTTOM | Gravity.END;
-//        int m = (int) ImageUtils.convertDpToPixel(16, this);
-//        layoutParams.setMargins(m, m, m, m);
-//        content.addView(fab, layoutParams);
-    }
-}

android/app/src/main/java/com/reactnativenavigation/activities/TabActivity.java

@@ -1,105 +0,0 @@
-package com.reactnativenavigation.activities;
-
-import android.support.v4.view.ViewPager;
-import android.view.Menu;
-import android.view.ViewGroup;
-
-import com.reactnativenavigation.R;
-import com.reactnativenavigation.adapters.ViewPagerAdapter;
-import com.reactnativenavigation.core.RctManager;
-import com.reactnativenavigation.core.objects.Screen;
-import com.reactnativenavigation.utils.StyleHelper;
-import com.reactnativenavigation.views.RnnTabLayout;
-import com.reactnativenavigation.views.RnnToolBar;
-
-import java.util.ArrayList;
-
-/**
- * This class is currently not supported and will be removed in future release.
- * Created by guyc on 02/04/16.
- */
-@Deprecated
-public class TabActivity extends BaseReactActivity {
-    public static final String EXTRA_SCREENS = "extraScreens";
-
-    private RnnTabLayout mTabLayout;
-    private ViewPager mViewPager;
-    private ViewPagerAdapter mAdapter;
-
-    @Override
-    protected void handleOnCreate() {
-        super.handleOnCreate();
-        mReactInstanceManager = RctManager.getInstance().getReactInstanceManager();
-
-        setContentView(R.layout.tab_activity);
-        mToolbar = (RnnToolBar) findViewById(R.id.toolbar);
-        mTabLayout = (RnnTabLayout) findViewById(R.id.tabLayout);
-        mViewPager = (ViewPager) findViewById(R.id.viewPager);
-
-        ArrayList<Screen> screens = (ArrayList<Screen>) getIntent().getSerializableExtra(EXTRA_SCREENS);
-
-        setupToolbar(screens);
-        setupViewPager(screens);
-    }
-
-    private void setupToolbar(ArrayList<Screen> screens) {
-        Screen initialScreen = screens.get(0);
-        mToolbar.setScreens(screens);
-        mToolbar.update(initialScreen);
-        setNavigationStyle(initialScreen);
-    }
-
-    public void setNavigationStyle(Screen screen) {
-        mTabLayout.setStyle(screen);
-    }
-
-    private void setupViewPager(ArrayList<Screen> screens) {
-        mAdapter = new ViewPagerAdapter(this, mViewPager, mToolbar, screens);
-        mViewPager.setAdapter(mAdapter);
-        mTabLayout.setupWithViewPager(mViewPager);
-        mTabLayout.setOnTabSelectedListener(mAdapter);
-        mAdapter.notifyDataSetChanged();
-    }
-
-    @Override
-    public boolean onCreateOptionsMenu(Menu menu) {
-        boolean ret = super.onCreateOptionsMenu(menu);
-        mToolbar.handleOnCreateOptionsMenuAsync();
-        return ret;
-    }
-
-    @Override
-    public void removeAllReactViews() {
-
-    }
-
-    @Override
-    public void push(Screen screen) {
-        super.push(screen);
-        StyleHelper.updateStyles(mToolbar, screen);
-        mAdapter.push(screen);
-    }
-
-    @Override
-    public Screen pop(String navigatorId) {
-        super.pop(navigatorId);
-        Screen popped = mAdapter.pop(navigatorId);
-        setNavigationStyle(getCurrentScreen());
-        return popped;
-    }
-
-    @Override
-    public Screen getCurrentScreen() {
-        return mAdapter.peek(getCurrentNavigatorId());
-    }
-
-    @Override
-    protected String getCurrentNavigatorId() {
-        return mAdapter.getNavigatorId(mViewPager.getCurrentItem());
-    }
-
-    @Override
-    public int getScreenStackSize() {
-        return mAdapter.getStackSizeForNavigatorId(getCurrentNavigatorId());
-    }
-}

android/app/src/main/java/com/reactnativenavigation/adapters/ViewPagerAdapter.java

@@ -1,154 +0,0 @@
-package com.reactnativenavigation.adapters;
-
-import android.support.design.widget.TabLayout;
-import android.support.v4.view.PagerAdapter;
-import android.support.v4.view.ViewPager;
-import android.view.View;
-import android.view.ViewGroup;
-
-import com.facebook.react.bridge.Arguments;
-import com.facebook.react.bridge.WritableMap;
-import com.reactnativenavigation.activities.BaseReactActivity;
-import com.reactnativenavigation.core.RctManager;
-import com.reactnativenavigation.core.objects.Screen;
-import com.reactnativenavigation.utils.StyleHelper;
-import com.reactnativenavigation.views.RnnToolBar;
-import com.reactnativenavigation.views.ScreenStack;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Map;
-
-/**
- * Created by guyc on 02/04/16.
- */
-public class ViewPagerAdapter extends PagerAdapter implements TabLayout.OnTabSelectedListener, ViewPager.OnPageChangeListener {
-
-    private static final String EVENT_ON_TAB_SELECTED = "OnTabSelected";
-
-    private ViewPager mViewPager;
-    private RnnToolBar mToolbar;
-    private final ArrayList<ScreenStack> mScreenStacks;
-    private final ArrayList<String> mNavigatorIds;
-    private final Map<String, ScreenStack> mStackByNavigatorId;
-    private int mCurrentPage = 0;
-
-    public ViewPagerAdapter(BaseReactActivity context, ViewPager viewPager, RnnToolBar toolbar,
-                            ArrayList<Screen> screens) {
-        mViewPager = viewPager;
-        mToolbar = toolbar;
-        mScreenStacks = new ArrayList<>();
-        mNavigatorIds = new ArrayList<>();
-        mStackByNavigatorId = new HashMap<>();
-        for (Screen screen : screens) {
-            ScreenStack stack = new ScreenStack(context);
-            stack.push(screen);
-            mScreenStacks.add(stack);
-            mNavigatorIds.add(screen.navigatorId);
-            mStackByNavigatorId.put(screen.navigatorId, stack);
-        }
-    }
-
-    public void push(Screen screen) {
-        ScreenStack stack = mStackByNavigatorId.get(screen.navigatorId);
-        Screen prevScreen = mScreenStacks.get(mCurrentPage).peek();
-        mToolbar.setupToolbarButtonsAsync(prevScreen, screen);
-        stack.push(screen);
-    }
-
-    public Screen pop(String navigatorId) {
-        ScreenStack stack = mStackByNavigatorId.get(navigatorId);
-        Screen oldScreen =  stack != null ? stack.pop() : null;
-        Screen newScreen = stack.peek();
-        mToolbar.setupToolbarButtonsAsync(oldScreen, newScreen);
-        return oldScreen;
-    }
-
-    public Screen peek(String navigatorId) {
-        ScreenStack stack = mStackByNavigatorId.get(navigatorId);
-        return stack != null ? stack.peek() : null;
-    }
-
-    @Override
-    public Object instantiateItem(ViewGroup container, int position) {
-        ScreenStack view = mScreenStacks.get(position);
-        container.addView(view);
-        return view;
-    }
-
-    @Override
-    public void destroyItem(ViewGroup container, int position, Object view) {
-        container.removeView((View) view);
-    }
-
-    @Override
-    public int getCount() {
-        return mScreenStacks.size();
-    }
-
-    @Override
-    public boolean isViewFromObject(View view, Object object) {
-        return view == object;
-    }
-
-    @Override
-    public CharSequence getPageTitle(int position) {
-        return mScreenStacks.get(position).peek().label;
-    }
-
-    @Override
-    public void onTabSelected(TabLayout.Tab tab) {
-        // Set the viewPager's current item
-        int position = tab.getPosition();
-        mViewPager.setCurrentItem(position);
-
-        // Set screen buttons
-        Screen prevScreen = mScreenStacks.get(mCurrentPage).peek();
-        Screen newScreen = mScreenStacks.get(position).peek();
-        mToolbar.setupToolbarButtonsAsync(prevScreen, newScreen);
-
-        // Set title
-        mToolbar.setTitle(newScreen.title == null ? "" : newScreen.title);
-
-        // Set navigation color
-        StyleHelper.updateStyles(mToolbar, newScreen);
-
-        // Send tab selected event
-        WritableMap params = Arguments.createMap();
-        Screen screen = mScreenStacks.get(position).peek();
-        RctManager.getInstance().sendEvent(EVENT_ON_TAB_SELECTED, screen, params);
-    }
-
-    @Override
-    public void onTabUnselected(TabLayout.Tab tab) {
-
-    }
-
-    @Override
-    public void onTabReselected(TabLayout.Tab tab) {
-
-    }
-
-    public String getNavigatorId(int position) {
-        return mNavigatorIds.get(position);
-    }
-
-    public int getStackSizeForNavigatorId(String activeNavigatorID) {
-        return mStackByNavigatorId.get(activeNavigatorID).getStackSize();
-    }
-
-    @Override
-    public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
-
-    }
-
-    @Override
-    public void onPageSelected(int position) {
-        mCurrentPage = position;
-    }
-
-    @Override
-    public void onPageScrollStateChanged(int state) {
-
-    }
-}

android/app/src/main/java/com/reactnativenavigation/animation/VisibilityAnimator.java

@@ -0,0 +1,120 @@
+package com.reactnativenavigation.animation;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.ObjectAnimator;
+import android.support.v4.view.animation.LinearOutSlowInInterpolator;
+import android.view.View;
+
+import com.reactnativenavigation.views.ScrollDirectionListener;
+
+public class VisibilityAnimator {
+
+    public enum HideDirection {
+        Up, Down
+    }
+
+    private enum VisibilityState {
+        Hidden, AnimateHide, Shown, AnimateShow
+    }
+
+    private static final int SHOW_END_VALUE = 0;
+    private static final int DURATION = 300;
+
+    private final View view;
+    private final HideDirection hideDirection;
+    private final int hiddenEndValue;
+    private VisibilityState visibilityState = VisibilityState.Shown;
+
+    public VisibilityAnimator(View view, HideDirection hideDirection, int height) {
+        this.view = view;
+        this.hideDirection = hideDirection;
+        this.hiddenEndValue = hideDirection == HideDirection.Up ? -height : height;
+    }
+
+    public void onScrollChanged(ScrollDirectionListener.Direction scrollDirection) {
+        if (hideDirection == HideDirection.Down) {
+            handleDownHidingViews(scrollDirection);
+        } else {
+            handleUpHidingViews(scrollDirection);
+        }
+    }
+
+    public void setVisible(boolean visible, boolean animate) {
+        if (visible && isHiding()) {
+            show(animate);
+        } else if (!visible && isShowing()) {
+            hide(animate);
+        }
+    }
+
+    private void handleUpHidingViews(ScrollDirectionListener.Direction scrollDirection) {
+        if (scrollUp(scrollDirection) && !isShowing()) {
+            show(true);
+        } else if (scrollDown(scrollDirection) && !isHiding()) {
+            hide(true);
+        }
+    }
+
+    private void handleDownHidingViews(ScrollDirectionListener.Direction scrollDirection) {
+        if (scrollDown(scrollDirection) && !isHiding()) {
+            hide(true);
+        } else if (scrollUp(scrollDirection) && !isShowing()) {
+            show(true);
+        }
+    }
+
+    private void show(boolean animate) {
+        if (animate) {
+            ObjectAnimator animator = createAnimator(true);
+            animator.start();
+        } else {
+            visibilityState = VisibilityState.Shown;
+            view.setVisibility(View.VISIBLE);
+        }
+    }
+
+    private void hide(boolean animate) {
+        if (animate) {
+            ObjectAnimator animator = createAnimator(false);
+            animator.start();
+        } else {
+            visibilityState = VisibilityState.Hidden;
+            view.setVisibility(View.GONE);
+        }
+    }
+
+    private boolean scrollUp(ScrollDirectionListener.Direction scrollDirection) {
+        return scrollDirection == ScrollDirectionListener.Direction.Up;
+    }
+
+    private boolean scrollDown(ScrollDirectionListener.Direction scrollDirection) {
+        return scrollDirection == ScrollDirectionListener.Direction.Down;
+    }
+
+    private boolean isShowing() {
+        return visibilityState == VisibilityState.Shown || visibilityState == VisibilityState.AnimateShow;
+    }
+
+    private boolean isHiding() {
+        return visibilityState == VisibilityState.Hidden || visibilityState == VisibilityState.AnimateHide;
+    }
+
+    private ObjectAnimator createAnimator(final boolean show) {
+        ObjectAnimator animator = ObjectAnimator.ofFloat(view, View.TRANSLATION_Y, show ? SHOW_END_VALUE : hiddenEndValue);
+        animator.setDuration(DURATION);
+        animator.setInterpolator(new LinearOutSlowInInterpolator());
+        animator.addListener(new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationStart(Animator animation) {
+                visibilityState = show ? VisibilityState.AnimateShow : VisibilityState.AnimateHide;
+            }
+
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                visibilityState = show ? VisibilityState.Shown : VisibilityState.Hidden;
+            }
+        });
+        return animator;
+    }
+}

android/app/src/main/java/com/reactnativenavigation/bridge/BundleConverter.java

@@ -0,0 +1,68 @@
+package com.reactnativenavigation.bridge;
+
+import android.os.Bundle;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableMapKeySetIterator;
+
+public class BundleConverter {
+    public static Bundle toBundle(ReadableMap map) {
+        Bundle bundle = new Bundle();
+        ReadableMapKeySetIterator it = map.keySetIterator();
+        while (it.hasNextKey()) {
+            String key = it.nextKey();
+            switch (map.getType(key)) {
+                case Null:
+                    break;
+                case Boolean:
+                    bundle.putBoolean(key, map.getBoolean(key));
+                    break;
+                case Number:
+                    bundle.putDouble(key, map.getDouble(key));
+                    break;
+                case String:
+                    bundle.putString(key, map.getString(key));
+                    break;
+                case Map:
+                    bundle.putBundle(key, toBundle(map.getMap(key)));
+                    break;
+                case Array:
+                    bundle.putBundle(key, toBundle(map.getArray(key)));
+                    break;
+                default:
+                    break;
+            }
+        }
+        return bundle;
+    }
+
+    public static Bundle toBundle(ReadableArray array) {
+        Bundle bundle = new Bundle();
+        for (int i = 0; i < array.size(); i++) {
+            String key = String.valueOf(i);
+            switch (array.getType(i)) {
+                case Null:
+                    break;
+                case Boolean:
+                    bundle.putBoolean(key, array.getBoolean(i));
+                    break;
+                case Number:
+                    bundle.putDouble(key, array.getDouble(i));
+                    break;
+                case String:
+                    bundle.putString(key, array.getString(i));
+                    break;
+                case Map:
+                    bundle.putBundle(key, toBundle(array.getMap(i)));
+                    break;
+                case Array:
+                    bundle.putBundle(key, toBundle(array.getArray(i)));
+                    break;
+                default:
+                    break;
+            }
+        }
+        return bundle;
+    }
+}

android/app/src/main/java/com/reactnativenavigation/bridge/NavigationReactEventEmitter.java

@@ -0,0 +1,41 @@
+package com.reactnativenavigation.bridge;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter;
+
+public class NavigationReactEventEmitter {
+
+    private static final String KEY_EVENT_ID = "id";
+    private static final String KEY_EVENT_TYPE = "type";
+    private static final String KEY_NAVIGATOR_EVENT_ID = "navigatorEventID";
+    private static final String EVENT_TYPE = "NavBarButtonPress";
+    private RCTDeviceEventEmitter eventEmitter;
+
+    public NavigationReactEventEmitter(ReactContext reactContext) {
+        this.eventEmitter = reactContext.getJSModule(RCTDeviceEventEmitter.class);
+    }
+
+    public void sendNavigatorEvent(String eventId, String navigatorEventId) {
+        WritableMap data = Arguments.createMap();
+        data.putString(KEY_EVENT_TYPE, EVENT_TYPE);
+        data.putString(KEY_EVENT_ID, eventId);
+        data.putString(KEY_NAVIGATOR_EVENT_ID, navigatorEventId);
+        eventEmitter.emit(navigatorEventId, data);
+    }
+
+    public void sendNavigatorEvent(String eventId, String navigatorEventId, WritableMap data) {
+        data.putString(KEY_NAVIGATOR_EVENT_ID, navigatorEventId);
+        data.putString(KEY_EVENT_ID, eventId);
+        eventEmitter.emit(navigatorEventId, data);
+    }
+
+    public void sendEvent(String eventId, String data) {
+        eventEmitter.emit(eventId, data);
+    }
+
+    public void sendEvent(String eventId, WritableMap data) {
+        eventEmitter.emit(eventId, data);
+    }
+}

android/app/src/main/java/com/reactnativenavigation/bridge/NavigationReactModule.java

@@ -0,0 +1,144 @@
+package com.reactnativenavigation.bridge;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.reactnativenavigation.controllers.NavigationCommandsHandler;
+import com.reactnativenavigation.params.TitleBarButtonParams;
+import com.reactnativenavigation.params.TitleBarLeftButtonParams;
+import com.reactnativenavigation.params.parsers.TitleBarButtonParamsParser;
+import com.reactnativenavigation.params.parsers.TitleBarLeftButtonParamsParser;
+
+import java.util.List;
+
+/**
+ * The basic abstract components we will expose:
+ * BottomTabs (app) - boolean
+ * TopBar (per screen)
+ * - TitleBar
+ * - - RightButtons
+ * - - LeftButton
+ * - TopTabs (segmented control / view pager tabs)
+ * DeviceStatusBar (app) (colors are per screen)
+ * AndroidNavigationBar (app) (colors are per screen)
+ * SideMenu (app) - boolean, (menu icon is screen-based)
+ */
+public class NavigationReactModule extends ReactContextBaseJavaModule {
+    public static final String NAME = "NavigationReactModule";
+
+    public NavigationReactModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    @ReactMethod
+    public void startApp(final ReadableMap params) {
+        NavigationCommandsHandler.startApp(BundleConverter.toBundle(params));
+    }
+
+    @ReactMethod
+    public void setScreenTitleBarTitle(String screenInstanceId, String title) {
+        NavigationCommandsHandler.setScreenTitleBarTitle(screenInstanceId, title);
+    }
+
+    @ReactMethod
+    public void setScreenTitleBarButtons(String screenInstanceId, String navigatorEventId,
+                                         ReadableArray rightButtonsParams, ReadableMap leftButtonParams) {
+        if (rightButtonsParams != null) {
+            setScreenTitleBarRightButtons(screenInstanceId, navigatorEventId, rightButtonsParams);
+        }
+
+        if (leftButtonParams != null) {
+            setScreenTitleBarLeftButton(screenInstanceId, navigatorEventId, leftButtonParams);
+        }
+    }
+
+    private void setScreenTitleBarRightButtons(String screenInstanceId, String navigatorEventId, ReadableArray rightButtonsParams) {
+        List<TitleBarButtonParams> rightButtons = new TitleBarButtonParamsParser()
+                .parseButtons(BundleConverter.toBundle(rightButtonsParams));
+        NavigationCommandsHandler.setScreenTitleBarRightButtons(screenInstanceId, navigatorEventId, rightButtons);
+    }
+
+    private void setScreenTitleBarLeftButton(String screenInstanceId, String navigatorEventId, ReadableMap leftButtonParams) {
+        TitleBarLeftButtonParams leftButton = new TitleBarLeftButtonParamsParser()
+                .parseSingleButton(BundleConverter.toBundle(leftButtonParams));
+        NavigationCommandsHandler.setScreenTitleBarLeftButtons(screenInstanceId, navigatorEventId, leftButton);
+    }
+
+    @ReactMethod
+    public void setTabBadge(final ReadableMap params) {
+    }
+
+    @ReactMethod
+    public void selectBottomTab(final ReadableMap params) {
+    }
+
+    @ReactMethod
+    public void toggleSideMenuVisible(boolean animated) {
+        NavigationCommandsHandler.toggleSideMenuVisible(animated);
+    }
+
+    @ReactMethod
+    public void setSideMenuVisible(boolean animated, boolean visible) {
+        NavigationCommandsHandler.setSideMenuVisible(animated, visible);
+    }
+
+    @ReactMethod
+    public void toggleTopBarVisible(final ReadableMap params) {
+    }
+
+    @ReactMethod
+    public void setTopBarVisible(String screenInstanceId, boolean hidden, boolean animated) {
+        NavigationCommandsHandler.setTopBarVisible(screenInstanceId, hidden, animated);
+    }
+
+    @ReactMethod
+    public void toggleBottomTabsVisible(final ReadableMap params) {
+    }
+
+    @ReactMethod
+    public void setBottomTabsVisible(boolean hidden, boolean animated) {
+        NavigationCommandsHandler.setBottomTabsVisible(hidden, animated);
+    }
+
+    @ReactMethod
+    public void push(final ReadableMap params) {
+        NavigationCommandsHandler.push(BundleConverter.toBundle(params));
+    }
+
+    @ReactMethod
+    public void pop(final ReadableMap params) {
+        NavigationCommandsHandler.pop(BundleConverter.toBundle(params));
+    }
+
+    @ReactMethod
+    public void popToRoot(final ReadableMap params) {
+        NavigationCommandsHandler.popToRoot(BundleConverter.toBundle(params));
+    }
+
+    @ReactMethod
+    public void newStack(final ReadableMap params) {
+        NavigationCommandsHandler.newStack(BundleConverter.toBundle(params));
+    }
+
+    @ReactMethod
+    public void showModal(final ReadableMap params) {
+        NavigationCommandsHandler.showModal(BundleConverter.toBundle(params));
+    }
+
+    @ReactMethod
+    public void dismissAllModals() {
+        NavigationCommandsHandler.dismissAllModals();
+    }
+
+    @ReactMethod
+    public void dismissTopModal() {
+        NavigationCommandsHandler.dismissTopModal();
+    }
+}

android/app/src/main/java/com/reactnativenavigation/packages/RnnPackage.java → android/app/src/main/java/com/reactnativenavigation/bridge/NavigationReactPackage.java

@@ -1,22 +1,21 @@
-package com.reactnativenavigation.packages;
+package com.reactnativenavigation.bridge;
 
 import com.facebook.react.ReactPackage;
 import com.facebook.react.bridge.JavaScriptModule;
 import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.uimanager.ViewManager;
-import com.reactnativenavigation.modules.RctActivityModule;
 
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 
-public class RnnPackage implements ReactPackage {
+public class NavigationReactPackage implements ReactPackage {
 
     @Override
     public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
         return Arrays.<NativeModule>asList(
-                new RctActivityModule(reactContext)
+                new NavigationReactModule(reactContext)
         );
     }
 

android/app/src/main/java/com/reactnativenavigation/controllers/Modal.java

@@ -0,0 +1,115 @@
+package com.reactnativenavigation.controllers;
+
+import android.app.Dialog;
+import android.content.DialogInterface;
+import android.support.v7.app.AppCompatActivity;
+import android.view.Window;
+import android.view.WindowManager;
+
+import com.reactnativenavigation.R;
+import com.reactnativenavigation.layouts.Layout;
+import com.reactnativenavigation.layouts.ScreenStackContainer;
+import com.reactnativenavigation.layouts.SingleScreenLayout;
+import com.reactnativenavigation.params.ScreenParams;
+import com.reactnativenavigation.params.TitleBarButtonParams;
+import com.reactnativenavigation.params.TitleBarLeftButtonParams;
+
+import java.util.List;
+
+public class Modal extends Dialog implements DialogInterface.OnDismissListener, ScreenStackContainer {
+
+    private final AppCompatActivity activity;
+    private final OnModalDismissedListener onModalDismissedListener;
+    private final ScreenParams screenParams;
+    private Layout layout;
+
+    public void setTopBarVisible(String screenInstanceId, boolean hidden, boolean animated) {
+        layout.setTopBarVisible(screenInstanceId, hidden, animated);
+    }
+
+    public void setTitleBarTitle(String screenInstanceId, String title) {
+        layout.setTitleBarTitle(screenInstanceId, title);
+    }
+
+    public void setTitleBarRightButtons(String screenInstanceId, String navigatorEventId, List<TitleBarButtonParams> titleBarButtons) {
+        layout.setTitleBarRightButtons(screenInstanceId, navigatorEventId, titleBarButtons);
+    }
+
+    public void setTitleBarLeftButton(String screenInstanceId, String navigatorEventId, TitleBarLeftButtonParams titleBarLeftButton) {
+        layout.setTitleBarLeftButton(screenInstanceId, navigatorEventId, titleBarLeftButton);
+    }
+
+    @Override
+    public boolean onTitleBarBackButtonClick() {
+        if (!layout.onBackPressed()) {
+            onBackPressed();
+        }
+        return true;
+    }
+
+    public void onSideMenuButtonClick() {
+    }
+
+    public interface OnModalDismissedListener {
+        void onModalDismissed(Modal modal);
+    }
+
+    public Modal(AppCompatActivity activity, OnModalDismissedListener onModalDismissedListener, ScreenParams screenParams) {
+        super(activity, R.style.Modal);
+        this.activity = activity;
+        this.onModalDismissedListener = onModalDismissedListener;
+        this.screenParams = screenParams;
+        createContent();
+    }
+
+    public AppCompatActivity getActivity() {
+        return activity;
+    }
+
+    private void createContent() {
+        setCancelable(true);
+        setOnDismissListener(this);
+        requestWindowFeature(Window.FEATURE_NO_TITLE);
+        layout = new SingleScreenLayout(getActivity(), screenParams, this);
+        getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE);
+        setContentView(layout.asView());
+    }
+
+    @Override
+    public void push(ScreenParams params) {
+        layout.push(params);
+    }
+
+    @Override
+    public void pop(ScreenParams screenParams) {
+        layout.pop(screenParams);
+    }
+
+    @Override
+    public void popToRoot(ScreenParams params) {
+        layout.popToRoot(params);
+    }
+
+    @Override
+    public void newStack(ScreenParams params) {
+        layout.newStack(params);
+    }
+
+    @Override
+    public void destroy() {
+        layout.destroy();
+    }
+
+    @Override
+    public void onBackPressed() {
+        if (!layout.onBackPressed()) {
+            super.onBackPressed();
+        }
+    }
+
+    @Override
+    public void onDismiss(DialogInterface dialog) {
+        destroy();
+        onModalDismissedListener.onModalDismissed(this);
+    }
+}

android/app/src/main/java/com/reactnativenavigation/controllers/ModalController.java

@@ -1,63 +1,110 @@
 package com.reactnativenavigation.controllers;
 
-import android.support.annotation.Nullable;
+import android.support.v7.app.AppCompatActivity;
 
-import com.reactnativenavigation.modal.RnnModal;
-import com.reactnativenavigation.utils.RefUtils;
+import com.reactnativenavigation.layouts.ScreenStackContainer;
+import com.reactnativenavigation.params.ScreenParams;
+import com.reactnativenavigation.params.TitleBarButtonParams;
+import com.reactnativenavigation.params.TitleBarLeftButtonParams;
 
-import java.lang.ref.WeakReference;
+import java.util.List;
 import java.util.Stack;
 
-/**
- * Created by guyc on 06/05/16.
- */
-public class ModalController {
-    private static ModalController sInstance;
+public class ModalController implements ScreenStackContainer, Modal.OnModalDismissedListener {
+    private final AppCompatActivity activity;
+    private Stack<Modal> stack = new Stack<>();
 
-    private final Stack<WeakReference<RnnModal>> mModals;
+    public ModalController(AppCompatActivity activity) {
+        this.activity = activity;
+    }
+
+    public void showModal(ScreenParams screenParams) {
+        Modal modal = new Modal(activity, this, screenParams);
+        modal.show();
+        stack.add(modal);
+    }
 
-    private ModalController() {
-        mModals = new Stack<>();
+    public void dismissTopModal() {
+        if (isShowing()) {
+            stack.pop().dismiss();
+        }
     }
 
-    public static synchronized ModalController getInstance() {
-        if (sInstance == null) {
-            sInstance = new ModalController();
+    public void dismissAllModals() {
+        while (isShowing()) {
+            dismissTopModal();
         }
+    }
 
-        return sInstance;
+    public boolean isShowing() {
+        return !stack.empty();
     }
 
-    public void add(RnnModal modal) {
-        mModals.add(new WeakReference<>(modal));
+    public void push(ScreenParams params) {
+        stack.peek().push(params);
     }
 
-    public boolean isModalDisplayed() {
-        return mModals.size() != 0;
+    @Override
+    public void pop(ScreenParams screenParams) {
+        stack.peek().pop(screenParams);
     }
 
-    @Nullable
-    public RnnModal get() {
-        return isModalDisplayed() ? RefUtils.get(mModals.peek()) : null;
+    @Override
+    public void popToRoot(ScreenParams params) {
+        stack.peek().popToRoot(params);
     }
 
-    public void remove() {
-        if (isModalDisplayed()) {
-            mModals.pop();
+    @Override
+    public void newStack(ScreenParams params) {
+        stack.peek().newStack(params);
+    }
+
+    @Override
+    public void destroy() {
+        for (Modal modal : stack) {
+            modal.destroy();
+            modal.dismiss();
         }
+        stack.clear();
     }
 
-    public void dismissAllModals() {
-        while (isModalDisplayed()) {
-            dismissModal();
+    @Override
+    public void onModalDismissed(Modal modal) {
+        stack.remove(modal);
+    }
+
+    public void setTopBarVisible(String screenInstanceId, boolean hidden, boolean animated) {
+        for (Modal modal : stack) {
+            modal.setTopBarVisible(screenInstanceId, hidden, animated);
         }
     }
 
-    public void dismissModal() {
-        WeakReference<RnnModal> ref = mModals.pop();
-        RnnModal modal = RefUtils.get(ref);
-        if (modal != null) {
-            modal.dismiss();
+    public void setTitleBarTitle(String screenInstanceId, String title) {
+        for (Modal modal : stack) {
+            modal.setTitleBarTitle(screenInstanceId, title);
+        }
+    }
+
+    public void setTitleBarRightButtons(String screenInstanceId, String navigatorEventId, List<TitleBarButtonParams> titleBarButtons) {
+        for (Modal modal : stack) {
+            modal.setTitleBarRightButtons(screenInstanceId, navigatorEventId, titleBarButtons);
         }
     }
+
+    public void setTitleBarLeftButton(String screenInstanceId, String navigatorEventId, TitleBarLeftButtonParams titleBarLeftButton) {
+        for (Modal modal : stack) {
+            modal.setTitleBarLeftButton(screenInstanceId, navigatorEventId, titleBarLeftButton);
+        }
+    }
+
+    @Override
+    public boolean onTitleBarBackButtonClick() {
+        // Do nothing and let the layout handle the back button click
+        return false;
+    }
+
+    @Override
+    public void onSideMenuButtonClick() {
+        // Do nothing and let the layout handle the click
+    }
 }

android/app/src/main/java/com/reactnativenavigation/controllers/NavigationActivity.java

@@ -0,0 +1,215 @@
+package com.reactnativenavigation.controllers;
+
+import android.content.Intent;
+import android.os.Bundle;
+import android.support.v7.app.AppCompatActivity;
+import android.view.KeyEvent;
+
+import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
+import com.reactnativenavigation.NavigationApplication;
+import com.reactnativenavigation.layouts.BottomTabsLayout;
+import com.reactnativenavigation.layouts.Layout;
+import com.reactnativenavigation.layouts.LayoutFactory;
+import com.reactnativenavigation.params.ActivityParams;
+import com.reactnativenavigation.params.ScreenParams;
+import com.reactnativenavigation.params.TitleBarButtonParams;
+import com.reactnativenavigation.params.TitleBarLeftButtonParams;
+import com.reactnativenavigation.react.JsDevReloadHandler;
+import com.reactnativenavigation.react.ReactGateway;
+import com.reactnativenavigation.react.RedboxPermission;
+import com.reactnativenavigation.utils.IntentUtils;
+
+import java.util.List;
+
+public class NavigationActivity extends AppCompatActivity implements DefaultHardwareBackBtnHandler, ReactGateway.OnJsDevReloadListener {
+
+    /**
+     * Although we start multiple activities, we make sure to pass Intent.CLEAR_TASK | Intent.NEW_TASK
+     * So that we actually have only 1 instance of the activity running at one time.
+     * We hold the currentActivity (resume->pause) so we know when we need to destroy the javascript context
+     * (when currentActivity is null, ie pause and destroy was called without resume).
+     * This is somewhat weird, and in the future we better use a single activity with changing contentView similar to ReactNative impl.
+     * Along with that, we should handle commands from the bridge using onNewIntent
+     */
+    static NavigationActivity currentActivity;
+
+    private ActivityParams activityParams;
+    private ModalController modalController;
+    private Layout layout;
+    private boolean waitingForNewJsContext = false;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        if (!NavigationApplication.instance.isReactContextInitialized()) {
+            waitingForNewJsContext = true;
+            finish();
+            startActivity(IntentUtils.getLauncherIntent());
+            return;
+        }
+
+        RedboxPermission.permissionToShowRedboxIfNeeded(this);
+
+        activityParams = NavigationCommandsHandler.parseActivityParams(getIntent());
+
+        createLayout();
+        createModalController();
+    }
+
+    private void createModalController() {
+        modalController = new ModalController(this);
+    }
+
+    private void createLayout() {
+        layout = LayoutFactory.create(this, activityParams);
+        setContentView(layout.asView());
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+        if (isFinishing()) {
+            return;
+        }
+
+        currentActivity = this;
+        NavigationApplication.instance.getReactGateway().onResumeActivity(this, this, this);
+    }
+
+    @Override
+    protected void onPause() {
+        super.onPause();
+        currentActivity = null;
+        NavigationApplication.instance.getReactGateway().onPauseActivity();
+    }
+
+    @Override
+    protected void onDestroy() {
+        destroyLayouts();
+        destroyJsIfNeeded();
+        super.onDestroy();
+    }
+
+    private void destroyLayouts() {
+        if (modalController != null) {
+            modalController.destroy();
+        }
+        if (layout != null) {
+            layout.destroy();
+        }
+    }
+
+    private void destroyJsIfNeeded() {
+        if (!waitingForNewJsContext && (currentActivity == null || currentActivity.isFinishing())) {
+            NavigationApplication.instance.getReactGateway().onDestroyApp();
+        }
+    }
+
+    @Override
+    public void onJsDevReload() {
+        modalController.destroy();
+        layout.destroy();
+    }
+
+    @Override
+    public void invokeDefaultOnBackPressed() {
+        super.onBackPressed();
+    }
+
+    @Override
+    public void onBackPressed() {
+        if (!layout.onBackPressed()) {
+            NavigationApplication.instance.getReactGateway().onBackPressed();
+        }
+    }
+
+    @Override
+    public void onActivityResult(int requestCode, int resultCode, Intent data) {
+        NavigationApplication.instance.getReactGateway().onActivityResult(requestCode, resultCode, data);
+    }
+
+    @Override
+    public boolean onKeyUp(int keyCode, KeyEvent event) {
+        return JsDevReloadHandler.onKeyUp(getCurrentFocus(), keyCode) || super.onKeyUp(keyCode, event);
+    }
+
+    void push(ScreenParams params) {
+        if (modalController.isShowing()) {
+            modalController.push(params);
+        } else {
+            layout.push(params);
+        }
+    }
+
+    void pop(ScreenParams params) {
+        if (modalController.isShowing()) {
+            modalController.pop(params);
+        } else {
+            layout.pop(params);
+        }
+    }
+
+    void popToRoot(ScreenParams params) {
+        if (modalController.isShowing()) {
+            modalController.popToRoot(params);
+        } else {
+            layout.popToRoot(params);
+        }
+    }
+
+    void newStack(ScreenParams params) {
+        if (modalController.isShowing()) {
+            modalController.newStack(params);
+        } else {
+            layout.newStack(params);
+        }
+    }
+
+    void showModal(ScreenParams screenParams) {
+        modalController.showModal(screenParams);
+    }
+
+    void dismissTopModal() {
+        modalController.dismissTopModal();
+    }
+
+    void dismissAllModals() {
+        modalController.dismissAllModals();
+    }
+
+    //TODO all these setters should be combined to something like setStyle
+    void setTopBarVisible(String screenInstanceId, boolean hidden, boolean animated) {
+        layout.setTopBarVisible(screenInstanceId, hidden, animated);
+        modalController.setTopBarVisible(screenInstanceId, hidden, animated);
+    }
+
+    void setBottomTabsVisible(boolean hidden, boolean animated) {
+        if (layout instanceof BottomTabsLayout) {
+            ((BottomTabsLayout) layout).setBottomTabsVisible(hidden, animated);
+        }
+    }
+
+    void setTitleBarTitle(String screenInstanceId, String title) {
+        layout.setTitleBarTitle(screenInstanceId, title);
+        modalController.setTitleBarTitle(screenInstanceId, title);
+    }
+
+    void setTitleBarButtons(String screenInstanceId, String navigatorEventId, List<TitleBarButtonParams> titleBarButtons) {
+        layout.setTitleBarRightButtons(screenInstanceId, navigatorEventId, titleBarButtons);
+        modalController.setTitleBarRightButtons(screenInstanceId, navigatorEventId, titleBarButtons);
+    }
+
+    void setTitleBarLeftButton(String screenInstanceId, String navigatorEventId, TitleBarLeftButtonParams titleBarLeftButton) {
+        layout.setTitleBarLeftButton(screenInstanceId, navigatorEventId, titleBarLeftButton);
+        modalController.setTitleBarLeftButton(screenInstanceId, navigatorEventId, titleBarLeftButton);
+    }
+
+    public void toggleSideMenuVisible(boolean animated) {
+        layout.toggleSideMenuVisible(animated);
+    }
+
+    public void setSideMenuVisible(boolean animated, boolean visible) {
+        layout.setSideMenuVisible(animated, visible);
+    }
+}

android/app/src/main/java/com/reactnativenavigation/controllers/NavigationCommandsHandler.java

@@ -0,0 +1,241 @@
+package com.reactnativenavigation.controllers;
+
+import android.content.Intent;
+import android.os.Bundle;
+
+import com.reactnativenavigation.NavigationApplication;
+import com.reactnativenavigation.params.ActivityParams;
+import com.reactnativenavigation.params.ScreenParams;
+import com.reactnativenavigation.params.TitleBarButtonParams;
+import com.reactnativenavigation.params.TitleBarLeftButtonParams;
+import com.reactnativenavigation.params.parsers.ActivityParamsParser;
+import com.reactnativenavigation.params.parsers.ScreenParamsParser;
+
+import java.util.List;
+
+public class NavigationCommandsHandler {
+
+    private static final String ACTIVITY_PARAMS_BUNDLE = "ACTIVITY_PARAMS_BUNDLE";
+
+    static ActivityParams parseActivityParams(Intent intent) {
+        return ActivityParamsParser.parse(intent.getBundleExtra(NavigationCommandsHandler.ACTIVITY_PARAMS_BUNDLE));
+    }
+
+    /**
+     * start a new activity with CLEAR_TASK | NEW_TASK
+     *
+     * @param params ActivityParams as bundle
+     */
+    public static void startApp(Bundle params) {
+        Intent intent = new Intent(NavigationApplication.instance, NavigationActivity.class);
+        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_NEW_TASK);
+        intent.putExtra(ACTIVITY_PARAMS_BUNDLE, params);
+        NavigationApplication.instance.startActivity(intent);
+    }
+
+    public static void push(Bundle screenParams) {
+        final NavigationActivity currentActivity = NavigationActivity.currentActivity;
+        if (currentActivity == null) {
+            return;
+        }
+
+        final ScreenParams params = ScreenParamsParser.parse(screenParams);
+        NavigationApplication.instance.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                currentActivity.push(params);
+            }
+        });
+    }
+
+    public static void pop(Bundle screenParams) {
+        final NavigationActivity currentActivity = NavigationActivity.currentActivity;
+        if (currentActivity == null) {
+            return;
+        }
+
+        final ScreenParams params = ScreenParamsParser.parse(screenParams);
+        NavigationApplication.instance.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                currentActivity.pop(params);
+            }
+        });
+    }
+
+    public static void popToRoot(Bundle screenParams) {
+        final NavigationActivity currentActivity = NavigationActivity.currentActivity;
+        if (currentActivity == null) {
+            return;
+        }
+
+        final ScreenParams params = ScreenParamsParser.parse(screenParams);
+        NavigationApplication.instance.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                currentActivity.popToRoot(params);
+            }
+        });
+    }
+
+    public static void newStack(Bundle screenParams) {
+        final NavigationActivity currentActivity = NavigationActivity.currentActivity;
+        if (currentActivity == null) {
+            return;
+        }
+
+        final ScreenParams params = ScreenParamsParser.parse(screenParams);
+        NavigationApplication.instance.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                currentActivity.newStack(params);
+            }
+        });
+    }
+
+    public static void setTopBarVisible(final String screenInstanceID, final boolean hidden, final boolean animated) {
+        final NavigationActivity currentActivity = NavigationActivity.currentActivity;
+        if (currentActivity == null) {
+            return;
+        }
+
+        NavigationApplication.instance.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                currentActivity.setTopBarVisible(screenInstanceID, hidden, animated);
+            }
+        });
+    }
+
+    public static void setBottomTabsVisible(final boolean hidden, final boolean animated) {
+        final NavigationActivity currentActivity = NavigationActivity.currentActivity;
+        if (currentActivity == null) {
+            return;
+        }
+
+        NavigationApplication.instance.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                currentActivity.setBottomTabsVisible(hidden, animated);
+            }
+        });
+    }
+
+    public static void setScreenTitleBarTitle(final String screenInstanceId, final String title) {
+        final NavigationActivity currentActivity = NavigationActivity.currentActivity;
+        if (currentActivity == null) {
+            return;
+        }
+
+        NavigationApplication.instance.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                currentActivity.setTitleBarTitle(screenInstanceId, title);
+            }
+        });
+    }
+
+    public static void showModal(Bundle params) {
+        final NavigationActivity currentActivity = NavigationActivity.currentActivity;
+        if (currentActivity == null) {
+            return;
+        }
+
+        final ScreenParams screenParams = ScreenParamsParser.parse(params);
+
+        NavigationApplication.instance.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                currentActivity.showModal(screenParams);
+            }
+        });
+    }
+
+    public static void setScreenTitleBarRightButtons(final String screenInstanceId,
+                                                     final String navigatorEventId,
+                                                     final List<TitleBarButtonParams> titleBarButtons) {
+        final NavigationActivity currentActivity = NavigationActivity.currentActivity;
+        if (currentActivity == null) {
+            return;
+        }
+
+        NavigationApplication.instance.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                currentActivity.setTitleBarButtons(screenInstanceId, navigatorEventId, titleBarButtons);
+            }
+        });
+    }
+
+    public static void setScreenTitleBarLeftButtons(final String screenInstanceId,
+                                                     final String navigatorEventId,
+                                                     final TitleBarLeftButtonParams titleBarButtons) {
+        final NavigationActivity currentActivity = NavigationActivity.currentActivity;
+        if (currentActivity == null) {
+            return;
+        }
+
+        NavigationApplication.instance.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                currentActivity.setTitleBarLeftButton(screenInstanceId, navigatorEventId, titleBarButtons);
+            }
+        });
+    }
+
+    public static void dismissTopModal() {
+        final NavigationActivity currentActivity = NavigationActivity.currentActivity;
+        if (currentActivity == null) {
+            return;
+        }
+
+        NavigationApplication.instance.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                currentActivity.dismissTopModal();
+            }
+        });
+    }
+
+    public static void dismissAllModals() {
+        final NavigationActivity currentActivity = NavigationActivity.currentActivity;
+        if (currentActivity == null) {
+            return;
+        }
+
+        NavigationApplication.instance.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                currentActivity.dismissAllModals();
+            }
+        });
+    }
+
+    public static void toggleSideMenuVisible(final boolean animated) {
+        final NavigationActivity currentActivity = NavigationActivity.currentActivity;
+        if (currentActivity == null) {
+            return;
+        }
+
+        NavigationApplication.instance.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                currentActivity.toggleSideMenuVisible(animated);
+            }
+        });
+    }
+
+    public static void setSideMenuVisible(final boolean animated, final boolean visible) {
+        final NavigationActivity currentActivity = NavigationActivity.currentActivity;
+        if (currentActivity == null) {
+            return;
+        }
+
+        NavigationApplication.instance.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                currentActivity.setSideMenuVisible(animated, visible);
+            }
+        });
+    }
+}

android/app/src/main/java/com/reactnativenavigation/controllers/SplashActivity.java

@@ -0,0 +1,57 @@
+package com.reactnativenavigation.controllers;
+
+import android.graphics.Color;
+import android.os.Bundle;
+import android.support.annotation.LayoutRes;
+import android.support.annotation.Nullable;
+import android.support.v7.app.AppCompatActivity;
+import android.view.View;
+
+import com.reactnativenavigation.NavigationApplication;
+
+public abstract class SplashActivity extends AppCompatActivity {
+
+    @Override
+    protected void onCreate(@Nullable Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setSplashLayout();
+
+        if (NavigationApplication.instance.isReactContextInitialized()) {
+            finish();
+        } else {
+            NavigationApplication.instance.startReactContext();
+        }
+    }
+
+    @Override
+    protected void onPause() {
+        super.onPause();
+        finish();
+    }
+
+    private void setSplashLayout() {
+        final int splashLayout = getSplashLayout();
+        if (splashLayout > 0) {
+            setContentView(splashLayout);
+        } else {
+            setContentView(createSplashLayout());
+        }
+    }
+
+    /**
+     * @return xml layout res id
+     */
+    @LayoutRes
+    public int getSplashLayout() {
+        return 0;
+    }
+
+    /**
+     * @return the layout you would like to show while react's js context loads
+     */
+    public View createSplashLayout() {
+        View view = new View(this);
+        view.setBackgroundColor(Color.WHITE);
+        return view;
+    }
+}

android/app/src/main/java/com/reactnativenavigation/core/RctManager.java

@@ -1,204 +0,0 @@
-package com.reactnativenavigation.core;
-
-import android.app.Application;
-import android.util.Log;
-
-import com.facebook.react.LifecycleState;
-import com.facebook.react.ReactInstanceManager;
-import com.facebook.react.ReactPackage;
-import com.facebook.react.bridge.JavaJSExecutor;
-import com.facebook.react.bridge.ReactContext;
-import com.facebook.react.bridge.ReactContextBaseJavaModule;
-import com.facebook.react.bridge.WritableMap;
-import com.facebook.react.devsupport.DevSupportManager;
-import com.facebook.react.devsupport.ReactInstanceDevCommandsHandler;
-import com.reactnativenavigation.activities.BaseReactActivity;
-import com.reactnativenavigation.core.objects.Screen;
-import com.reactnativenavigation.utils.ContextProvider;
-import com.reactnativenavigation.utils.ReflectionUtils;
-
-import static com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter;
-
-/**
- * Created by guyc on 22/02/16.
- */
-public class RctManager {
-    private static final String TAG = "RctManager";
-    private static final String KEY_EVENT_ID = "id";
-    private static final String KEY_EVENT_TYPE = "type";
-    private static final String EVENT_TYPE = "NavBarButtonPress";
-    private static RctManager sInstance;
-
-    private ReactInstanceManager mReactManager;
-
-    private RctManager() {
-        // Singleton
-    }
-
-    public static synchronized RctManager getInstance() {
-        if (sInstance == null) {
-            sInstance = new RctManager();
-        }
-        return sInstance;
-    }
-
-    public ReactInstanceManager getReactInstanceManager() {
-        return mReactManager;
-    }
-
-    public boolean isInitialized() {
-        return mReactManager != null;
-    }
-
-    public void init(BaseReactActivity context) {
-        createReactInstanceManager(context);
-    }
-
-    /**
-     * Creates a React Instance Manager associated with this component name
-     */
-    public ReactInstanceManager createReactInstanceManager(BaseReactActivity reactActivity) {
-        ReactInstanceManager.Builder builder = ReactInstanceManager.builder()
-                .setApplication((Application) reactActivity.getApplicationContext())
-                .setJSMainModuleName(reactActivity.getJSMainModuleName())
-                .setUseDeveloperSupport(reactActivity.getUseDeveloperSupport())
-                .setInitialLifecycleState(LifecycleState.BEFORE_RESUME);
-
-        for (ReactPackage reactPackage : reactActivity.getPackages()) {
-            builder.addPackage(reactPackage);
-        }
-
-        String jsBundleFile = reactActivity.getJSBundleFile();
-
-        if (jsBundleFile != null) {
-            builder.setJSBundleFile(jsBundleFile);
-        } else {
-            builder.setBundleAssetName(reactActivity.getBundleAssetName());
-        }
-
-        mReactManager = builder.build();
-        if (reactActivity.getUseDeveloperSupport()) {
-            setupDevSupportHandler(mReactManager);
-        }
-        return mReactManager;
-    }
-
-    /**
-     * Inject our CustomDevCommandsHandler to {@code reactInstanceManager} so we can detect when the bundle was
-     * parsed and is about to load.
-     * @param reactInstanceManager
-     */
-    private void setupDevSupportHandler(ReactInstanceManager reactInstanceManager) {
-        final ReactInstanceDevCommandsHandler devInterface = (ReactInstanceDevCommandsHandler)
-                ReflectionUtils.getDeclaredField(reactInstanceManager, "mDevInterface");
-        if (devInterface == null) {
-            Log.e(TAG, "Could not get field mDevInterface");
-            return;
-        }
-
-        // Create customDevCommandsHandler
-        CustomDevCommandsHandler customDevCommandsHandler = new CustomDevCommandsHandler(devInterface);
-        boolean success = ReflectionUtils.setField(reactInstanceManager, "mDevInterface", customDevCommandsHandler);
-        if (!success) {
-            Log.e(TAG, "Could not set field mDevInterface");
-            return;
-        }
-
-        // Set customDevCommandsHandler in devSupportManager. Fun =).
-        DevSupportManager devSupportManager = (DevSupportManager)
-                ReflectionUtils.getDeclaredField(reactInstanceManager, "mDevSupportManager");
-        if (devSupportManager == null) {
-            Log.e(TAG, "Could not get field mDevSupportManager");
-            return;
-        }
-
-        success = ReflectionUtils.setField(devSupportManager, "mReactInstanceCommandsHandler", customDevCommandsHandler);
-        if (!success) {
-            Log.e(TAG, "Could not set field mReactInstanceCommandsHandler");
-        }
-    }
-
-    public <T extends ReactContextBaseJavaModule> T getNativeModule(Class<T> nativeModuleClass) {
-        if (mReactManager == null || mReactManager.getCurrentReactContext() == null) {
-            return null;
-        }
-
-        return mReactManager.getCurrentReactContext().getNativeModule(nativeModuleClass);
-    }
-
-    /**
-     * Sends an event to JavaScript using <a href="https://facebook.github.io/react-native/docs/native-modules-android.html#sending-events-to-javascript">RCTDeviceEventEmitter</a>
-     * @param eventName Name of the event
-     * @param params Event params
-     * @param screen screen which should receive the event
-     */
-    public void sendEvent(String eventName, Screen screen, WritableMap params) {
-        RCTDeviceEventEmitter eventEmitter = getEventEmitter();
-        if (eventEmitter == null) {
-            return;
-        }
-
-        params.putString(KEY_EVENT_TYPE, EVENT_TYPE);
-        params.putString(KEY_EVENT_ID, eventName);
-        params.putString(Screen.KEY_NAVIGATOR_EVENT_ID, screen.navigatorEventId);
-        eventEmitter.emit(screen.navigatorEventId, params);
-    }
-
-    private RCTDeviceEventEmitter getEventEmitter() {
-        if (mReactManager == null) {
-            return null;
-        }
-
-        ReactContext currentReactContext = mReactManager.getCurrentReactContext();
-        if (currentReactContext == null) {
-            return null;
-        }
-
-        return currentReactContext.getJSModule(RCTDeviceEventEmitter.class);
-    }
-
-    public void onDestroy() {
-        mReactManager = null;
-        sInstance = null;
-    }
-
-    /**
-     * Proxy for {@link ReactInstanceDevCommandsHandler} used by {@link DevSupportManager} for requesting React
-     * instance recreation. Used to notify {@link BaseReactActivity} that the bundle has been reloaded.
-     */
-    private static class CustomDevCommandsHandler implements ReactInstanceDevCommandsHandler {
-        private ReactInstanceDevCommandsHandler mCommandsHandler;
-
-        public CustomDevCommandsHandler(ReactInstanceDevCommandsHandler commandsHandler) {
-            mCommandsHandler = commandsHandler;
-        }
-
-        @Override
-        public void onReloadWithJSDebugger(JavaJSExecutor.Factory proxyExecutorFactory) {
-            onJSBundleReloaded();
-            mCommandsHandler.onReloadWithJSDebugger(proxyExecutorFactory);
-        }
-
-        @Override
-        public void onJSBundleLoadedFromServer() {
-            onJSBundleReloaded();
-            mCommandsHandler.onJSBundleLoadedFromServer();
-        }
-
-        /**
-         * Detach previously added ReactRootViews before handling bundle.
-         */
-        private void onJSBundleReloaded() {
-            BaseReactActivity context = ContextProvider.getActivityContext();
-            if (context != null) {
-                context.onJSBundleReloaded();
-            }
-        }
-
-        @Override
-        public void toggleElementInspector() {
-            mCommandsHandler.toggleElementInspector();
-        }
-    }
-}
-

android/app/src/main/java/com/reactnativenavigation/core/objects/Button.java

@@ -1,80 +0,0 @@
-package com.reactnativenavigation.core.objects;
-
-import android.content.Context;
-import android.graphics.drawable.Drawable;
-import android.view.MenuItem;
-
-import com.facebook.react.bridge.ReadableMap;
-import com.reactnativenavigation.utils.IconUtils;
-
-import java.io.Serializable;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.concurrent.atomic.AtomicInteger;
-
-/**
- * Created by guyc on 08/04/16.
- */
-public class Button extends JsonObject implements Serializable {
-    private static final long serialVersionUID = -570145217281069067L;
-
-    private static final String KEY_ID = "id";
-    private static final String KEY_TITLE = "title";
-    private static final String KEY_ICON = "icon";
-    private static final String KEY_DISABLED = "disabled";
-    private static final String KEY_SHOW_AS_ACTION = "showAsAction";
-
-    public String id;
-    public String title;
-    private String mIconSource;
-    public boolean disabled;
-    public String showAsAction;
-
-    private static final AtomicInteger sAtomicIdGenerator = new AtomicInteger();
-    private static final Map<String, Integer> sStringToNumericId = new HashMap<>();
-
-    public Button(ReadableMap button) {
-        id = getString(button, KEY_ID);
-        title = getString(button, KEY_TITLE, "");
-        mIconSource = getString(button, KEY_ICON);
-        disabled = getBoolean(button, KEY_DISABLED);
-        showAsAction = getString(button, KEY_SHOW_AS_ACTION, "");
-    }
-
-    public boolean hasIcon() {
-        return mIconSource != null;
-    }
-
-    /**
-     * @param dimensions The requested icon dimensions
-     */
-    public Drawable getIcon(Context ctx, int dimensions) {
-       return IconUtils.getIcon(ctx, mIconSource, dimensions);
-    }
-
-    public int getItemId() {
-        if (sStringToNumericId.containsKey(id)) {
-            return sStringToNumericId.get(id);
-        }
-
-        int itemId = sAtomicIdGenerator.addAndGet(1);
-        sStringToNumericId.put(id, itemId);
-        return itemId;
-    }
-
-    /**
-     * Each button has a string id, defined in JS, which is used to identify the button when
-     * handling events.
-     * @param item Toolbar button
-     * @return Returns the event id associated with the given menu item
-     */
-    public static String getButtonEventId(MenuItem item) {
-        for (Map.Entry<String, Integer> entry : sStringToNumericId.entrySet()) {
-            if (entry.getValue() == item.getItemId()) {
-                return entry.getKey();
-            }
-        }
-
-        return null;
-    }
-}

android/app/src/main/java/com/reactnativenavigation/core/objects/Drawer.java

@@ -1,23 +0,0 @@
-package com.reactnativenavigation.core.objects;
-
-import com.facebook.react.bridge.ReadableMap;
-
-import java.io.Serializable;
-
-public class Drawer extends JsonObject implements Serializable {
-    private static final long serialVersionUID = 982836768712398756L;
-
-    private static final String KEY_LEFT = "left";
-    private static final String KEY_RIGHT = "right";
-    private static final String KEY_DISABLE_OPEN_GESTURE = "disableOpenGesture";
-
-    public final Screen left;
-    public final Screen right;
-    public final boolean disableOpenGesture;
-
-    public Drawer(ReadableMap params) {
-        left = params.hasKey(KEY_LEFT) ? new Screen(params.getMap(KEY_LEFT)) : null;
-        right = params.hasKey(KEY_RIGHT) ? new Screen(params.getMap(KEY_RIGHT)) : null;
-        disableOpenGesture = getBoolean(params, KEY_DISABLE_OPEN_GESTURE);
-    }
-}

android/app/src/main/java/com/reactnativenavigation/core/objects/JsonObject.java

@@ -1,35 +0,0 @@
-package com.reactnativenavigation.core.objects;
-
-import android.graphics.Color;
-
-import com.facebook.react.bridge.ReadableMap;
-
-/**
- * Created by guyc on 08/04/16.
- */
-public class JsonObject {
-
-    protected String getString(ReadableMap map, String key) {
-        return getString(map, key, null);
-    }
-
-    protected String getString(ReadableMap map, String key, String defaultValue) {
-        return map.hasKey(key) ? map.getString(key) : defaultValue;
-    }
-
-    protected int getInt(ReadableMap map, String key) {
-        return map.hasKey(key) ? map.getInt(key) : -1;
-    }
-
-    protected ReadableMap getMap(ReadableMap map, String key) {
-        return map.hasKey(key) ? map.getMap(key) : null;
-    }
-
-    protected Integer getColor(ReadableMap map, String key) {
-        return map.hasKey(key) ? Color.parseColor(map.getString(key)) : null;
-    }
-    
-    protected Boolean getBoolean(ReadableMap map, String key) {
-        return map.hasKey(key) && map.getBoolean(key);
-    }
-}

android/app/src/main/java/com/reactnativenavigation/core/objects/Screen.java

@@ -1,144 +0,0 @@
-package com.reactnativenavigation.core.objects;
-
-import android.content.Context;
-import android.graphics.drawable.Drawable;
-import android.support.annotation.ColorInt;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
-import android.util.Log;
-
-import com.facebook.react.bridge.ReadableArray;
-import com.facebook.react.bridge.ReadableMap;
-import com.facebook.react.bridge.ReadableNativeMap;
-import com.reactnativenavigation.utils.IconUtils;
-
-import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-
-/**
- * Created by guyc on 02/04/16.
- */
-public class Screen extends JsonObject implements Serializable {
-    private static final long serialVersionUID = -1033475305421107791L;
-
-    private static final String KEY_TITLE = "title";
-    private static final String KEY_SCREEN = "screen";
-    private static final String KEY_LABEL = "label";
-    public static final String KEY_SCREEN_INSTANCE_ID = "screenInstanceID";
-    public static final String KEY_NAVIGATOR_ID = "navigatorID";
-    public static final String KEY_NAVIGATOR_EVENT_ID = "navigatorEventID";
-    private static final String KEY_ICON = "icon";
-    private static final String KEY_NAVIGATOR_BUTTONS = "navigatorButtons";
-    private static final String KEY_RIGHT_BUTTONS = "rightButtons";
-    private static final String KEY_TOOL_BAR_STYLE = "navigatorStyle";
-    private static final String KEY_STATUS_BAR_COLOR = "statusBarColor";
-    private static final String KEY_TOOL_BAR_COLOR = "navBarBackgroundColor";
-    private static final String KEY_TOOL_BAR_HIDDEN = "navBarHidden";
-    private static final String KEY_NAVIGATION_BAR_COLOR = "navigationBarColor";
-    private static final String KEY_NAV_BAR_BUTTON_COLOR = "navBarButtonColor";
-    private static final String KEY_NAV_BAR_TEXT_COLOR = "navBarTextColor";
-    private static final String KEY_BACK_BUTTON_HIDDEN = "backButtonHidden";
-    private static final String KEY_TAB_NORMAL_TEXT_COLOR = "tabNormalTextColor";
-    private static final String KEY_TAB_SELECTED_TEXT_COLOR = "tabSelectedTextColor";
-    private static final String KEY_TAB_INDICATOR_COLOR = "tabIndicatorColor";
-    private static final String KEY_BOTTOM_TABS_HIDDEN = "tabBarHidden";
-    private static final String KEY_BOTTOM_TABS_HIDDEN_ON_SCROLL = "bottomTabsHiddenOnScroll";
-    private static final String KEY_PROPS = "passProps";
-
-    public String title;
-    public final String label;
-    public final String screenId;
-    public final String screenInstanceId;
-    public final String navigatorId;
-    public final String navigatorEventId;
-    public final String icon;
-    public ArrayList<Button> buttons;
-    public final boolean backButtonHidden;
-    public boolean bottomTabsHiddenOnScroll;
-    public HashMap<String, Object> passedProps = new HashMap<>();
-
-    // Navigation styling
-    @Nullable @ColorInt public Integer toolBarColor;
-    @Nullable public Boolean toolBarHidden;
-    @Nullable @ColorInt public Integer statusBarColor;
-    @Nullable @ColorInt public Integer navigationBarColor;
-    @Nullable @ColorInt public Integer navBarButtonColor;
-    @Nullable @ColorInt public Integer navBarTextColor;
-    @Nullable @ColorInt public Integer tabNormalTextColor;
-    @Nullable @ColorInt public Integer tabSelectedTextColor;
-    @Nullable @ColorInt public Integer tabIndicatorColor;
-    public Boolean bottomTabsHidden;
-
-    @NonNull
-    public List<Button> getButtons() {
-        return buttons == null ? Collections.<Button>emptyList() : buttons;
-    }
-
-    public Screen(ReadableMap screen) {
-        title = getString(screen, KEY_TITLE);
-        label = getString(screen, KEY_LABEL);
-        screenId = getString(screen, KEY_SCREEN);
-        screenInstanceId = getString(screen, KEY_SCREEN_INSTANCE_ID);
-        navigatorId = getString(screen, KEY_NAVIGATOR_ID);
-        navigatorEventId = getString(screen, KEY_NAVIGATOR_EVENT_ID);
-        icon = getString(screen, KEY_ICON);
-        if(screen.hasKey(KEY_PROPS)) {
-            passedProps = ((ReadableNativeMap) screen.getMap(KEY_PROPS)).toHashMap();
-        }
-        buttons = getButtons(screen);
-        backButtonHidden = getBoolean(screen, KEY_BACK_BUTTON_HIDDEN);
-        setToolbarStyle(screen);
-    }
-
-    public void setTitle(ReadableMap params) {
-        this.title = getString(params, KEY_TITLE);
-    }
-
-    public void setButtons(ReadableMap params) {
-        this.buttons = getButtons(params);
-    }
-
-    private ArrayList<Button> getButtons(ReadableMap screen) {
-        ArrayList<Button> ret = new ArrayList<>();
-        if (hasButtons(screen)) {
-            ReadableArray rightButtons = getRightButtons(screen);
-            for (int i = 0; i < rightButtons.size(); i++) {
-                ret.add(new Button(rightButtons.getMap(i)));
-            }
-        }
-        return ret;
-    }
-
-    private boolean hasButtons(ReadableMap screen) {
-        return screen.hasKey(KEY_RIGHT_BUTTONS) || screen.hasKey(KEY_NAVIGATOR_BUTTONS);
-    }
-
-    private ReadableArray getRightButtons(ReadableMap screen) {
-        return screen.hasKey(KEY_RIGHT_BUTTONS) ? screen.getArray(KEY_RIGHT_BUTTONS) :
-                screen.getMap(KEY_NAVIGATOR_BUTTONS).getArray(KEY_RIGHT_BUTTONS);
-    }
-
-    public Drawable getIcon(Context ctx) {
-        return IconUtils.getIcon(ctx, icon);
-    }
-
-    public void setToolbarStyle(ReadableMap screen) {
-        ReadableMap style = getMap(screen, KEY_TOOL_BAR_STYLE);
-        if (style != null) {
-            toolBarColor = getColor(style, KEY_TOOL_BAR_COLOR);
-            toolBarHidden = getBoolean(style, KEY_TOOL_BAR_HIDDEN);
-            statusBarColor = getColor(style, KEY_STATUS_BAR_COLOR);
-            navigationBarColor = getColor(style, KEY_NAVIGATION_BAR_COLOR);
-            navBarButtonColor = getColor(style, KEY_NAV_BAR_BUTTON_COLOR);
-            navBarTextColor = getColor(style, KEY_NAV_BAR_TEXT_COLOR);
-            tabNormalTextColor = getColor(style, KEY_TAB_NORMAL_TEXT_COLOR);
-            tabSelectedTextColor = getColor(style, KEY_TAB_SELECTED_TEXT_COLOR);
-            tabIndicatorColor = getColor(style, KEY_TAB_INDICATOR_COLOR);
-            bottomTabsHidden = getBoolean(style, KEY_BOTTOM_TABS_HIDDEN);
-            bottomTabsHiddenOnScroll = getBoolean(style, KEY_BOTTOM_TABS_HIDDEN_ON_SCROLL);
-        }
-    }
-}

android/app/src/main/java/com/reactnativenavigation/layouts/BottomTabsLayout.java

@@ -0,0 +1,285 @@
+package com.reactnativenavigation.layouts;
+
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.support.v7.app.AppCompatActivity;
+import android.view.View;
+import android.widget.RelativeLayout;
+
+import com.aurelhubert.ahbottomnavigation.AHBottomNavigation;
+import com.reactnativenavigation.params.ActivityParams;
+import com.reactnativenavigation.params.ScreenParams;
+import com.reactnativenavigation.params.SideMenuParams;
+import com.reactnativenavigation.params.TitleBarButtonParams;
+import com.reactnativenavigation.params.TitleBarLeftButtonParams;
+import com.reactnativenavigation.screens.ScreenStack;
+import com.reactnativenavigation.views.BottomTabs;
+import com.reactnativenavigation.views.SideMenu;
+
+import java.util.List;
+
+import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
+import static android.view.ViewGroup.LayoutParams.WRAP_CONTENT;
+
+public class BottomTabsLayout extends RelativeLayout implements Layout, AHBottomNavigation.OnTabSelectedListener {
+
+    private final AppCompatActivity activity;
+    private ActivityParams params;
+    private BottomTabs bottomTabs;
+    private ScreenStack[] screenStacks;
+    private final SideMenuParams sideMenuParams;
+    private @Nullable SideMenu sideMenu;
+    private int currentStackIndex = 0;
+
+    public BottomTabsLayout(AppCompatActivity activity, ActivityParams params) {
+        super(activity);
+        this.activity = activity;
+        this.params = params;
+        this.sideMenuParams = params.sideMenuParams;
+        screenStacks = new ScreenStack[params.tabParams.size()];
+        createLayout();
+    }
+
+    private void createLayout() {
+        createSideMenu();
+        createBottomTabs();
+        addBottomTabs();
+        addScreenStacks();
+        showInitialScreenStack();
+    }
+
+    private void createSideMenu() {
+        if (sideMenuParams == null) {
+            return;
+        }
+        sideMenu = new SideMenu(getContext(), sideMenuParams);
+        RelativeLayout.LayoutParams lp = new LayoutParams(MATCH_PARENT, MATCH_PARENT);
+        addView(sideMenu, lp);
+    }
+
+    private void addScreenStacks() {
+        for (int i = 0; i < screenStacks.length; i++) {
+            createAndAddScreens(i);
+        }
+    }
+
+    private void createAndAddScreens(int position) {
+        ScreenParams screenParams = params.tabParams.get(position);
+        ScreenStack newStack = new ScreenStack(activity, getScreenStackParent(), screenParams.getNavigatorId(), this);
+        newStack.pushInitialScreen(screenParams, createScreenLayoutParams(screenParams));
+        screenStacks[position] = newStack;
+    }
+
+    private RelativeLayout getScreenStackParent() {
+        return sideMenu == null ? this : sideMenu.getContentContainer();
+    }
+
+    @NonNull
+    private LayoutParams createScreenLayoutParams(ScreenParams params) {
+        LayoutParams lp = new LayoutParams(MATCH_PARENT, MATCH_PARENT);
+        if (params.styleParams.drawScreenAboveBottomTabs) {
+            lp.addRule(RelativeLayout.ABOVE, bottomTabs.getId());
+        }
+        return lp;
+    }
+
+    private void createBottomTabs() {
+        bottomTabs = new BottomTabs(getContext());
+        bottomTabs.addTabs(params.tabParams, this);
+    }
+
+    private void addBottomTabs() {
+        LayoutParams lp = new LayoutParams(MATCH_PARENT, WRAP_CONTENT);
+        lp.addRule(ALIGN_PARENT_BOTTOM);
+        getScreenStackParent().addView(bottomTabs, lp);
+    }
+
+    private void showInitialScreenStack() {
+        showStackAndUpdateStyle(screenStacks[0]);
+    }
+
+    @Override
+    public View asView() {
+        return this;
+    }
+
+    @Override
+    public boolean onBackPressed() {
+        if (getCurrentScreenStack().handleBackPressInJs()) {
+            return true;
+        }
+
+        if (getCurrentScreenStack().canPop()) {
+            getCurrentScreenStack().pop(true);
+            setBottomTabsStyleFromCurrentScreen();
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    @Override
+    public void setTopBarVisible(String screenInstanceId, boolean hidden, boolean animated) {
+        for (int i = 0; i < bottomTabs.getItemsCount(); i++) {
+            screenStacks[i].setScreenTopBarVisible(screenInstanceId, hidden, animated);
+        }
+    }
+
+    public void setBottomTabsVisible(boolean hidden, boolean animated) {
+        bottomTabs.setVisibility(hidden, animated);
+    }
+
+    @Override
+    public void setTitleBarTitle(String screenInstanceId, String title) {
+        for (int i = 0; i < bottomTabs.getItemsCount(); i++) {
+            screenStacks[i].setScreenTitleBarTitle(screenInstanceId, title);
+        }
+    }
+
+    @Override
+    public void setTitleBarRightButtons(String screenInstanceId, String navigatorEventId, List<TitleBarButtonParams> titleBarButtons) {
+        for (int i = 0; i < bottomTabs.getItemsCount(); i++) {
+            screenStacks[i].setScreenTitleBarRightButtons(screenInstanceId, navigatorEventId, titleBarButtons);
+        }
+    }
+
+    @Override
+    public void setTitleBarLeftButton(String screenInstanceId, String navigatorEventId, TitleBarLeftButtonParams titleBarLeftButtonParams) {
+        for (int i = 0; i < bottomTabs.getItemsCount(); i++) {
+            screenStacks[i].setScreenTitleBarLeftButton(screenInstanceId, navigatorEventId, titleBarLeftButtonParams);
+        }
+    }
+
+    @Override
+    public void toggleSideMenuVisible(boolean animated) {
+        if (sideMenu != null) {
+            sideMenu.toggleVisible(animated);
+        }
+    }
+
+    @Override
+    public void setSideMenuVisible(boolean animated, boolean visible) {
+        if (sideMenu != null) {
+            sideMenu.setVisible(visible, animated);
+        }
+    }
+
+    @Override
+    public void push(ScreenParams screenParams) {
+        ScreenStack screenStack = getScreenStack(screenParams.getNavigatorId());
+        if (screenStack == null) {
+            return;
+        }
+
+        if (isCurrentStack(screenStack)) {
+            screenStack.push(screenParams, createScreenLayoutParams(screenParams));
+            bottomTabs.setStyleFromScreen(screenParams.styleParams);
+        } else {
+            screenStack.push(screenParams, createScreenLayoutParams(screenParams));
+        }
+    }
+
+    @Override
+    public void pop(ScreenParams screenParams) {
+        getCurrentScreenStack().pop(screenParams.animateScreenTransitions, new ScreenStack.OnScreenPop() {
+            @Override
+            public void onScreenPopAnimationEnd() {
+                setBottomTabsStyleFromCurrentScreen();
+            }
+        });
+    }
+
+    @Override
+    public void popToRoot(ScreenParams params) {
+        getCurrentScreenStack().popToRoot(params.animateScreenTransitions);
+        setBottomTabsStyleFromCurrentScreen();
+    }
+
+    @Override
+    public void newStack(ScreenParams params) {
+        ScreenStack currentScreenStack = getCurrentScreenStack();
+        currentScreenStack.destroy();
+        removeView(currentScreenStack.peek());
+
+        ScreenStack newStack = new ScreenStack(activity, getScreenStackParent(), params.getNavigatorId(), this);
+        LayoutParams lp = createScreenLayoutParams(params);
+        newStack.pushInitialScreen(params, lp);
+        screenStacks[currentStackIndex] = newStack;
+
+        bottomTabs.setStyleFromScreen(params.styleParams);
+    }
+
+    @Override
+    public void destroy() {
+        for (ScreenStack screenStack : screenStacks) {
+            screenStack.destroy();
+        }
+
+        if (sideMenu != null) {
+            sideMenu.destroy();
+        }
+    }
+
+    @Override
+    public boolean onTabSelected(int position, boolean wasSelected) {
+        hideCurrentStack();
+
+        ScreenStack newStack = screenStacks[position];
+        showStackAndUpdateStyle(newStack);
+        currentStackIndex = position;
+
+        return true;
+    }
+
+    private void showStackAndUpdateStyle(ScreenStack newStack) {
+        newStack.show();
+        bottomTabs.setStyleFromScreen(newStack.getCurrentScreenStyleParams());
+    }
+
+    private void hideCurrentStack() {
+        ScreenStack currentScreenStack = getCurrentScreenStack();
+        currentScreenStack.hide();
+    }
+
+    private ScreenStack getCurrentScreenStack() {
+        return screenStacks[currentStackIndex];
+    }
+
+    private @Nullable ScreenStack getScreenStack(String navigatorId) {
+        for (ScreenStack screenStack : screenStacks) {
+            if (screenStack.getNavigatorId().equals(navigatorId)) {
+                return screenStack;
+            }
+        }
+        return null;
+    }
+
+    private boolean isCurrentStack(ScreenStack screenStack) {
+        return getCurrentScreenStack() == screenStack;
+    }
+
+    private void setBottomTabsStyleFromCurrentScreen() {
+        bottomTabs.setStyleFromScreen(getCurrentScreenStack().getCurrentScreenStyleParams());
+    }
+
+    @Override
+    public boolean onTitleBarBackButtonClick() {
+        if (getCurrentScreenStack().canPop()) {
+            getCurrentScreenStack().pop(true, new ScreenStack.OnScreenPop() {
+                @Override
+                public void onScreenPopAnimationEnd() {
+                    setBottomTabsStyleFromCurrentScreen();
+                }
+            });
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void onSideMenuButtonClick() {
+        if (sideMenu != null) {
+            sideMenu.openDrawer();
+        }
+    }
+}

android/app/src/main/java/com/reactnativenavigation/layouts/Layout.java

@@ -0,0 +1,26 @@
+package com.reactnativenavigation.layouts;
+
+import android.view.View;
+
+import com.reactnativenavigation.params.TitleBarButtonParams;
+import com.reactnativenavigation.params.TitleBarLeftButtonParams;
+
+import java.util.List;
+
+public interface Layout extends ScreenStackContainer {
+    View asView();
+
+    boolean onBackPressed();
+
+    void setTopBarVisible(String screenInstanceId, boolean hidden, boolean animated);
+
+    void setTitleBarTitle(String screenInstanceId, String title);
+
+    void setTitleBarRightButtons(String screenInstanceId, String navigatorEventId, List<TitleBarButtonParams> titleBarButtons);
+
+    void setTitleBarLeftButton(String screenInstanceId, String navigatorEventId, TitleBarLeftButtonParams titleBarLeftButtonParams);
+
+    void toggleSideMenuVisible(boolean animated);
+
+    void setSideMenuVisible(boolean animated, boolean visible);
+}

android/app/src/main/java/com/reactnativenavigation/layouts/LayoutFactory.java

@@ -0,0 +1,36 @@
+package com.reactnativenavigation.layouts;
+
+import android.support.v7.app.AppCompatActivity;
+import android.util.Log;
+
+import com.reactnativenavigation.params.ActivityParams;
+
+public class LayoutFactory {
+    public static Layout create(AppCompatActivity activity, ActivityParams params) {
+        switch (params.type) {
+            case TabBased:
+                return createBottomTabsScreenLayout(activity, params);
+            case SingleScreen:
+            default:
+                return createSingleScreenLayout(activity, params);
+        }
+    }
+
+    private static Layout createSingleScreenLayout(AppCompatActivity activity, ActivityParams params) {
+        return new SingleScreenLayout(activity, params.sideMenuParams, params.screenParams);
+    }
+
+    private static Layout createBottomTabsScreenLayout(AppCompatActivity activity, ActivityParams params) {
+        if (params.tabParams.size() > 5) {
+            removeAllButTheFirst5Tabs(params);
+        }
+        return new BottomTabsLayout(activity, params);
+    }
+
+    private static void removeAllButTheFirst5Tabs(ActivityParams params) {
+        Log.e("Navigation", "LayoutFactory:createBottomTabsScreenLayout() does not support more than 5 tabs, currently");
+        while (params.tabParams.size() > 5) {
+            params.tabParams.remove(params.tabParams.size() - 1);
+        }
+    }
+}

android/app/src/main/java/com/reactnativenavigation/layouts/ScreenStackContainer.java

@@ -0,0 +1,16 @@
+package com.reactnativenavigation.layouts;
+
+import com.reactnativenavigation.params.ScreenParams;
+import com.reactnativenavigation.views.LeftButtonOnClickListener;
+
+public interface ScreenStackContainer extends LeftButtonOnClickListener {
+    void push(ScreenParams screenParams);
+
+    void pop(ScreenParams screenParams);
+
+    void popToRoot(ScreenParams params);
+
+    void newStack(ScreenParams params);
+
+    void destroy();
+}

android/app/src/main/java/com/reactnativenavigation/layouts/SingleScreenLayout.java

@@ -0,0 +1,168 @@
+package com.reactnativenavigation.layouts;
+
+import android.support.annotation.Nullable;
+import android.support.v7.app.AppCompatActivity;
+import android.view.View;
+import android.widget.RelativeLayout;
+
+import com.reactnativenavigation.params.ScreenParams;
+import com.reactnativenavigation.params.SideMenuParams;
+import com.reactnativenavigation.params.TitleBarButtonParams;
+import com.reactnativenavigation.params.TitleBarLeftButtonParams;
+import com.reactnativenavigation.screens.ScreenStack;
+import com.reactnativenavigation.views.LeftButtonOnClickListener;
+import com.reactnativenavigation.views.SideMenu;
+
+import java.util.List;
+
+import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
+
+public class SingleScreenLayout extends RelativeLayout implements Layout {
+
+    private final AppCompatActivity activity;
+    private final ScreenParams screenParams;
+    private final SideMenuParams sideMenuParams;
+    private ScreenStack stack;
+    private LeftButtonOnClickListener leftButtonOnClickListener;
+    private @Nullable SideMenu sideMenu;
+
+    public SingleScreenLayout(AppCompatActivity activity, ScreenParams screenParams,
+                              LeftButtonOnClickListener leftButtonOnClickListener) {
+        this(activity, null, screenParams);
+        this.leftButtonOnClickListener = leftButtonOnClickListener;
+    }
+
+    public SingleScreenLayout(AppCompatActivity activity, @Nullable SideMenuParams sideMenuParams, ScreenParams screenParams) {
+        super(activity);
+        this.activity = activity;
+        this.screenParams = screenParams;
+        this.sideMenuParams = sideMenuParams;
+        createLayout();
+    }
+
+    private void createLayout() {
+        if (sideMenuParams == null) {
+            createStack(this);
+        } else {
+            sideMenu = createSideMenu();
+            createStack(sideMenu.getContentContainer());
+        }
+    }
+
+    private SideMenu createSideMenu() {
+        SideMenu sideMenu = new SideMenu(getContext(), sideMenuParams);
+        RelativeLayout.LayoutParams lp = new LayoutParams(MATCH_PARENT, MATCH_PARENT);
+        addView(sideMenu, lp);
+        return sideMenu;
+    }
+
+    private void createStack(RelativeLayout parent) {
+        if (stack != null) {
+            stack.destroy();
+        }
+        stack = new ScreenStack(activity, parent, screenParams.getNavigatorId(), this);
+        LayoutParams lp = new LayoutParams(MATCH_PARENT, MATCH_PARENT);
+        stack.pushInitialScreen(screenParams, lp);
+        stack.show();
+    }
+
+    @Override
+    public boolean onBackPressed() {
+        if (stack.handleBackPressInJs()) {
+            return true;
+        }
+
+        if (stack.canPop()) {
+            stack.pop(true);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    @Override
+    public void destroy() {
+        stack.destroy();
+        if (sideMenu != null) {
+            sideMenu.destroy();
+        }
+    }
+
+    @Override
+    public void push(ScreenParams params) {
+        LayoutParams lp = new LayoutParams(MATCH_PARENT, MATCH_PARENT);
+        stack.push(params, lp);
+    }
+
+    @Override
+    public void pop(ScreenParams params) {
+        stack.pop(params.animateScreenTransitions);
+    }
+
+    @Override
+    public void popToRoot(ScreenParams params) {
+        stack.popToRoot(params.animateScreenTransitions);
+    }
+
+    @Override
+    public void newStack(ScreenParams params) {
+        RelativeLayout parent = sideMenu == null ? this : sideMenu.getContentContainer();
+        createStack(parent);
+    }
+
+    @Override
+    public void setTopBarVisible(String screenInstanceID, boolean visible, boolean animate) {
+        stack.setScreenTopBarVisible(screenInstanceID, visible, animate);
+    }
+
+    @Override
+    public void setTitleBarTitle(String screenInstanceId, String title) {
+        stack.setScreenTitleBarTitle(screenInstanceId, title);
+    }
+
+    @Override
+    public View asView() {
+        return this;
+    }
+
+    @Override
+    public void setTitleBarRightButtons(String screenInstanceId, String navigatorEventId,
+                                        List<TitleBarButtonParams> titleBarRightButtons) {
+        stack.setScreenTitleBarRightButtons(screenInstanceId, navigatorEventId, titleBarRightButtons);
+    }
+
+    @Override
+    public void setTitleBarLeftButton(String screenInstanceId, String navigatorEventId, TitleBarLeftButtonParams titleBarLeftButtonParams) {
+        stack.setScreenTitleBarLeftButton(screenInstanceId, navigatorEventId, titleBarLeftButtonParams);
+    }
+
+    @Override
+    public void toggleSideMenuVisible(boolean animated) {
+        if (sideMenu != null) {
+            sideMenu.toggleVisible(animated);
+        }
+    }
+
+    @Override
+    public void setSideMenuVisible(boolean animated, boolean visible) {
+        if (sideMenu != null) {
+            sideMenu.setVisible(visible, animated);
+        }
+    }
+
+    @Override
+    public boolean onTitleBarBackButtonClick() {
+        if (leftButtonOnClickListener != null) {
+            return leftButtonOnClickListener.onTitleBarBackButtonClick();
+        }
+
+        return onBackPressed();
+    }
+
+    @Override
+    public void onSideMenuButtonClick() {
+        if (sideMenu != null) {
+            sideMenu.openDrawer();
+        }
+    }
+}

android/app/src/main/java/com/reactnativenavigation/modal/RnnModal.java

@@ -1,109 +0,0 @@
-package com.reactnativenavigation.modal;
-
-import android.annotation.SuppressLint;
-import android.app.Dialog;
-import android.content.Context;
-import android.content.DialogInterface;
-import android.support.annotation.Nullable;
-import android.view.LayoutInflater;
-import android.view.View;
-import android.view.Window;
-import android.view.WindowManager;
-import android.view.animation.Animation;
-import android.view.animation.AnimationUtils;
-
-import com.reactnativenavigation.R;
-import com.reactnativenavigation.activities.BaseReactActivity;
-import com.reactnativenavigation.controllers.ModalController;
-import com.reactnativenavigation.core.objects.Screen;
-import com.reactnativenavigation.utils.ContextProvider;
-import com.reactnativenavigation.utils.SdkSupports;
-import com.reactnativenavigation.utils.StyleHelper;
-import com.reactnativenavigation.views.RctView;
-import com.reactnativenavigation.views.RnnToolBar;
-import com.reactnativenavigation.views.ScreenStack;
-
-/**
- * Created by guyc on 02/05/16.
- */
-public class RnnModal extends Dialog implements DialogInterface.OnDismissListener {
-
-    private ScreenStack mScreenStack;
-    private View mContentView;
-    private RnnToolBar mToolBar;
-
-    public RnnModal(BaseReactActivity context, Screen screen) {
-        super(context, R.style.Modal);
-        ModalController.getInstance().add(this);
-        init(context, screen);
-    }
-
-    @SuppressLint("InflateParams")
-    private void init(final Context context, Screen screen) {
-        requestWindowFeature(Window.FEATURE_NO_TITLE);
-        mContentView = LayoutInflater.from(context).inflate(R.layout.modal_layout, null, false);
-        mToolBar = (RnnToolBar) mContentView.findViewById(R.id.toolbar);
-        mScreenStack = (ScreenStack) mContentView.findViewById(R.id.screenStack);
-        setContentView(mContentView);
-        mToolBar.update(screen);
-        mScreenStack.push(screen, new RctView.OnDisplayedListener() {
-            @Override
-            public void onDisplayed() {
-                Animation animation = AnimationUtils.loadAnimation(context, R.anim.slide_up);
-                mContentView.setAnimation(animation);
-                mContentView.animate();
-            }
-        });
-
-        // Set navigation colors
-        if (SdkSupports.lollipop()) {
-            Window window = getWindow();
-            window.addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);
-            StyleHelper.setWindowStyle(window, context.getApplicationContext(), screen);
-        }
-        setOnDismissListener(this);
-    }
-
-    public void push(Screen screen) {
-        mScreenStack.push(screen);
-        mToolBar.update(screen);
-    }
-
-    public Screen pop() {
-        Screen popped = mScreenStack.pop();
-        if (mScreenStack.isEmpty()) {
-            dismiss();
-        }
-        Screen currentScreen = getCurrentScreen();
-        if (currentScreen != null) {
-            mToolBar.update(currentScreen);
-        }
-        return popped;
-    }
-
-    @Nullable
-    public Screen getCurrentScreen() {
-        return mScreenStack.isEmpty() ? null : mScreenStack.peek();
-    }
-
-    @Override
-    public void onBackPressed() {
-        if (mScreenStack.getStackSize() == 1) {
-            super.onBackPressed();
-        } else {
-            pop();
-        }
-    }
-
-    @Override
-    public void onDismiss(DialogInterface dialog) {
-        mScreenStack.removeAllReactViews();
-        ModalController.getInstance().remove();
-        // After modal is dismissed, update Toolbar with screen from parent activity or previously displayed modal
-        BaseReactActivity context = ContextProvider.getActivityContext();
-        if (context != null) {
-            Screen currentScreen = context.getCurrentScreen();
-            StyleHelper.updateStyles(mToolBar, currentScreen);
-        }
-    }
-}

android/app/src/main/java/com/reactnativenavigation/modules/RctActivityModule.java

@@ -1,346 +0,0 @@
-package com.reactnativenavigation.modules;
-
-import android.app.Activity;
-import android.content.Intent;
-import android.os.Bundle;
-
-import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.bridge.ReactContextBaseJavaModule;
-import com.facebook.react.bridge.ReactMethod;
-import com.facebook.react.bridge.ReadableArray;
-import com.facebook.react.bridge.ReadableMap;
-import com.facebook.react.bridge.ReadableNativeMap;
-import com.reactnativenavigation.activities.BaseReactActivity;
-import com.reactnativenavigation.activities.BottomTabActivity;
-import com.reactnativenavigation.activities.RootActivity;
-import com.reactnativenavigation.activities.SingleScreenActivity;
-import com.reactnativenavigation.controllers.ModalController;
-import com.reactnativenavigation.core.objects.Drawer;
-import com.reactnativenavigation.core.objects.Screen;
-import com.reactnativenavigation.modal.RnnModal;
-import com.reactnativenavigation.utils.BridgeUtils;
-import com.reactnativenavigation.utils.ContextProvider;
-
-import java.util.ArrayList;
-
-public class RctActivityModule extends ReactContextBaseJavaModule {
-    public static final String REACT_CLASS = "RctActivity";
-    private static final String KEY_NAVIGATOR_ID = "navigatorID";
-
-    public RctActivityModule(ReactApplicationContext reactContext) {
-        super(reactContext);
-    }
-
-    @Override
-    public String getName() {
-        return REACT_CLASS;
-    }
-
-    @ReactMethod
-    public void startTabBasedApp(ReadableArray screens, ReadableMap style, ReadableMap drawerParams) {
-        Activity context = ContextProvider.getActivityContext();
-        if (context != null && !context.isFinishing()) {
-            Intent intent = new Intent(context, BottomTabActivity.class);
-            intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_NEW_TASK);
-
-            Bundle extras = new Bundle();
-            extras.putSerializable(BottomTabActivity.EXTRA_SCREENS, createScreens(screens));
-            if (drawerParams != null) {
-                extras.putSerializable(BottomTabActivity.DRAWER_PARAMS, new Drawer(drawerParams));
-            }
-            if (style != null) {
-                BridgeUtils.addMapToBundle(((ReadableNativeMap) style).toHashMap(), extras);
-            }
-            intent.putExtras(extras);
-
-            context.startActivity(intent);
-            //TODO add abstract isRoot() instead of instanceof?
-            if (ContextProvider.getActivityContext() instanceof RootActivity) {
-                context.overridePendingTransition(0, 0);
-            }
-
-            // Dismiss modals associated with previous activity
-            ModalController.getInstance().dismissAllModals();
-        }
-    }
-
-    private ArrayList<Screen> createScreens(ReadableArray screens) {
-        ArrayList<Screen> ret = new ArrayList<>();
-        for (int i = 0; i < screens.size(); i++) {
-            ret.add(new Screen(screens.getMap(i)));
-        }
-        return ret;
-    }
-
-    @ReactMethod
-    public void startSingleScreenApp(ReadableMap screen, ReadableMap drawerParams) {
-        BaseReactActivity context = ContextProvider.getActivityContext();
-        if (context != null && !context.isFinishing()) {
-            Intent intent = new Intent(context, SingleScreenActivity.class);
-            intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_NEW_TASK);
-
-            Bundle extras = new Bundle();
-            extras.putSerializable(SingleScreenActivity.EXTRA_SCREEN, new Screen(screen));
-            if (drawerParams != null) {
-                extras.putSerializable(SingleScreenActivity.DRAWER_PARAMS, new Drawer(drawerParams));
-            }
-            intent.putExtras(extras);
-
-            context.startActivity(intent);
-            if (ContextProvider.getActivityContext() instanceof RootActivity) {
-                context.overridePendingTransition(0, 0);
-            }
-
-            // Dismiss modals associated with previous activity
-            ModalController.getInstance().dismissAllModals();
-        }
-    }
-
-    @ReactMethod
-    public void setNavigatorButtons(final ReadableMap buttons) {
-        final BaseReactActivity context = ContextProvider.getActivityContext();
-        if (context == null || context.isFinishing()) {
-            return;
-        }
-        context.runOnUiThread(new Runnable() {
-            @Override
-            public void run() {
-                context.setNavigationButtons(buttons);
-            }
-        });
-    }
-
-    @ReactMethod
-    public void setNavigatorTitle(final ReadableMap title) {
-        final BaseReactActivity context = ContextProvider.getActivityContext();
-        if (context == null || context.isFinishing()) {
-            return;
-        }
-        context.runOnUiThread(new Runnable() {
-            @Override
-            public void run() {
-                context.setNavigationTitle(title);
-            }
-        });
-    }
-
-    @ReactMethod
-    public void setTabBadge(final ReadableMap params) {
-        final BaseReactActivity context = ContextProvider.getActivityContext();
-        if (context == null || context.isFinishing()) {
-            return;
-        }
-        context.runOnUiThread(new Runnable() {
-            @Override
-            public void run() {
-                ((BottomTabActivity) context).setTabBadge(params);
-            }
-        });
-    }
-
-    @ReactMethod
-    public void switchToTab(final ReadableMap params) {
-        final BaseReactActivity context = ContextProvider.getActivityContext();
-        if (context == null || context.isFinishing()) {
-            return;
-        }
-        context.runOnUiThread(new Runnable() {
-            @Override
-            public void run() {
-                ((BottomTabActivity) context).switchToTab(params);
-            }
-        });
-    }
-
-    @ReactMethod
-    public void toggleDrawer(final ReadableMap params) {
-        final BaseReactActivity context = ContextProvider.getActivityContext();
-        if (context == null || context.isFinishing()) {
-            return;
-        }
-        context.runOnUiThread(new Runnable() {
-            @Override
-            public void run() {
-                context.toggleDrawer(params);
-            }
-        });
-    }
-
-    @ReactMethod
-    public void toggleNavigationBar(final ReadableMap params) {
-        final BaseReactActivity context = ContextProvider.getActivityContext();
-        if (context == null || context.isFinishing()) {
-            return;
-        }
-        context.runOnUiThread(new Runnable() {
-            @Override
-            public void run() {
-                context.toggleNavigationBar(params);
-            }
-        });
-    }
-
-    @ReactMethod
-    public void toggleNavigatorTabs(final ReadableMap params) {
-        final BaseReactActivity context = ContextProvider.getActivityContext();
-        if (context == null || context.isFinishing()) {
-            return;
-        }
-        context.runOnUiThread(new Runnable() {
-            @Override
-            public void run() {
-                ((BottomTabActivity) context).toggleTabs(params);
-            }
-        });
-    }
-
-    @ReactMethod
-    public void navigatorPush(final ReadableMap skreen) {
-        final Screen screen = new Screen(skreen);
-        final BaseReactActivity context = ContextProvider.getActivityContext();
-        if (context == null || context.isFinishing()) {
-            return;
-        }
-
-        // First, check if the screen should be pushed to a Modal
-        ModalController modalController = ModalController.getInstance();
-        if (modalController.isModalDisplayed()) {
-            final RnnModal modal = modalController.get();
-            if (modal != null) {
-                context.runOnUiThread(new Runnable() {
-                    @Override
-                    public void run() {
-                        modal.push(screen);
-                    }
-                });
-            }
-            return;
-        }
-
-        // No Modal is displayed, Push to activity
-        context.runOnUiThread(new Runnable() {
-            @Override
-            public void run() {
-                context.push(screen);
-            }
-        });
-    }
-
-    @ReactMethod
-    public void navigatorPop(final ReadableMap navigator) {
-        final String navigatorId = navigator.getString(KEY_NAVIGATOR_ID);
-        final BaseReactActivity context = ContextProvider.getActivityContext();
-        if (context == null || context.isFinishing()) {
-            return;
-        }
-
-        // First, check if the screen should be popped from a Modal
-        ModalController modalController = ModalController.getInstance();
-        if (modalController.isModalDisplayed()) {
-            final RnnModal modal = modalController.get();
-            if (modal != null) {
-                context.runOnUiThread(new Runnable() {
-                    @Override
-                    public void run() {
-                        modal.pop();
-                    }
-                });
-            }
-            return;
-        } else {
-            context.runOnUiThread(new Runnable() {
-                @Override
-                public void run() {
-                    context.pop(navigatorId);
-                }
-            });
-        }
-    }
-
-    @ReactMethod
-    public void navigatorPopToRoot(final ReadableMap params) {
-        final BaseReactActivity context = ContextProvider.getActivityContext();
-        if (context == null || context.isFinishing()) {
-            return;
-        }
-
-        final String navigatorID = params.getString(KEY_NAVIGATOR_ID);
-        context.runOnUiThread(new Runnable() {
-            @Override
-            public void run() {
-                context.popToRoot(navigatorID);
-            }
-        });
-    }
-
-    @ReactMethod
-    public void navigatorResetTo(final ReadableMap skreen) {
-        final BaseReactActivity context = ContextProvider.getActivityContext();
-        if (context == null || context.isFinishing()) {
-            return;
-        }
-
-        final Screen screen = new Screen(skreen);
-        context.runOnUiThread(new Runnable() {
-            @Override
-            public void run() {
-                context.resetTo(screen);
-            }
-        });
-    }
-
-    @ReactMethod
-    public void showModal(final ReadableMap screen) {
-        final BaseReactActivity context = ContextProvider.getActivityContext();
-        if (context != null && !context.isFinishing()) {
-            context.runOnUiThread(new Runnable() {
-                @Override
-                public void run() {
-                    new RnnModal(context, new Screen(screen)).show();
-                }
-            });
-        }
-    }
-
-    @ReactMethod
-    public void dismissAllModals(final ReadableMap params) {
-        final BaseReactActivity context = ContextProvider.getActivityContext();
-        if (context != null && !context.isFinishing()) {
-            context.runOnUiThread(new Runnable() {
-                @Override
-                public void run() {
-                    ModalController modalController = ModalController.getInstance();
-                    if (modalController.isModalDisplayed()) {
-                        modalController.dismissAllModals();
-                    }
-                }
-            });
-        }
-    }
-
-    /**
-     * Dismisses the top modal (the last modal pushed).
-     */
-    @ReactMethod
-    public void dismissModal() {
-        ModalController modalController = ModalController.getInstance();
-        if (modalController.isModalDisplayed()) {
-            modalController.dismissModal();
-        }
-    }
-
-    @ReactMethod
-    public void showFAB(final ReadableMap params) {
-        final BaseReactActivity context = ContextProvider.getActivityContext();
-        if (context == null || context.isFinishing()) {
-            return;
-        }
-        context.runOnUiThread(new Runnable() {
-            @Override
-            public void run() {
-                context.showFAB(params);
-            }
-        });
-    }
-
-}

android/app/src/main/java/com/reactnativenavigation/params/ActivityParams.java

@@ -0,0 +1,14 @@
+package com.reactnativenavigation.params;
+
+import java.util.List;
+
+public class ActivityParams {
+    public enum Type {
+        SingleScreen, TabBased
+    }
+
+    public Type type;
+    public ScreenParams screenParams;
+    public List<ScreenParams> tabParams;
+    public SideMenuParams sideMenuParams;
+}

android/app/src/main/java/com/reactnativenavigation/params/AppStyle.java

@@ -0,0 +1,13 @@
+package com.reactnativenavigation.params;
+
+import android.os.Bundle;
+
+import com.reactnativenavigation.params.parsers.StyleParamsParser;
+
+public class AppStyle {
+    public static StyleParams appStyle;
+
+    public static void setAppStyle(Bundle params) {
+        appStyle = new StyleParamsParser(params.getBundle("appStyle")).parse();
+    }
+}

android/app/src/main/java/com/reactnativenavigation/params/NavigationParams.java

@@ -0,0 +1,27 @@
+package com.reactnativenavigation.params;
+
+import android.os.Bundle;
+
+public class NavigationParams {
+    public static final String SCREEN_INSTANCE_ID = "screenInstanceID";
+    public static final String NAVIGATOR_ID = "navigatorID";
+    public static final String NAVIGATOR_EVENT_ID = "navigatorEventID";
+
+    public String screenInstanceId;
+    public String navigatorId;
+    public String navigatorEventId;
+
+    public NavigationParams(Bundle bundle) {
+        screenInstanceId = bundle.getString(SCREEN_INSTANCE_ID);
+        navigatorId = bundle.getString(NAVIGATOR_ID);
+        navigatorEventId = bundle.getString(NAVIGATOR_EVENT_ID);
+    }
+
+    public Bundle toBundle() {
+        Bundle b = new Bundle();
+        b.putString(SCREEN_INSTANCE_ID, screenInstanceId);
+        b.putString(NAVIGATOR_ID, navigatorId);
+        b.putString(NAVIGATOR_EVENT_ID, navigatorEventId);
+        return b;
+    }
+}

android/app/src/main/java/com/reactnativenavigation/params/ScreenParams.java

@@ -0,0 +1,44 @@
+package com.reactnativenavigation.params;
+
+import android.graphics.drawable.Drawable;
+import android.os.Bundle;
+
+import java.util.List;
+
+public class ScreenParams {
+    public String screenId;
+    public List<TitleBarButtonParams> rightButtons;
+    public TitleBarLeftButtonParams leftButton;
+    public boolean overrideBackPressInJs;
+    public String title;
+    public StyleParams styleParams;
+    public List<TopTabParams> topTabParams;
+    public String fragmentCreatorClassName;
+    public Bundle fragmentCreatorPassProps;
+    public boolean animateScreenTransitions;
+
+    public String tabLabel;
+    public Drawable tabIcon;
+
+    public NavigationParams navigationParams;
+
+    public boolean hasTopTabs() {
+        return topTabParams != null && !topTabParams.isEmpty();
+    }
+
+    public boolean isFragmentScreen() {
+        return fragmentCreatorClassName != null;
+    }
+
+    public String getScreenInstanceId() {
+        return navigationParams.screenInstanceId;
+    }
+
+    public String getNavigatorId() {
+        return navigationParams.navigatorId;
+    }
+
+    public String getNavigatorEventId() {
+        return navigationParams.navigatorEventId;
+    }
+}

android/app/src/main/java/com/reactnativenavigation/params/SideMenuParams.java

@@ -0,0 +1,7 @@
+package com.reactnativenavigation.params;
+
+public class SideMenuParams {
+    public String screenId;
+    public NavigationParams navigationParams;
+    public boolean disableOpenGesture;
+}

android/app/src/main/java/com/reactnativenavigation/params/StyleParams.java

@@ -0,0 +1,66 @@
+package com.reactnativenavigation.params;
+
+import android.support.annotation.ColorInt;
+
+public class StyleParams {
+    public static class Color {
+        @ColorInt
+        private Integer color = null;
+
+        public Color() {
+            color = null;
+        }
+
+        public Color(Integer color) {
+            this.color = color;
+        }
+
+        public boolean hasColor() {
+            return color != null;
+        }
+
+        @ColorInt
+        public int getColor() {
+            if (!hasColor()) {
+                throw new RuntimeException("Color undefined");
+            }
+            return color;
+        }
+
+        public static Color parse(String str) {
+            if (str == null) {
+                return new Color();
+            }
+            return new Color(android.graphics.Color.parseColor(str));
+        }
+    }
+
+    public Color statusBarColor;
+
+    public Color topBarColor;
+    public boolean topBarHidden;
+    public boolean topTabsHidden;
+    public boolean drawScreenBelowTopBar;
+
+    public boolean titleBarHidden;
+    public Color titleBarTitleColor;
+    public Color titleBarButtonColor;
+    public Color titleBarDisabledButtonColor;
+    public boolean backButtonHidden;
+
+    public Color topTabTextColor;
+    public Color selectedTopTabTextColor;
+    public int selectedTopTabIndicatorHeight;
+    public Color selectedTopTabIndicatorColor;
+
+    public boolean drawScreenAboveBottomTabs;
+
+    public boolean bottomTabsHidden;
+    public boolean bottomTabsHiddenOnScroll;
+    public Color bottomTabsColor;
+    public Color selectedBottomTabsButtonColor;
+    public Color bottomTabsButtonColor;
+    public boolean forceTitlesDisplay;
+
+    public Color navigationBarColor;
+}

android/app/src/main/java/com/reactnativenavigation/params/TitleBarButtonParams.java

@@ -0,0 +1,33 @@
+package com.reactnativenavigation.params;
+
+import android.graphics.drawable.Drawable;
+import android.view.MenuItem;
+
+public class TitleBarButtonParams {
+    public enum ShowAsAction {
+        IfRoom(MenuItem.SHOW_AS_ACTION_IF_ROOM),
+        Always(MenuItem.SHOW_AS_ACTION_ALWAYS),
+        Never(MenuItem.SHOW_AS_ACTION_NEVER),
+        WithText(MenuItem.SHOW_AS_ACTION_WITH_TEXT);
+
+        public final int action;
+
+        ShowAsAction(int action) {
+            this.action = action;
+        }
+    }
+
+    public String eventId;
+    public String label;
+    public Drawable icon;
+    public StyleParams.Color color;
+    public StyleParams.Color disabledColor;
+    public ShowAsAction showAsAction;
+    public boolean enabled = true;
+
+    public void setColorFromScreenStyle(StyleParams.Color titleBarButtonColor) {
+        if (!color.hasColor() && titleBarButtonColor.hasColor()) {
+            color = titleBarButtonColor;
+        }
+    }
+}

android/app/src/main/java/com/reactnativenavigation/params/TitleBarLeftButtonParams.java

@@ -0,0 +1,23 @@
+package com.reactnativenavigation.params;
+
+import com.balysv.materialmenu.MaterialMenuDrawable;
+
+public class TitleBarLeftButtonParams extends TitleBarButtonParams {
+    public MaterialMenuDrawable.IconState iconState;
+    public boolean overrideBackPressInJs;
+
+    public TitleBarLeftButtonParams(TitleBarButtonParams params) {
+        icon = params.icon;
+        color = params.color;
+        eventId = params.eventId;
+        enabled = params.enabled;
+    }
+
+    public boolean isBackButton() {
+        return eventId.equals("back");
+    }
+
+    public void setOverrideBackPressInJs(boolean overrideBackPressInJs) {
+        this.overrideBackPressInJs = overrideBackPressInJs;
+    }
+}

android/app/src/main/java/com/reactnativenavigation/params/TopTabParams.java

@@ -0,0 +1,7 @@
+package com.reactnativenavigation.params;
+
+public class TopTabParams {
+    public String screenId;
+    public String title;
+    public NavigationParams navigationParams;
+}

android/app/src/main/java/com/reactnativenavigation/params/parsers/ActivityParamsParser.java

@@ -0,0 +1,30 @@
+package com.reactnativenavigation.params.parsers;
+
+import android.os.Bundle;
+
+import com.reactnativenavigation.params.ActivityParams;
+import com.reactnativenavigation.params.AppStyle;
+
+public class ActivityParamsParser extends Parser {
+    public static ActivityParams parse(Bundle params) {
+        ActivityParams result = new ActivityParams();
+
+        AppStyle.setAppStyle(params);
+
+        if (hasKey(params, "screen")) {
+            result.type = ActivityParams.Type.SingleScreen;
+            result.screenParams = ScreenParamsParser.parse(params.getBundle("screen"));
+        }
+
+        if (hasKey(params, "tabs")) {
+            result.type = ActivityParams.Type.TabBased;
+            result.tabParams = ScreenParamsParser.parseTabs(params.getBundle("tabs"));
+        }
+
+        if (hasKey(params, "sideMenu")) {
+            result.sideMenuParams = SideMenuParamsParser.parse(params.getBundle("sideMenu"));
+        }
+
+        return result;
+    }
+}

android/app/src/main/java/com/reactnativenavigation/params/parsers/Parser.java

@@ -0,0 +1,23 @@
+package com.reactnativenavigation.params.parsers;
+
+import android.os.Bundle;
+
+public class Parser {
+
+    protected static boolean hasKey(Bundle bundle, String key) {
+        return bundle.keySet().contains(key);
+    }
+
+
+    protected static void assertKeyExists(Bundle bundle, String key) {
+        if (!hasKey(bundle, key)) {
+            throw new KeyDoesNotExistsException(key);
+        }
+    }
+
+    public static class KeyDoesNotExistsException extends RuntimeException {
+        public KeyDoesNotExistsException(String key) {
+            super(key);
+        }
+    }
+}

android/app/src/main/java/com/reactnativenavigation/params/parsers/ScreenParamsParser.java

@@ -0,0 +1,111 @@
+package com.reactnativenavigation.params.parsers;
+
+import android.graphics.drawable.Drawable;
+import android.os.Bundle;
+
+import com.reactnativenavigation.params.NavigationParams;
+import com.reactnativenavigation.params.ScreenParams;
+import com.reactnativenavigation.params.TitleBarButtonParams;
+import com.reactnativenavigation.params.TitleBarLeftButtonParams;
+import com.reactnativenavigation.params.TopTabParams;
+import com.reactnativenavigation.react.ImageLoader;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class ScreenParamsParser extends Parser {
+    private static final String KEY_TITLE = "title";
+    private static final String KEY_SCREEN_ID = "screenId";
+    private static final String KEY_NAVIGATION_PARAMS = "navigationParams";
+    private static final String KEY_RIGHT_BUTTONS = "rightButtons";
+    private static final String KEY_LEFT_BUTTON = "leftButton";
+    private static final String KEY_BACK_BUTTON_HIDDEN = "backButtonHidden";
+    private static final String STYLE_PARAMS = "styleParams";
+    private static final String TOP_TABS = "topTabs";
+    private static final String FRAGMENT_CREATOR_CLASS_NAME = "fragmentCreatorClassName";
+    private static final String FRAGMENT_CREATOR_PASS_PROPS = "fragmentCreatorPassProps";
+    public static final String OVERRIDE_BACK_PRESS = "overrideBackPress";
+
+    @SuppressWarnings("ConstantConditions")
+    public static ScreenParams parse(Bundle params) {
+        ScreenParams result = new ScreenParams();
+        result.screenId = params.getString(KEY_SCREEN_ID);
+        assertKeyExists(params, KEY_NAVIGATION_PARAMS);
+        result.navigationParams = new NavigationParams(params.getBundle(KEY_NAVIGATION_PARAMS));
+
+        result.styleParams = new StyleParamsParser(params.getBundle(STYLE_PARAMS)).parse();
+
+        result.title = params.getString(KEY_TITLE);
+        result.rightButtons = parseRightButton(params);
+        result.overrideBackPressInJs = params.getBoolean(OVERRIDE_BACK_PRESS, false);
+        result.leftButton = parseLeftButton(params);
+
+        result.topTabParams = parseTopTabs(params);
+
+        if (hasKey(params, FRAGMENT_CREATOR_CLASS_NAME)) {
+            result.fragmentCreatorClassName = params.getString(FRAGMENT_CREATOR_CLASS_NAME);
+            result.fragmentCreatorPassProps = params.getBundle(FRAGMENT_CREATOR_PASS_PROPS);
+        }
+
+        result.tabLabel = getTabLabel(params);
+        result.tabIcon = getTabIcon(params);
+
+        result.animateScreenTransitions = params.getBoolean("animated", true);
+
+        return result;
+    }
+
+    private static Drawable getTabIcon(Bundle params) {
+        Drawable tabIcon = null;
+        if (hasKey(params, "icon")) {
+            tabIcon = ImageLoader.loadImage(params.getString("icon"));
+        }
+        return tabIcon;
+    }
+
+    private static String getTabLabel(Bundle params) {
+        String tabLabel = null;
+        if (hasKey(params, "label")) {
+            tabLabel = params.getString("label");
+        }
+        return tabLabel;
+    }
+
+    private static List<TopTabParams> parseTopTabs(Bundle params) {
+        List<TopTabParams> topTabParams = null;
+        if (hasKey(params, TOP_TABS)) {
+             topTabParams = TopTabParamsParser.parse(params.getBundle(TOP_TABS));
+        }
+        return topTabParams;
+    }
+
+    private static List<TitleBarButtonParams> parseRightButton(Bundle params) {
+        List<TitleBarButtonParams> rightButtons = null;
+        if (hasKey(params, KEY_RIGHT_BUTTONS)) {
+            rightButtons = new TitleBarButtonParamsParser().parseButtons(params.getBundle(KEY_RIGHT_BUTTONS));
+        }
+        return rightButtons;
+    }
+
+    private static TitleBarLeftButtonParams parseLeftButton(Bundle params) {
+        TitleBarLeftButtonParams leftButton = null;
+        if (hasKey(params, KEY_LEFT_BUTTON)) {
+            leftButton =  new TitleBarLeftButtonParamsParser().parseSingleButton(params.getBundle(KEY_LEFT_BUTTON));
+
+            boolean backButtonHidden = params.getBoolean(KEY_BACK_BUTTON_HIDDEN, false);
+            if (backButtonHidden && leftButton.isBackButton()) {
+                leftButton = null;
+            }
+        }
+        return leftButton;
+    }
+
+    public static List<ScreenParams> parseTabs(Bundle params) {
+        ScreenParams result[] = new ScreenParams[params.keySet().size()];
+        for (String key : params.keySet()) {
+            result[Integer.parseInt(key)] = ScreenParamsParser.parse(params.getBundle(key));
+        }
+        return new ArrayList<>(Arrays.asList(result));
+    }
+}

android/app/src/main/java/com/reactnativenavigation/params/parsers/SideMenuParamsParser.java

@@ -0,0 +1,17 @@
+package com.reactnativenavigation.params.parsers;
+
+import android.os.Bundle;
+
+import com.reactnativenavigation.params.NavigationParams;
+import com.reactnativenavigation.params.SideMenuParams;
+
+public class SideMenuParamsParser extends Parser {
+
+    public static SideMenuParams parse(Bundle sideMenu) {
+        SideMenuParams result = new SideMenuParams();
+        result.screenId = sideMenu.getString("screenId");
+        result.navigationParams = new NavigationParams(sideMenu.getBundle("navigationParams"));
+        result.disableOpenGesture = sideMenu.getBoolean("disableOpenGesture", false);
+        return result;
+    }
+}

android/app/src/main/java/com/reactnativenavigation/params/parsers/StyleParamsParser.java

@@ -0,0 +1,159 @@
+package com.reactnativenavigation.params.parsers;
+
+import android.graphics.Color;
+import android.os.Bundle;
+
+import com.reactnativenavigation.params.AppStyle;
+import com.reactnativenavigation.params.StyleParams;
+
+public class StyleParamsParser {
+    private Bundle params;
+
+    public StyleParamsParser(Bundle params) {
+        this.params = params;
+    }
+
+    public StyleParams parse() {
+        StyleParams result = new StyleParams();
+        if (params == null) {
+            return result;
+        }
+
+        result.statusBarColor = getColor("statusBarColor", getDefaultStatusBarColor());
+
+        result.topBarColor = getColor("topBarColor", getDefaultTopBarColor());
+        result.titleBarHidden = getBoolean("titleBarHidden", getDefaultTopBarHidden());
+        result.titleBarTitleColor = getColor("titleBarTitleColor", getDefaultTitleBarColor());
+        result.titleBarButtonColor = getColor("titleBarButtonColor", getTitleBarButtonColor());
+        result.titleBarDisabledButtonColor = getColor("titleBarDisabledButtonColor", getTitleBarDisabledButtonColor());
+        result.backButtonHidden = getBoolean("backButtonHidden", getDefaultBackButtonHidden());
+        result.topTabsHidden = getBoolean("topTabsHidden", getDefaultTopTabsHidden());
+
+        result.topTabTextColor = getColor("topTabTextColor", getDefaultTopTabTextColor());
+        result.selectedTopTabTextColor = getColor("selectedTopTabTextColor", getDefaultSelectedTopTabTextColor());
+        result.selectedTopTabIndicatorHeight = getInt("selectedTopTabIndicatorHeight", getDefaultSelectedTopTabIndicatorHeight());
+        result.selectedTopTabIndicatorColor = getColor("selectedTopTabIndicatorColor", getDefaultSelectedTopTabIndicatorColor());
+
+        // TODO: Uncomment once we support drawBelowTopBar again
+        //result.drawScreenBelowTopBar = params.getBoolean("drawBelowTopBar", isDefaultScreenBelowTopBar());
+        result.drawScreenBelowTopBar = true;
+
+        result.bottomTabsHidden = getBoolean("bottomTabsHidden", getDefaultBottomTabsHidden());
+        result.drawScreenAboveBottomTabs = !result.bottomTabsHidden &&
+                                           params.getBoolean("drawScreenAboveBottomTabs", getDefaultDrawScreenAboveBottomTabs());
+        result.bottomTabsHiddenOnScroll =
+                getBoolean("bottomTabsHiddenOnScroll", getDefaultBottomTabsHiddenOnScroll());
+        result.bottomTabsColor = getColor("bottomTabsColor", getDefaultBottomTabsColor());
+        result.bottomTabsButtonColor = getColor("bottomTabsButtonColor", getDefaultBottomTabsButtonColor());
+        result.selectedBottomTabsButtonColor =
+                getColor("bottomTabsSelectedButtonColor", getDefaultSelectedBottomTabsButtonColor());
+
+        result.navigationBarColor = getColor("navigationBarColor", getDefaultNavigationColor());
+        result.forceTitlesDisplay = getBoolean("forceTitlesDisplay", getDefaultForceTitlesDisplay());
+
+        return result;
+    }
+
+    private boolean getDefaultDrawScreenAboveBottomTabs() {
+        return AppStyle.appStyle == null || AppStyle.appStyle.drawScreenAboveBottomTabs;
+    }
+
+    private StyleParams.Color getDefaultSelectedTopTabIndicatorColor() {
+        return AppStyle.appStyle == null ? new StyleParams.Color() : AppStyle.appStyle.selectedTopTabIndicatorColor;
+    }
+
+    private int getDefaultSelectedTopTabIndicatorHeight() {
+        return AppStyle.appStyle == null ? -1 : AppStyle.appStyle.selectedTopTabIndicatorHeight;
+    }
+
+    private StyleParams.Color getDefaultSelectedTopTabTextColor() {
+        return AppStyle.appStyle == null ? new StyleParams.Color() : AppStyle.appStyle.selectedTopTabTextColor;
+    }
+
+    private StyleParams.Color getDefaultNavigationColor() {
+        return AppStyle.appStyle == null ? new StyleParams.Color() : AppStyle.appStyle.navigationBarColor;
+    }
+
+    private boolean getDefaultForceTitlesDisplay() {
+        return AppStyle.appStyle != null && AppStyle.appStyle.forceTitlesDisplay;
+    }
+
+    private StyleParams.Color getDefaultSelectedBottomTabsButtonColor() {
+        return AppStyle.appStyle == null ? new StyleParams.Color() : AppStyle.appStyle.selectedBottomTabsButtonColor;
+    }
+
+    private StyleParams.Color getDefaultBottomTabsButtonColor() {
+        return AppStyle.appStyle == null ? new StyleParams.Color() : AppStyle.appStyle.bottomTabsButtonColor;
+    }
+
+    private StyleParams.Color getDefaultBottomTabsColor() {
+        return AppStyle.appStyle == null ? new StyleParams.Color() : AppStyle.appStyle.bottomTabsColor;
+    }
+
+    private boolean getDefaultBottomTabsHiddenOnScroll() {
+        return AppStyle.appStyle != null && AppStyle.appStyle.bottomTabsHiddenOnScroll;
+    }
+
+    private boolean getDefaultBottomTabsHidden() {
+        return AppStyle.appStyle != null && AppStyle.appStyle.bottomTabsHidden;
+    }
+
+    private boolean isDefaultScreenBelowTopBar() {
+        return AppStyle.appStyle == null || AppStyle.appStyle.drawScreenBelowTopBar;
+    }
+
+    private boolean getDefaultTopTabsHidden() {
+        return AppStyle.appStyle != null && AppStyle.appStyle.topTabsHidden;
+    }
+
+    private StyleParams.Color getDefaultTopTabTextColor() {
+        return AppStyle.appStyle == null ? new StyleParams.Color() : AppStyle.appStyle.topTabTextColor;
+    }
+
+    private boolean getDefaultBackButtonHidden() {
+        return AppStyle.appStyle != null && AppStyle.appStyle.backButtonHidden;
+    }
+
+    private StyleParams.Color getDefaultTitleBarColor() {
+        return AppStyle.appStyle == null ? new StyleParams.Color() : AppStyle.appStyle.titleBarTitleColor;
+    }
+
+    private StyleParams.Color getTitleBarButtonColor() {
+        return AppStyle.appStyle == null ? new StyleParams.Color() : AppStyle.appStyle.titleBarButtonColor;
+    }
+
+    private StyleParams.Color getTitleBarDisabledButtonColor() {
+        return AppStyle.appStyle == null ? new StyleParams.Color(Color.LTGRAY) : AppStyle.appStyle.titleBarDisabledButtonColor;
+    }
+
+    private boolean getDefaultTopBarHidden() {
+        return AppStyle.appStyle != null && AppStyle.appStyle.titleBarHidden;
+    }
+
+    private StyleParams.Color getDefaultTopBarColor() {
+        return AppStyle.appStyle == null ? new StyleParams.Color() : AppStyle.appStyle.topBarColor;
+    }
+
+    private StyleParams.Color getDefaultStatusBarColor() {
+        return AppStyle.appStyle == null ? new StyleParams.Color() : AppStyle.appStyle.statusBarColor;
+    }
+
+    private boolean getBoolean(String key, boolean defaultValue) {
+        return params.containsKey(key) ? params.getBoolean(key) : defaultValue;
+    }
+
+    private StyleParams.Color getColor(String key, StyleParams.Color defaultColor) {
+        StyleParams.Color color = StyleParams.Color.parse(params.getString(key));
+        if (color.hasColor()) {
+            return color;
+        } else {
+            return defaultColor != null && defaultColor.hasColor() ? defaultColor : color;
+        }
+    }
+
+    private int getInt(String selectedTopTabIndicatorHeight, int defaultSelectedTopTabIndicatorHeight) {
+        return params.containsKey(selectedTopTabIndicatorHeight) ?
+                (int) params.getDouble(selectedTopTabIndicatorHeight) :
+                defaultSelectedTopTabIndicatorHeight;
+    }
+}

android/app/src/main/java/com/reactnativenavigation/params/parsers/TitleBarButtonParamsParser.java

@@ -0,0 +1,59 @@
+package com.reactnativenavigation.params.parsers;
+
+import android.os.Bundle;
+
+import com.reactnativenavigation.params.AppStyle;
+import com.reactnativenavigation.params.StyleParams;
+import com.reactnativenavigation.params.TitleBarButtonParams;
+import com.reactnativenavigation.react.ImageLoader;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class TitleBarButtonParamsParser extends Parser {
+    public List<TitleBarButtonParams> parseButtons(Bundle params) {
+        List<TitleBarButtonParams> result = new ArrayList<>();
+
+        for (String key : params.keySet()) {
+            result.add(parseSingleButton(params.getBundle(key)));
+        }
+        return result;
+    }
+
+    public TitleBarButtonParams parseSingleButton(Bundle bundle) {
+        TitleBarButtonParams result = new TitleBarButtonParams();
+        result.label = bundle.getString("title");
+        if (hasKey(bundle,"icon")) {
+            result.icon = ImageLoader.loadImage(bundle.getString("icon"));
+        }
+        result.color = getColor(bundle, "color", AppStyle.appStyle.titleBarButtonColor);
+        result.disabledColor = getColor(bundle, "disabledColor", AppStyle.appStyle.titleBarDisabledButtonColor);
+        result.showAsAction = parseShowAsAction(bundle.getString("showAsAction"));
+        result.enabled = bundle.getBoolean("enabled", true);
+        result.eventId = bundle.getString("id");
+        return result;
+    }
+
+    private StyleParams.Color getColor(Bundle bundle, String key, StyleParams.Color defaultColor) {
+        StyleParams.Color color = StyleParams.Color.parse(bundle.getString(key));
+        return color.hasColor() || defaultColor == null ? color : defaultColor;
+    }
+
+    private static TitleBarButtonParams.ShowAsAction parseShowAsAction(String showAsAction) {
+        if (showAsAction == null) {
+            return TitleBarButtonParams.ShowAsAction.IfRoom;
+        }
+
+        switch (showAsAction) {
+            case "always":
+                return TitleBarButtonParams.ShowAsAction.Always;
+            case "never":
+                return TitleBarButtonParams.ShowAsAction.Never;
+            case "withText":
+                return TitleBarButtonParams.ShowAsAction.WithText;
+            case "ifRoom":
+            default:
+                return TitleBarButtonParams.ShowAsAction.IfRoom;
+        }
+    }
+}

android/app/src/main/java/com/reactnativenavigation/params/parsers/TitleBarLeftButtonParamsParser.java

@@ -0,0 +1,30 @@
+package com.reactnativenavigation.params.parsers;
+
+import android.os.Bundle;
+
+import com.balysv.materialmenu.MaterialMenuDrawable;
+import com.reactnativenavigation.params.TitleBarLeftButtonParams;
+
+public class TitleBarLeftButtonParamsParser extends TitleBarButtonParamsParser {
+
+    public TitleBarLeftButtonParams parseSingleButton(Bundle params) {
+        TitleBarLeftButtonParams leftButtonParams = new TitleBarLeftButtonParams(super.parseSingleButton(params));
+        leftButtonParams.iconState = getIconStateFromId(leftButtonParams.eventId);
+        return leftButtonParams;
+    }
+
+    private MaterialMenuDrawable.IconState getIconStateFromId(String id) {
+        switch (id) {
+            case "back":
+                return MaterialMenuDrawable.IconState.ARROW;
+            case "cancel":
+                return MaterialMenuDrawable.IconState.X;
+            case "accept":
+                return MaterialMenuDrawable.IconState.CHECK;
+            case "sideMenu":
+                return MaterialMenuDrawable.IconState.BURGER;
+            default:
+                throw new RuntimeException("Unsupported button type " + id);
+        }
+    }
+}

android/app/src/main/java/com/reactnativenavigation/params/parsers/TopTabParamsParser.java

@@ -0,0 +1,34 @@
+package com.reactnativenavigation.params.parsers;
+
+import android.os.Bundle;
+import android.support.annotation.NonNull;
+
+import com.reactnativenavigation.params.NavigationParams;
+import com.reactnativenavigation.params.TopTabParams;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class TopTabParamsParser extends Parser {
+    private static final String KEY_SCREEN_ID = "screenId";
+    private static final String KEY_TITLE = "title";
+    private static final String NAVIGATION_PARAMS = "navigationParams";
+
+    @SuppressWarnings("ConstantConditions")
+    public static List<TopTabParams> parse(Bundle params) {
+        List<TopTabParams> result = new ArrayList<>();
+        for (String key : params.keySet()) {
+            result.add(parseItem(params.getBundle(key)));
+        }
+        return result;
+    }
+
+    @NonNull
+    private static TopTabParams parseItem(Bundle params) {
+        TopTabParams result = new TopTabParams();
+        result.screenId = params.getString(KEY_SCREEN_ID);
+        result.title = params.getString(KEY_TITLE);
+        result.navigationParams = new NavigationParams(params.getBundle(NAVIGATION_PARAMS));
+        return result;
+    }
+}

android/app/src/main/java/com/reactnativenavigation/react/ImageLoader.java

@@ -0,0 +1,16 @@
+package com.reactnativenavigation.react;
+
+import android.graphics.drawable.Drawable;
+
+import com.reactnativenavigation.NavigationApplication;
+
+public class ImageLoader {
+
+    public static Drawable loadImage(String iconSource) {
+        if (NavigationApplication.instance.isDebug()) {
+            return JsDevImageLoader.loadIcon(iconSource);
+        } else {
+            return ResourceDrawableIdHelper.instance.getResourceDrawable(NavigationApplication.instance, iconSource);
+        }
+    }
+}

android/app/src/main/java/com/reactnativenavigation/react/JsDevImageLoader.java

@@ -0,0 +1,37 @@
+package com.reactnativenavigation.react;
+
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+import android.os.StrictMode;
+import android.support.annotation.NonNull;
+
+import com.reactnativenavigation.NavigationApplication;
+
+import java.io.IOException;
+import java.net.URL;
+
+public class JsDevImageLoader {
+
+    public static Drawable loadIcon(String iconDevUri) {
+        try {
+            StrictMode.ThreadPolicy threadPolicy = StrictMode.getThreadPolicy();
+            StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder().permitNetwork().build());
+
+            Drawable drawable = tryLoadIcon(iconDevUri);
+
+            StrictMode.setThreadPolicy(threadPolicy);
+            return drawable;
+        } catch (Exception e) {
+            throw new RuntimeException(iconDevUri, e);
+        }
+    }
+
+    @NonNull
+    private static Drawable tryLoadIcon(String iconDevUri) throws IOException {
+        URL url = new URL(iconDevUri);
+        Bitmap bitmap = BitmapFactory.decodeStream(url.openStream());
+        return new BitmapDrawable(NavigationApplication.instance.getResources(), bitmap);
+    }
+}

android/app/src/main/java/com/reactnativenavigation/react/JsDevReloadHandler.java

@@ -0,0 +1,48 @@
+package com.reactnativenavigation.react;
+
+import android.view.KeyEvent;
+import android.view.View;
+import android.widget.EditText;
+
+import com.facebook.react.ReactInstanceManager;
+import com.reactnativenavigation.NavigationApplication;
+
+public class JsDevReloadHandler {
+
+    private static boolean shouldRefreshOnRR = false;
+
+    //TODO yuck.
+    public static boolean onKeyUp(View currentFocus, int keyCode) {
+        ReactInstanceManager reactInstanceManager = NavigationApplication
+                .instance
+                .getReactGateway()
+                .getReactInstanceManager();
+
+        if (reactInstanceManager != null &&
+                reactInstanceManager.getDevSupportManager().getDevSupportEnabled()) {
+            if (keyCode == KeyEvent.KEYCODE_MENU) {
+                reactInstanceManager.showDevOptionsDialog();
+                return true;
+            }
+            if (keyCode == KeyEvent.KEYCODE_R && !(currentFocus instanceof EditText)) {
+                // Enable double-tap-R-to-reload
+                if (shouldRefreshOnRR) {
+                    reactInstanceManager.getDevSupportManager().handleReloadJS();
+                    shouldRefreshOnRR = false;
+                    return true;
+                } else {
+                    shouldRefreshOnRR = true;
+                    NavigationApplication.instance.runOnMainThread(
+                            new Runnable() {
+                                @Override
+                                public void run() {
+                                    shouldRefreshOnRR = false;
+                                }
+                            },
+                            500);
+                }
+            }
+        }
+        return false;
+    }
+}

android/app/src/main/java/com/reactnativenavigation/react/JsDevReloadListenerReplacer.java

@@ -0,0 +1,69 @@
+package com.reactnativenavigation.react;
+
+import com.facebook.react.ReactInstanceManager;
+import com.facebook.react.bridge.JavaJSExecutor;
+import com.facebook.react.devsupport.DevSupportManager;
+import com.facebook.react.devsupport.ReactInstanceDevCommandsHandler;
+import com.reactnativenavigation.utils.ReflectionUtils;
+
+public class JsDevReloadListenerReplacer {
+    private final ReactInstanceManager reactInstanceManager;
+    private final Listener listener;
+
+    public interface Listener {
+        void onJsDevReload();
+    }
+
+    public JsDevReloadListenerReplacer(ReactInstanceManager reactInstanceManager, Listener listener) {
+        this.reactInstanceManager = reactInstanceManager;
+        this.listener = listener;
+    }
+
+    public void replace() {
+        ReactInstanceDevCommandsHandler originalHandler = getOriginalHandler();
+        DevCommandsHandlerProxy proxy = new DevCommandsHandlerProxy(originalHandler, listener);
+        replaceInReactInstanceManager(proxy);
+        replaceInDevSupportManager(proxy);
+    }
+
+    private void replaceInDevSupportManager(DevCommandsHandlerProxy proxy) {
+        DevSupportManager devSupportManager = (DevSupportManager)
+                ReflectionUtils.getDeclaredField(reactInstanceManager, "mDevSupportManager");
+        ReflectionUtils.setField(devSupportManager, "mReactInstanceCommandsHandler", proxy);
+    }
+
+    private ReactInstanceDevCommandsHandler getOriginalHandler() {
+        return (ReactInstanceDevCommandsHandler) ReflectionUtils.getDeclaredField(reactInstanceManager, "mDevInterface");
+    }
+
+    private void replaceInReactInstanceManager(DevCommandsHandlerProxy proxy) {
+        ReflectionUtils.setField(reactInstanceManager, "mDevInterface", proxy);
+    }
+
+    private static class DevCommandsHandlerProxy implements ReactInstanceDevCommandsHandler {
+        private ReactInstanceDevCommandsHandler originalReactHandler;
+        private final Listener listener;
+
+        public DevCommandsHandlerProxy(ReactInstanceDevCommandsHandler originalReactHandler, Listener listener) {
+            this.originalReactHandler = originalReactHandler;
+            this.listener = listener;
+        }
+
+        @Override
+        public void onReloadWithJSDebugger(JavaJSExecutor.Factory proxyExecutorFactory) {
+            listener.onJsDevReload();
+            originalReactHandler.onReloadWithJSDebugger(proxyExecutorFactory);
+        }
+
+        @Override
+        public void onJSBundleLoadedFromServer() {
+            listener.onJsDevReload();
+            originalReactHandler.onJSBundleLoadedFromServer();
+        }
+
+        @Override
+        public void toggleElementInspector() {
+            originalReactHandler.toggleElementInspector();
+        }
+    }
+}

android/app/src/main/java/com/reactnativenavigation/react/NavigationReactGateway.java

@@ -0,0 +1,143 @@
+package com.reactnativenavigation.react;
+
+import android.app.Activity;
+import android.content.Intent;
+
+import com.facebook.react.LifecycleState;
+import com.facebook.react.ReactInstanceManager;
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
+import com.facebook.react.shell.MainReactPackage;
+import com.reactnativenavigation.NavigationApplication;
+import com.reactnativenavigation.bridge.NavigationReactEventEmitter;
+import com.reactnativenavigation.bridge.NavigationReactPackage;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class NavigationReactGateway implements ReactGateway, ReactInstanceManager.ReactInstanceEventListener {
+
+    private OnJsDevReloadListener onJsDevReloadListener;
+    private ReactInstanceManager reactInstanceManager;
+    private NavigationReactEventEmitter reactEventEmitter;
+
+    public NavigationReactGateway() {
+        reactInstanceManager = createReactInstanceManager();
+    }
+
+    @Override
+    public void startReactContextOnceInBackgroundAndExecuteJS() {
+        if (reactInstanceManager == null) {
+            reactInstanceManager = createReactInstanceManager();
+        }
+
+        if (!reactInstanceManager.hasStartedCreatingInitialContext()) {
+            reactInstanceManager.createReactContextInBackground();
+        }
+    }
+
+    public boolean isInitialized() {
+        return reactInstanceManager != null && reactInstanceManager.getCurrentReactContext() != null;
+    }
+
+    public ReactContext getReactContext() {
+        return reactInstanceManager.getCurrentReactContext();
+    }
+
+    public NavigationReactEventEmitter getReactEventEmitter() {
+        return reactEventEmitter;
+    }
+
+    public ReactInstanceManager getReactInstanceManager() {
+        return reactInstanceManager;
+    }
+
+    public void onBackPressed() {
+        reactInstanceManager.onBackPressed();
+    }
+
+    public void onDestroyApp() {
+        reactInstanceManager.onHostDestroy();
+        reactInstanceManager.destroy();
+        reactInstanceManager.removeReactInstanceEventListener(this);
+        reactInstanceManager = null;
+    }
+
+    public void onPauseActivity() {
+        reactInstanceManager.onHostPause();
+        onJsDevReloadListener = null;
+    }
+
+    public void onResumeActivity(Activity activity, DefaultHardwareBackBtnHandler defaultHardwareBackBtnHandler, OnJsDevReloadListener onJsDevReloadListener) {
+        this.onJsDevReloadListener = onJsDevReloadListener;
+        reactInstanceManager.onHostResume(activity, defaultHardwareBackBtnHandler);
+    }
+
+    public void onActivityResult(int requestCode, int resultCode, Intent data) {
+        reactInstanceManager.onActivityResult(requestCode, resultCode, data);
+    }
+
+    private void replaceJsDevReloadListener(ReactInstanceManager manager) {
+        new JsDevReloadListenerReplacer(manager, new JsDevReloadListenerReplacer.Listener() {
+            @Override
+            public void onJsDevReload() {
+                if (onJsDevReloadListener != null)
+                    onJsDevReloadListener.onJsDevReload();
+            }
+        }).replace();
+    }
+
+    private ReactInstanceManager createReactInstanceManager() {
+        ReactInstanceManager.Builder builder = ReactInstanceManager.builder()
+                .setApplication(NavigationApplication.instance)
+                .setJSMainModuleName(NavigationApplication.instance.getJsEntryFileName())
+                .setBundleAssetName(NavigationApplication.instance.getBundleAssetName())
+                .setUseDeveloperSupport(NavigationApplication.instance.isDebug())
+                .setInitialLifecycleState(LifecycleState.BEFORE_RESUME);
+
+        for (ReactPackage reactPackage : createReactPackages()) {
+            builder.addPackage(reactPackage);
+        }
+
+        ReactInstanceManager manager = builder.build();
+
+        if (NavigationApplication.instance.isDebug()) {
+            replaceJsDevReloadListener(manager);
+        }
+
+        manager.addReactInstanceEventListener(this);
+
+        return manager;
+    }
+
+    private List<ReactPackage> createReactPackages() {
+        List<ReactPackage> list = new ArrayList<>();
+        list.add(new MainReactPackage());
+        list.add(new NavigationReactPackage());
+        addAdditionalReactPackagesIfNeeded(list);
+        return list;
+    }
+
+    private void addAdditionalReactPackagesIfNeeded(List<ReactPackage> list) {
+        List<ReactPackage> additionalReactPackages = NavigationApplication.instance.createAdditionalReactPackages();
+        if (additionalReactPackages == null) {
+            return;
+        }
+
+        for (ReactPackage reactPackage : additionalReactPackages) {
+            if (reactPackage instanceof MainReactPackage)
+                throw new RuntimeException("Do not create a new MainReactPackage. This is created for you.");
+            if (reactPackage instanceof NavigationReactPackage)
+                throw new RuntimeException("Do not create a new NavigationReactPackage. This is created for you.");
+        }
+
+        list.addAll(additionalReactPackages);
+    }
+
+    @Override
+    public void onReactContextInitialized(ReactContext context) {
+        reactEventEmitter = new NavigationReactEventEmitter(context);
+        NavigationApplication.instance.onReactInitialized(context);
+    }
+}

android/app/src/main/java/com/reactnativenavigation/react/ReactGateway.java

@@ -0,0 +1,36 @@
+package com.reactnativenavigation.react;
+
+import android.app.Activity;
+import android.content.Intent;
+
+import com.facebook.react.ReactInstanceManager;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
+import com.reactnativenavigation.bridge.NavigationReactEventEmitter;
+
+public interface ReactGateway {
+
+    interface OnJsDevReloadListener {
+        void onJsDevReload();
+    }
+
+    void startReactContextOnceInBackgroundAndExecuteJS();
+
+    boolean isInitialized();
+
+    ReactContext getReactContext();
+
+    NavigationReactEventEmitter getReactEventEmitter();
+
+    ReactInstanceManager getReactInstanceManager();
+
+    void onResumeActivity(Activity activity, DefaultHardwareBackBtnHandler defaultHardwareBackBtnHandler, OnJsDevReloadListener onJsDevReloadListener);
+
+    void onPauseActivity();
+
+    void onDestroyApp();
+
+    void onBackPressed();
+
+    void onActivityResult(int requestCode, int resultCode, Intent data);
+}

android/app/src/main/java/com/reactnativenavigation/react/ReactViewHacks.java

@@ -0,0 +1,26 @@
+package com.reactnativenavigation.react;
+
+import com.facebook.react.ReactRootView;
+import com.reactnativenavigation.utils.ReflectionUtils;
+
+public class ReactViewHacks {
+
+    public static void preventUnmountOnDetachedFromWindow(ReactRootView view) {
+        ReflectionUtils.setField(view, "mAttachScheduled", true);
+    }
+
+    /**
+     * Side effect: prevents JS components constructor from being called
+     */
+    public static void ensureUnmountOnDetachedFromWindow(ReactRootView view) {
+        ReflectionUtils.setField(view, "mAttachScheduled", false);
+    }
+
+    /**
+     * Side effect: ensures unmount will be called
+     */
+    public static void preventMountAfterReattachedToWindow(ReactRootView view) {
+        ReflectionUtils.setField(view, "mAttachScheduled", false);
+    }
+
+}

android/app/src/main/java/com/reactnativenavigation/react/RedboxPermission.java

@@ -0,0 +1,26 @@
+package com.reactnativenavigation.react;
+
+import android.content.Context;
+import android.content.Intent;
+import android.os.Build;
+import android.provider.Settings;
+import android.util.Log;
+import android.widget.Toast;
+
+import com.facebook.react.common.ReactConstants;
+import com.reactnativenavigation.NavigationApplication;
+
+public class RedboxPermission {
+
+    public static void permissionToShowRedboxIfNeeded(Context context) {
+        if (NavigationApplication.instance.isDebug() &&
+                Build.VERSION.SDK_INT >= 23 &&
+                !Settings.canDrawOverlays(context)) {
+            Intent serviceIntent = new Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION);
+            context.startActivity(serviceIntent);
+            String msg = "Overlay permissions needs to be granted in order for react native apps to run in dev mode";
+            Log.w(ReactConstants.TAG, msg);
+            Toast.makeText(context, msg, Toast.LENGTH_LONG).show();
+        }
+    }
+}

android/app/src/main/java/com/reactnativenavigation/utils/ResourceDrawableIdHelper.java → android/app/src/main/java/com/reactnativenavigation/react/ResourceDrawableIdHelper.java

@@ -1,4 +1,4 @@
-package com.reactnativenavigation.utils;// Copyright 2004-present Facebook. All Rights Reserved.
+package com.reactnativenavigation.react;// Copyright 2004-present Facebook. All Rights Reserved.
 
 import android.content.Context;
 import android.graphics.drawable.Drawable;
@@ -12,9 +12,11 @@ import java.util.Map;
 import javax.annotation.Nullable;
 
 /**
- * Helper class for obtaining information about local images.
+ * Direct copy paste from react-native, because they made that class package scope. -_-"
+ * Can be deleted in react-native ^0.29
  */
 public class ResourceDrawableIdHelper {
+    public static final ResourceDrawableIdHelper instance = new ResourceDrawableIdHelper();
 
     private Map<String, Integer> mResourceDrawableIdMap;
 

android/app/src/main/java/com/reactnativenavigation/screens/ContentViewPagerAdapter.java

@@ -0,0 +1,60 @@
+package com.reactnativenavigation.screens;
+
+import android.support.v4.view.PagerAdapter;
+import android.view.View;
+import android.view.ViewGroup;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableMap;
+import com.reactnativenavigation.NavigationApplication;
+import com.reactnativenavigation.params.TopTabParams;
+import com.reactnativenavigation.views.ContentView;
+
+import java.util.List;
+
+public class ContentViewPagerAdapter extends PagerAdapter {
+
+    private List<ContentView> contentViews;
+    private List<TopTabParams> topTabParams;
+    private int currentPosition = 0;
+
+    public ContentViewPagerAdapter(List<ContentView> contentViews, List<TopTabParams> topTabParams) {
+        this.contentViews = contentViews;
+        this.topTabParams = topTabParams;
+    }
+
+    @Override
+    public Object instantiateItem(ViewGroup container, int position) {
+        return contentViews.get(position);
+    }
+
+    @Override
+    public void setPrimaryItem(ViewGroup container, int position, Object object) {
+        super.setPrimaryItem(container, position, object);
+        if (position != currentPosition) {
+            currentPosition = position;
+            sendPageChangeEvent();
+        }
+    }
+
+    private void sendPageChangeEvent() {
+        WritableMap data = Arguments.createMap();
+        String navigatorEventId = contentViews.get(currentPosition).getNavigatorEventId();
+        NavigationApplication.instance.sendNavigatorEvent("tabSelected", navigatorEventId, data);
+    }
+
+    @Override
+    public int getCount() {
+        return contentViews.size();
+    }
+
+    @Override
+    public boolean isViewFromObject(View view, Object object) {
+        return view == object;
+    }
+
+    @Override
+    public CharSequence getPageTitle(int position) {
+        return topTabParams.get(position).title;
+    }
+}

android/app/src/main/java/com/reactnativenavigation/screens/FragmentScreen.java

@@ -0,0 +1,135 @@
+package com.reactnativenavigation.screens;
+
+import android.app.Fragment;
+import android.app.FragmentManager;
+import android.app.FragmentTransaction;
+import android.os.Bundle;
+import android.support.annotation.Nullable;
+import android.support.v7.app.AppCompatActivity;
+import android.widget.FrameLayout;
+
+import com.reactnativenavigation.R;
+import com.reactnativenavigation.params.ScreenParams;
+import com.reactnativenavigation.utils.ViewUtils;
+import com.reactnativenavigation.views.ContentView;
+import com.reactnativenavigation.views.LeftButtonOnClickListener;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
+
+@SuppressWarnings("ResourceType")
+public class FragmentScreen extends Screen {
+
+    private static final String CONTRACT_GET_FRAGMENT = "getFragment";
+    private static final String CONTRACT_GET_SUPPORT_FRAGMENT = "getSupportFragment";
+    private FrameLayout content;
+
+    public FragmentScreen(AppCompatActivity activity, ScreenParams screenParams, LeftButtonOnClickListener leftButtonOnClickListener) {
+        super(activity, screenParams, leftButtonOnClickListener);
+    }
+
+    @Override
+    protected void createContent() {
+        content = new FrameLayout(getContext());
+        content.setId(R.id.fragment_screen_content);
+        addContent();
+        addFragment();
+    }
+
+    private void addContent() {
+        ContentView contentView = new ContentView(getContext(),
+                screenParams.screenId,
+                screenParams.navigationParams);
+        addView(contentView, 0, 0);
+        LayoutParams params = new LayoutParams(MATCH_PARENT, MATCH_PARENT);
+        if (screenParams.styleParams.drawScreenBelowTopBar) {
+            params.addRule(BELOW, topBar.getId());
+        }
+        addView(content, params);
+    }
+
+
+    private void addFragment() {
+        try {
+            Fragment fragment = tryGetFragment();
+            if (fragment != null) {
+                addFragment(fragment);
+                return;
+            }
+
+            android.support.v4.app.Fragment supportFragment = tryGetSupportFragment();
+            if (supportFragment != null) {
+                addSupportFragment(supportFragment);
+                return;
+            }
+            throw new RuntimeException("must provide public static method " + CONTRACT_GET_FRAGMENT + " or " + CONTRACT_GET_SUPPORT_FRAGMENT);
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private void addFragment(Fragment fragment) {
+        FragmentManager fm = activity.getFragmentManager();
+        FragmentTransaction transaction = fm.beginTransaction();
+        transaction.add(R.id.fragment_screen_content, fragment);
+        transaction.commit();
+    }
+
+    private void addSupportFragment(android.support.v4.app.Fragment supportFragment) {
+        android.support.v4.app.FragmentManager fm = activity.getSupportFragmentManager();
+        android.support.v4.app.FragmentTransaction transaction = fm.beginTransaction();
+        transaction.add(R.id.fragment_screen_content, supportFragment);
+        transaction.commit();
+    }
+
+    @Nullable
+    private Fragment tryGetFragment() throws ClassNotFoundException, IllegalAccessException, InvocationTargetException {
+        try {
+            String className = screenParams.fragmentCreatorClassName;
+            Class<?> fragmentCreatorClass = Class.forName(className);
+            Method method = fragmentCreatorClass.getMethod(CONTRACT_GET_FRAGMENT, Bundle.class);
+            return (android.app.Fragment) method.invoke(null, screenParams.fragmentCreatorPassProps);
+        } catch (NoSuchMethodException noSuchMethod) {
+            return null;
+        }
+    }
+
+    @Nullable
+    private android.support.v4.app.Fragment tryGetSupportFragment() throws ClassNotFoundException, IllegalAccessException, InvocationTargetException {
+        try {
+            String className = screenParams.fragmentCreatorClassName;
+            Class<?> fragmentCreatorClass = Class.forName(className);
+            Method method = fragmentCreatorClass.getMethod(CONTRACT_GET_SUPPORT_FRAGMENT, Bundle.class);
+            return (android.support.v4.app.Fragment) method.invoke(null, screenParams.fragmentCreatorPassProps);
+        } catch (NoSuchMethodException noSuchMethod) {
+            return null;
+        }
+    }
+
+    @Override
+    public void ensureUnmountOnDetachedFromWindow() {
+        // nothing
+    }
+
+    @Override
+    public void preventUnmountOnDetachedFromWindow() {
+        // nothing
+    }
+
+    @Override
+    public void preventMountAfterReattachedToWindow() {
+        // nothing
+    }
+
+    @Override
+    public void setOnDisplayListener(final OnDisplayListener onContentViewDisplayedListener) {
+        ViewUtils.runOnPreDraw(content, new Runnable() {
+            @Override
+            public void run() {
+                onContentViewDisplayedListener.onDisplay();
+            }
+        });
+    }
+}

android/app/src/main/java/com/reactnativenavigation/screens/Screen.java

@@ -0,0 +1,188 @@
+package com.reactnativenavigation.screens;
+
+import android.annotation.TargetApi;
+import android.app.Activity;
+import android.graphics.Color;
+import android.os.Build;
+import android.support.v7.app.AppCompatActivity;
+import android.view.Window;
+import android.widget.RelativeLayout;
+
+import com.reactnativenavigation.animation.VisibilityAnimator;
+import com.reactnativenavigation.params.ScreenParams;
+import com.reactnativenavigation.params.StyleParams;
+import com.reactnativenavigation.params.TitleBarButtonParams;
+import com.reactnativenavigation.params.TitleBarLeftButtonParams;
+import com.reactnativenavigation.utils.ViewUtils;
+import com.reactnativenavigation.views.LeftButtonOnClickListener;
+import com.reactnativenavigation.views.TopBar;
+
+import java.util.List;
+
+import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
+import static android.view.ViewGroup.LayoutParams.WRAP_CONTENT;
+
+public abstract class Screen extends RelativeLayout {
+
+    public interface OnDisplayListener {
+        void onDisplay();
+    }
+
+    protected final AppCompatActivity activity;
+    protected final ScreenParams screenParams;
+    protected TopBar topBar;
+    private final LeftButtonOnClickListener leftButtonOnClickListener;
+    private VisibilityAnimator topBarVisibilityAnimator;
+    private ScreenAnimator screenAnimator;
+    private final StyleParams styleParams;
+
+    public Screen(AppCompatActivity activity, ScreenParams screenParams, LeftButtonOnClickListener leftButtonOnClickListener) {
+        super(activity);
+        this.activity = activity;
+        this.screenParams = screenParams;
+        styleParams = screenParams.styleParams;
+        this.leftButtonOnClickListener = leftButtonOnClickListener;
+        screenAnimator = new ScreenAnimator(this);
+        createViews();
+    }
+
+    public void setStyle() {
+        setStatusBarColor(styleParams.statusBarColor);
+        setNavigationBarColor(styleParams.navigationBarColor);
+        topBar.setStyle(styleParams);
+    }
+
+    private void createViews() {
+        createTopBar();
+        createTitleBar();
+        createContent();
+    }
+
+    protected abstract void createContent();
+
+    private void createTitleBar() {
+        addTitleBarButtons();
+        topBar.setTitle(screenParams.title);
+    }
+
+    private void addTitleBarButtons() {
+        setButtonColorFromScreen(screenParams.rightButtons);
+        if (screenParams.leftButton != null) {
+            screenParams.leftButton.setColorFromScreenStyle(screenParams.styleParams.titleBarButtonColor);
+        }
+        topBar.addTitleBarAndSetButtons(screenParams.rightButtons,
+                screenParams.leftButton,
+                leftButtonOnClickListener,
+                screenParams.getNavigatorEventId(),
+                screenParams.overrideBackPressInJs);
+    }
+
+    private void createTopBar() {
+        topBar = new TopBar(getContext());
+        createTopBarVisibilityAnimator();
+        addView(topBar, new LayoutParams(MATCH_PARENT, WRAP_CONTENT));
+    }
+
+    private void createTopBarVisibilityAnimator() {
+        ViewUtils.runOnPreDraw(topBar, new Runnable() {
+            @Override
+            public void run() {
+                if (topBarVisibilityAnimator == null) {
+                    topBarVisibilityAnimator = new VisibilityAnimator(topBar,
+                            VisibilityAnimator.HideDirection.Up,
+                            topBar.getHeight());
+                }
+            }
+        });
+    }
+
+    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
+    private void setStatusBarColor(StyleParams.Color statusBarColor) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) return;
+
+        final Activity context = (Activity) getContext();
+        final Window window = context.getWindow();
+        if (statusBarColor.hasColor()) {
+            window.setStatusBarColor(statusBarColor.getColor());
+        } else {
+            window.setStatusBarColor(Color.BLACK);
+        }
+    }
+
+    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
+    public void setNavigationBarColor(StyleParams.Color navigationBarColor) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) return;
+
+        final Activity context = (Activity) getContext();
+        final Window window = context.getWindow();
+        if (navigationBarColor.hasColor()) {
+            window.setNavigationBarColor(navigationBarColor.getColor());
+        } else {
+            window.setNavigationBarColor(Color.BLACK);
+        }
+    }
+
+    public abstract void ensureUnmountOnDetachedFromWindow();
+
+    public abstract void preventUnmountOnDetachedFromWindow();
+
+    public abstract void preventMountAfterReattachedToWindow();
+
+    public String getScreenInstanceId() {
+        return screenParams.getScreenInstanceId();
+    }
+
+    public void setTopBarVisible(boolean visible, boolean animate) {
+        topBarVisibilityAnimator.setVisible(visible, animate);
+    }
+
+    public void setTitleBarTitle(String title) {
+        topBar.setTitle(title);
+    }
+
+    public void setTitleBarRightButtons(String navigatorEventId, List<TitleBarButtonParams> titleBarButtons) {
+        setButtonColorFromScreen(titleBarButtons);
+        topBar.setTitleBarRightButtons(navigatorEventId, titleBarButtons);
+    }
+
+    public void setTitleBarLeftButton(String navigatorEventId, LeftButtonOnClickListener backButtonListener,
+                                      TitleBarLeftButtonParams titleBarLeftButtonParams) {
+        topBar.setTitleBarLeftButton(navigatorEventId,
+                backButtonListener,
+                titleBarLeftButtonParams,
+                screenParams.overrideBackPressInJs);
+    }
+
+    public StyleParams getStyleParams() {
+        return screenParams.styleParams;
+    }
+
+    private void setButtonColorFromScreen(List<TitleBarButtonParams> titleBarButtonParams) {
+        if (titleBarButtonParams == null) {
+            return;
+        }
+
+        for (TitleBarButtonParams titleBarButtonParam : titleBarButtonParams) {
+            titleBarButtonParam.setColorFromScreenStyle(screenParams.styleParams.titleBarButtonColor);
+        }
+    }
+
+    public abstract void setOnDisplayListener(OnDisplayListener onContentViewDisplayedListener);
+
+    public void show() {
+        screenAnimator.show(screenParams.animateScreenTransitions);
+    }
+
+    public void show(boolean animated) {
+        screenAnimator.show(animated);
+    }
+
+    public void show(boolean animated, Runnable onAnimationEnd) {
+        setStyle();
+        screenAnimator.show(animated, onAnimationEnd);
+    }
+
+    public void hide(boolean animated, Runnable onAnimatedEnd) {
+        screenAnimator.hide(animated, onAnimatedEnd);
+    }
+}

android/app/src/main/java/com/reactnativenavigation/screens/ScreenAnimator.java

@@ -0,0 +1,99 @@
+package com.reactnativenavigation.screens;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.AnimatorSet;
+import android.animation.ObjectAnimator;
+import android.view.View;
+import android.view.animation.AccelerateInterpolator;
+import android.view.animation.DecelerateInterpolator;
+import android.view.animation.LinearInterpolator;
+
+import com.reactnativenavigation.NavigationApplication;
+import com.reactnativenavigation.utils.ViewUtils;
+
+import javax.annotation.Nullable;
+
+public class ScreenAnimator {
+    private final float translationY;
+    private Screen screen;
+
+    public ScreenAnimator(Screen screen) {
+        this.screen = screen;
+        translationY = 0.08f * ViewUtils.getScreenHeight();
+    }
+
+    public void show(boolean animate, final Runnable onAnimationEnd) {
+        if (animate) {
+            createShowAnimator(onAnimationEnd).start();
+        } else {
+            screen.setVisibility(View.VISIBLE);
+            NavigationApplication.instance.runOnMainThread(onAnimationEnd, 200);
+        }
+    }
+
+    public void show(boolean animate) {
+        if (animate) {
+            createShowAnimator(null).start();
+        } else {
+            screen.setVisibility(View.VISIBLE);
+        }
+    }
+
+    public void hide(boolean animate, Runnable onAnimationEnd) {
+        if (animate) {
+            createHideAnimator(onAnimationEnd).start();
+        } else {
+            screen.setVisibility(View.INVISIBLE);
+            onAnimationEnd.run();
+        }
+    }
+
+    private Animator createShowAnimator(final @Nullable Runnable onAnimationEnd) {
+        ObjectAnimator alpha = ObjectAnimator.ofFloat(screen, View.ALPHA, 0, 1);
+        alpha.setInterpolator(new DecelerateInterpolator());
+        alpha.setDuration(200);
+
+        ObjectAnimator translationY = ObjectAnimator.ofFloat(screen, View.TRANSLATION_Y, this.translationY, 0);
+        translationY.setInterpolator(new DecelerateInterpolator());
+        translationY.setDuration(280);
+
+        AnimatorSet set = new AnimatorSet();
+        set.playTogether(translationY, alpha);
+        set.addListener(new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationStart(Animator animation) {
+                screen.setVisibility(View.VISIBLE);
+            }
+
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                if (onAnimationEnd != null) {
+                    onAnimationEnd.run();
+                }
+            }
+        });
+        return set;
+    }
+
+    private Animator createHideAnimator(final Runnable onAnimationEnd) {
+        ObjectAnimator alpha = ObjectAnimator.ofFloat(screen, View.ALPHA, 0);
+        alpha.setInterpolator(new LinearInterpolator());
+        alpha.setStartDelay(100);
+        alpha.setDuration(150);
+
+        ObjectAnimator translationY = ObjectAnimator.ofFloat(screen, View.TRANSLATION_Y, this.translationY);
+        translationY.setInterpolator(new AccelerateInterpolator());
+        translationY.setDuration(250);
+
+        AnimatorSet set = new AnimatorSet();
+        set.playTogether(translationY, alpha);
+        set.addListener(new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                onAnimationEnd.run();
+            }
+        });
+        return set;
+    }
+}

android/app/src/main/java/com/reactnativenavigation/screens/ScreenFactory.java

@@ -0,0 +1,20 @@
+package com.reactnativenavigation.screens;
+
+import android.support.v7.app.AppCompatActivity;
+
+import com.reactnativenavigation.params.ScreenParams;
+import com.reactnativenavigation.views.LeftButtonOnClickListener;
+
+public class ScreenFactory {
+    public static Screen create(AppCompatActivity activity,
+                                ScreenParams screenParams,
+                                LeftButtonOnClickListener leftButtonOnClickListener) {
+        if (screenParams.isFragmentScreen()) {
+            return new FragmentScreen(activity, screenParams, leftButtonOnClickListener);
+        } else if (screenParams.hasTopTabs()) {
+            return new ViewPagerScreen(activity, screenParams, leftButtonOnClickListener);
+        } else {
+            return new SingleScreen(activity, screenParams, leftButtonOnClickListener);
+        }
+    }
+}

android/app/src/main/java/com/reactnativenavigation/screens/ScreenStack.java

@@ -0,0 +1,256 @@
+package com.reactnativenavigation.screens;
+
+import android.support.annotation.Nullable;
+import android.support.v7.app.AppCompatActivity;
+import android.util.Log;
+import android.view.View;
+import android.widget.RelativeLayout;
+
+import com.reactnativenavigation.NavigationApplication;
+import com.reactnativenavigation.params.ScreenParams;
+import com.reactnativenavigation.params.StyleParams;
+import com.reactnativenavigation.params.TitleBarButtonParams;
+import com.reactnativenavigation.params.TitleBarLeftButtonParams;
+import com.reactnativenavigation.utils.KeyboardVisibilityDetector;
+import com.reactnativenavigation.utils.Task;
+import com.reactnativenavigation.views.LeftButtonOnClickListener;
+
+import java.util.List;
+import java.util.Stack;
+
+public class ScreenStack {
+    private static final String TAG = "ScreenStack";
+
+    public interface OnScreenPop {
+        void onScreenPopAnimationEnd();
+    }
+
+    private final AppCompatActivity activity;
+    private RelativeLayout parent;
+    private LeftButtonOnClickListener leftButtonOnClickListener;
+    private Stack<Screen> stack = new Stack<>();
+    private final KeyboardVisibilityDetector keyboardVisibilityDetector;
+    private boolean isStackVisible = false;
+    private final String navigatorId;
+
+    public String getNavigatorId() {
+        return navigatorId;
+    }
+
+    public ScreenStack(AppCompatActivity activity,
+                       RelativeLayout parent,
+                       String navigatorId,
+                       LeftButtonOnClickListener leftButtonOnClickListener) {
+        this.activity = activity;
+        this.parent = parent;
+        this.navigatorId = navigatorId;
+        this.leftButtonOnClickListener = leftButtonOnClickListener;
+        keyboardVisibilityDetector = new KeyboardVisibilityDetector(parent);
+    }
+
+    public void pushInitialScreen(ScreenParams initialScreenParams, RelativeLayout.LayoutParams params) {
+        Screen initialScreen = ScreenFactory.create(activity, initialScreenParams, leftButtonOnClickListener);
+        initialScreen.setVisibility(View.INVISIBLE);
+        addScreen(initialScreen, params);
+    }
+
+    public void push(final ScreenParams params, RelativeLayout.LayoutParams layoutParams) {
+        Screen nextScreen = ScreenFactory.create(activity, params, leftButtonOnClickListener);
+        final Screen previousScreen = stack.peek();
+        if (isStackVisible) {
+            pushScreenToVisibleStack(params, layoutParams, nextScreen, previousScreen);
+        } else {
+            pushScreenToInvisibleStack(layoutParams, nextScreen, previousScreen);
+        }
+    }
+
+    private void pushScreenToVisibleStack(final ScreenParams params, RelativeLayout.LayoutParams layoutParams,
+                                          final Screen nextScreen, final Screen previousScreen) {
+        nextScreen.setVisibility(View.INVISIBLE);
+        addScreen(nextScreen, layoutParams);
+        nextScreen.setOnDisplayListener(new Screen.OnDisplayListener() {
+            @Override
+            public void onDisplay() {
+                nextScreen.show(params.animateScreenTransitions, new Runnable() {
+                    @Override
+                    public void run() {
+                        removePreviousWithoutUnmount(previousScreen);
+                    }
+                });
+            }
+        });
+    }
+
+    private void pushScreenToInvisibleStack(RelativeLayout.LayoutParams layoutParams, Screen nextScreen,
+                                            Screen previousScreen) {
+        nextScreen.setVisibility(View.INVISIBLE);
+        addScreen(nextScreen, layoutParams);
+        removePreviousWithoutUnmount(previousScreen);
+    }
+
+    private void addScreen(Screen screen, RelativeLayout.LayoutParams layoutParams) {
+        parent.addView(screen, layoutParams);
+        stack.push(screen);
+    }
+
+    private void removePreviousWithoutUnmount(Screen previous) {
+        previous.preventUnmountOnDetachedFromWindow();
+        parent.removeView(previous);
+    }
+
+    public void pop(boolean animated) {
+        pop(animated, null);
+    }
+
+    public void pop(final boolean animated, @Nullable final OnScreenPop onScreenPop) {
+        if (!canPop()) {
+            return;
+        }
+
+        final Screen toRemove = stack.pop();
+        final Screen previous = stack.peek();
+
+        if (keyboardVisibilityDetector.isKeyboardVisible()) {
+            keyboardVisibilityDetector.setKeyboardCloseListener(new Runnable() {
+                @Override
+                public void run() {
+                    keyboardVisibilityDetector.setKeyboardCloseListener(null);
+                    swapScreens(animated, toRemove, previous, onScreenPop);
+                }
+            });
+            keyboardVisibilityDetector.closeKeyboard();
+        } else {
+            swapScreens(animated, toRemove, previous, onScreenPop);
+        }
+    }
+
+    private void swapScreens(boolean animated, final Screen toRemove, Screen previous, OnScreenPop onScreenPop) {
+        readdPrevious(previous);
+        previous.setStyle();
+        toRemove.hide(animated, new Runnable() {
+            @Override
+            public void run() {
+                toRemove.ensureUnmountOnDetachedFromWindow();
+                parent.removeView(toRemove);
+            }
+        });
+
+        if (onScreenPop != null) {
+            onScreenPop.onScreenPopAnimationEnd();
+        }
+    }
+
+    public Screen peek() {
+        return stack.peek();
+    }
+
+    private void readdPrevious(Screen previous) {
+        previous.setVisibility(View.VISIBLE);
+        parent.addView(previous, 0);
+        previous.preventMountAfterReattachedToWindow();
+    }
+
+    public void popToRoot(boolean animated) {
+        while (canPop()) {
+            pop(animated);
+        }
+    }
+
+    public void destroy() {
+        for (Screen screen : stack) {
+            screen.ensureUnmountOnDetachedFromWindow();
+            parent.removeView(screen);
+        }
+        stack.clear();
+    }
+
+    public int getStackSize() {
+        return stack.size();
+    }
+
+    public boolean canPop() {
+        return getStackSize() > 1 && !isPreviousScreenAttachedToWindow();
+    }
+
+    private boolean isPreviousScreenAttachedToWindow() {
+        Screen previousScreen = stack.get(stack.size() - 2);
+        if (previousScreen.getParent() != null) {
+            Log.w(TAG, "Can't pop stack. reason: previous screen is already attached");
+            return true;
+        }
+        return false;
+    }
+
+    public void setScreenTopBarVisible(String screenInstanceId, final boolean visible, final boolean animate) {
+        performOnScreen(screenInstanceId, new Task<Screen>() {
+            @Override
+            public void run(Screen param) {
+                param.setTopBarVisible(visible, animate);
+            }
+        });
+    }
+
+    public void setScreenTitleBarTitle(String screenInstanceId, final String title) {
+        performOnScreen(screenInstanceId, new Task<Screen>() {
+            @Override
+            public void run(Screen param) {
+                param.setTitleBarTitle(title);
+            }
+        });
+    }
+
+    public void setScreenTitleBarRightButtons(String screenInstanceId, final String navigatorEventId, final List<TitleBarButtonParams> titleBarButtons) {
+        performOnScreen(screenInstanceId, new Task<Screen>() {
+            @Override
+            public void run(Screen param) {
+                param.setTitleBarRightButtons(navigatorEventId, titleBarButtons);
+            }
+        });
+    }
+
+    public void setScreenTitleBarLeftButton(String screenInstanceId, final String navigatorEventId, final TitleBarLeftButtonParams titleBarLeftButtonParams) {
+        performOnScreen(screenInstanceId, new Task<Screen>() {
+            @Override
+            public void run(Screen param) {
+                param.setTitleBarLeftButton(navigatorEventId, leftButtonOnClickListener, titleBarLeftButtonParams);
+            }
+        });
+    }
+
+    public StyleParams getCurrentScreenStyleParams() {
+        return stack.peek().getStyleParams();
+    }
+
+    public boolean handleBackPressInJs() {
+        ScreenParams currentScreen = stack.peek().screenParams;
+        if (currentScreen.overrideBackPressInJs) {
+            NavigationApplication.instance.sendNavigatorEvent("backPress", currentScreen.getNavigatorEventId());
+            return true;
+        }
+        return false;
+    }
+
+    private void performOnScreen(String screenInstanceId, Task<Screen> task) {
+        if (stack.isEmpty()) {
+            return;
+        }
+
+        for (Screen screen : stack) {
+            if (screen.getScreenInstanceId().equals(screenInstanceId)) {
+                task.run(screen);
+                return;
+            }
+        }
+    }
+
+    public void show() {
+        isStackVisible = true;
+        stack.peek().setStyle();
+        stack.peek().setVisibility(View.VISIBLE);
+    }
+
+    public void hide() {
+        isStackVisible = false;
+        stack.peek().setVisibility(View.INVISIBLE);
+    }
+}

android/app/src/main/java/com/reactnativenavigation/screens/SingleScreen.java

@@ -0,0 +1,49 @@
+package com.reactnativenavigation.screens;
+
+import android.support.v7.app.AppCompatActivity;
+
+import com.reactnativenavigation.params.ScreenParams;
+import com.reactnativenavigation.views.ContentView;
+import com.reactnativenavigation.views.LeftButtonOnClickListener;
+
+import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
+
+public class SingleScreen extends Screen {
+
+    private ContentView contentView;
+
+    public SingleScreen(AppCompatActivity activity, ScreenParams screenParams,
+                        LeftButtonOnClickListener titleBarBarBackButtonListener) {
+        super(activity, screenParams, titleBarBarBackButtonListener);
+    }
+
+    @Override
+    protected void createContent() {
+        contentView = new ContentView(getContext(), screenParams.screenId, screenParams.navigationParams);
+        LayoutParams params = new LayoutParams(MATCH_PARENT, MATCH_PARENT);
+        if (screenParams.styleParams.drawScreenBelowTopBar) {
+            params.addRule(BELOW, topBar.getId());
+        }
+        addView(contentView, params);
+    }
+
+    @Override
+    public void ensureUnmountOnDetachedFromWindow() {
+        contentView.ensureUnmountOnDetachedFromWindow();
+    }
+
+    @Override
+    public void preventUnmountOnDetachedFromWindow() {
+        contentView.preventUnmountOnDetachedFromWindow();
+    }
+
+    @Override
+    public void preventMountAfterReattachedToWindow() {
+        contentView.preventMountAfterReattachedToWindow();
+    }
+
+    @Override
+    public void setOnDisplayListener(OnDisplayListener onContentViewDisplayedListener) {
+        contentView.setOnDisplayListener(onContentViewDisplayedListener);
+    }
+}

android/app/src/main/java/com/reactnativenavigation/screens/ViewPagerScreen.java

@@ -0,0 +1,95 @@
+package com.reactnativenavigation.screens;
+
+import android.support.design.widget.TabLayout;
+import android.support.v4.view.ViewPager;
+import android.support.v7.app.AppCompatActivity;
+
+import com.reactnativenavigation.params.ScreenParams;
+import com.reactnativenavigation.params.TopTabParams;
+import com.reactnativenavigation.views.ContentView;
+import com.reactnativenavigation.views.LeftButtonOnClickListener;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
+
+public class ViewPagerScreen extends Screen {
+
+    private static final int OFFSCREEN_PAGE_LIMIT = 99;
+    private List<ContentView> contentViews;
+    private ViewPager viewPager;
+
+    public ViewPagerScreen(AppCompatActivity activity, ScreenParams screenParams, LeftButtonOnClickListener backButtonListener) {
+        super(activity, screenParams, backButtonListener);
+    }
+
+    @Override
+    protected void createContent() {
+        TabLayout tabLayout = topBar.initTabs();
+        createViewPager();
+        addPages();
+        setupViewPager(tabLayout);
+    }
+
+    private void createViewPager() {
+        viewPager = new ViewPager(getContext());
+        viewPager.setOffscreenPageLimit(OFFSCREEN_PAGE_LIMIT);
+        LayoutParams lp = new LayoutParams(MATCH_PARENT, MATCH_PARENT);
+        if (screenParams.styleParams.drawScreenBelowTopBar) {
+            lp.addRule(BELOW, topBar.getId());
+        }
+        addView(viewPager, lp);
+    }
+
+    private void addPages() {
+        contentViews = new ArrayList<>();
+        for (TopTabParams tab : screenParams.topTabParams) {
+            ContentView contentView = new ContentView(getContext(), tab.screenId, tab.navigationParams);
+            addContent(contentView);
+            contentViews.add(contentView);
+        }
+    }
+
+    private void setupViewPager(TabLayout tabLayout) {
+        ContentViewPagerAdapter adapter = new ContentViewPagerAdapter(contentViews, screenParams.topTabParams);
+        viewPager.setAdapter(adapter);
+        tabLayout.setupWithViewPager(viewPager);
+    }
+
+    private void addContent(ContentView contentView) {
+        LayoutParams params = new LayoutParams(MATCH_PARENT, MATCH_PARENT);
+        viewPager.addView(contentView, params);
+    }
+
+    @Override
+    public void ensureUnmountOnDetachedFromWindow() {
+        for (ContentView contentView : contentViews) {
+            contentView.ensureUnmountOnDetachedFromWindow();
+        }
+    }
+
+    @Override
+    public void preventUnmountOnDetachedFromWindow() {
+        for (ContentView contentView : contentViews) {
+            contentView.preventUnmountOnDetachedFromWindow();
+        }
+    }
+
+    @Override
+    public void preventMountAfterReattachedToWindow() {
+        for (ContentView contentView : contentViews) {
+            contentView.preventMountAfterReattachedToWindow();
+        }
+    }
+
+    @Override
+    public void setOnDisplayListener(OnDisplayListener onContentViewDisplayedListener) {
+        contentViews.get(0).setOnDisplayListener(onContentViewDisplayedListener);
+    }
+
+    @Override
+    public String getScreenInstanceId() {
+        return screenParams.topTabParams.get(viewPager.getCurrentItem()).navigationParams.screenInstanceId;
+    }
+}

android/app/src/main/java/com/reactnativenavigation/utils/BridgeUtils.java

@@ -1,121 +0,0 @@
-package com.reactnativenavigation.utils;
-
-import android.os.Bundle;
-import android.util.Log;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-
-/**
- * Created by yedidyak on 26/05/2016.
- */
-public class BridgeUtils {
-
-    @SuppressWarnings("unchecked")
-    public static Bundle addMapToBundle(HashMap<String, ?> map, Bundle bundle) {
-        for (String key : map.keySet()) {
-            Object value = map.get(key);
-            if (value instanceof String) {
-                bundle.putString(key, (String) value);
-            } else if (value instanceof Integer) {
-                bundle.putInt(key, (Integer) value);
-            } else if (value instanceof Double) {
-                bundle.putDouble(key, ((Double) value));
-            } else if (value instanceof Boolean) {
-                bundle.putBoolean(key, (Boolean) value);
-            } else if (value instanceof HashMap) {
-                bundle.putBundle(key, addMapToBundle((HashMap<String, Object>) value, new Bundle()));
-            } else if (value instanceof ArrayList) {
-                putArray(key, (ArrayList) value, bundle);
-            }
-        }
-        return bundle;
-    }
-
-    @SuppressWarnings("unchecked")
-    private static void putArray(String key, ArrayList arrayList, Bundle bundle) {
-        if (arrayList.size() == 0) {
-            bundle.putBooleanArray(key, new boolean[]{});
-        } else {
-            verifyArrayListIsSingleType(arrayList);
-            if (arrayList.get(0) instanceof String) {
-                bundle.putStringArray(key, toStringArray((ArrayList<String>) arrayList));
-            } else if (arrayList.get(0) instanceof Integer) {
-                bundle.putIntArray(key, toIntArray((ArrayList<Integer>) arrayList));
-            } else if (arrayList.get(0) instanceof Float) {
-                bundle.putFloatArray(key, toFloatArray((ArrayList<Float>) arrayList));
-            } else if (arrayList.get(0) instanceof Double) {
-                bundle.putDoubleArray(key, toDoubleArray((ArrayList<Double>) arrayList));
-            } else if (arrayList.get(0) instanceof Boolean) {
-                bundle.putBooleanArray(key, toBooleanArray((ArrayList<Boolean>) arrayList));
-            } else if (arrayList.get(0) instanceof HashMap) {
-                bundle.putParcelableArray(key, toBundleArray((ArrayList<HashMap>) arrayList));
-            } else if (arrayList.get(0) instanceof ArrayList) {
-                Log.w("RNNavigation", "Arrays of arrays passed in props are converted to dictionaries with indexes as keys");
-                Bundle innerArray = new Bundle();
-                for (int i = 0; i < arrayList.size(); i++) {
-                    putArray(String.valueOf(i), (ArrayList) arrayList.get(i), innerArray);
-                }
-                bundle.putParcelable(key, innerArray);
-            }
-        }
-    }
-
-    private static void verifyArrayListIsSingleType(ArrayList arrayList) {
-        for (int i = 1; i < arrayList.size(); i++) {
-            if (!arrayList.get(i - 1).getClass().isInstance(arrayList.get(i))) {
-                throw new IllegalArgumentException("Cannot pass array of multiple types via props");
-            }
-        }
-    }
-
-    @SuppressWarnings("unchecked")
-    private static Bundle[] toBundleArray(ArrayList<HashMap> arrayList) {
-        Bundle[] ret = new Bundle[arrayList.size()];
-        for (int i=0; i < ret.length; i++) {
-            ret[i] = addMapToBundle(arrayList.get(i), new Bundle());
-        }
-        return ret;
-    }
-
-    private static int[] toIntArray(ArrayList<Integer> arrayList) {
-        int[] ret = new int[arrayList.size()];
-        for (int i=0; i < ret.length; i++) {
-            ret[i] = arrayList.get(i);
-        }
-        return ret;
-    }
-
-    private static float[] toFloatArray(ArrayList<Float> arrayList) {
-        float[] ret = new float[arrayList.size()];
-        for (int i=0; i < ret.length; i++) {
-            ret[i] = arrayList.get(i);
-        }
-        return ret;
-    }
-
-    private static double[] toDoubleArray(ArrayList<Double> arrayList) {
-        double[] ret = new double[arrayList.size()];
-        for (int i=0; i < ret.length; i++) {
-            ret[i] = arrayList.get(i);
-        }
-        return ret;
-    }
-
-    private static boolean[] toBooleanArray(ArrayList<Boolean> arrayList) {
-        boolean[] ret = new boolean[arrayList.size()];
-        for (int i=0; i < ret.length; i++) {
-            ret[i] = arrayList.get(i);
-        }
-        return ret;
-    }
-
-    private static String[] toStringArray(ArrayList<String> arrayList) {
-        String[] ret = new String[arrayList.size()];
-        for (int i=0; i < ret.length; i++) {
-            ret[i] = arrayList.get(i);
-        }
-        return ret;
-    }
-
-}

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

@@ -1,14 +0,0 @@
-package com.reactnativenavigation.utils;
-
-import java.util.Collection;
-
-/**
- * Created by guyc on 11/04/16.
- */
-public class CollectionUtils {
-
-    public static boolean isNullOrEmpty(Collection collection) {
-        return collection == null || collection.size() == 0;
-    }
-
-}

android/app/src/main/java/com/reactnativenavigation/utils/ContextProvider.java

@@ -1,34 +0,0 @@
-package com.reactnativenavigation.utils;
-
-import android.support.annotation.Nullable;
-
-import com.reactnativenavigation.activities.BaseReactActivity;
-
-import java.lang.ref.WeakReference;
-
-/**
- * Created by guyc on 10/03/16.
- */
-public class ContextProvider {
-    private static WeakReference<BaseReactActivity> sActivityWR;
-
-    public static void setActivityContext(BaseReactActivity activity) {
-        if (sActivityWR == null) {
-            sActivityWR = new WeakReference<>(activity);
-        }
-    }
-
-    /**
-     * Returns the currently resumed activity or {@code null} if there is none.
-     */
-    public static @Nullable BaseReactActivity getActivityContext() {
-        return sActivityWR != null ? sActivityWR.get() : null;
-    }
-
-    public static void clearActivityContext() {
-        if (sActivityWR != null) {
-            sActivityWR.clear();
-        }
-        sActivityWR = null;
-    }
-}

android/app/src/main/java/com/reactnativenavigation/utils/IconUtils.java

@@ -1,76 +0,0 @@
-package com.reactnativenavigation.utils;
-
-import android.content.Context;
-import android.graphics.Bitmap;
-import android.graphics.BitmapFactory;
-import android.graphics.drawable.BitmapDrawable;
-import android.graphics.drawable.Drawable;
-import android.net.Uri;
-
-import com.reactnativenavigation.BuildConfig;
-
-import java.net.URL;
-
-/**
- * Created by yedidyak on 29/05/2016.
- */
-public class IconUtils {
-    public static final String LOCAL_RESOURCE_URI_SCHEME = "res";
-    private static ResourceDrawableIdHelper sResDrawableIdHelper = new ResourceDrawableIdHelper();
-
-    public static Drawable getIcon(Context ctx, String iconSource) {
-        return getIcon(ctx, iconSource, -1);
-    }
-
-    /**
-     * @param iconSource Icon source. In release builds this would be a path in assets, In debug it's
-     *                   a url and the image needs to be decoded from input stream.
-     * @param dimensions The requested icon dimensions
-     */
-    public static Drawable getIcon(Context ctx, String iconSource, int dimensions) {
-        if (iconSource == null) {
-            return null;
-        }
-
-        try {
-            Drawable icon;
-            Uri iconUri = getIconUri(ctx, iconSource);
-
-            if (LOCAL_RESOURCE_URI_SCHEME.equals(iconUri.getScheme())) {
-                icon = sResDrawableIdHelper.getResourceDrawable(ctx, iconSource);
-            } else {
-                URL url = new URL(iconUri.toString());
-                Bitmap bitmap = BitmapFactory.decodeStream(url.openStream());
-                bitmap = dimensions > 0 ?
-                        Bitmap.createScaledBitmap(bitmap, dimensions, dimensions, false) : bitmap;
-                icon = new BitmapDrawable(ctx.getResources(), bitmap);
-            }
-            return icon;
-        } catch (Exception e) {
-            if (BuildConfig.DEBUG) {
-                e.printStackTrace();
-            }
-        }
-        return null;
-    }
-
-    private static Uri getIconUri(Context context, String iconSource) {
-        Uri ret = null;
-        if (iconSource != null) {
-            try {
-                ret = Uri.parse(iconSource);
-                // Verify scheme is set, so that relative uri (used by static resources) are not handled.
-                if (ret.getScheme() == null) {
-                    ret = null;
-                }
-            } catch (Exception e) {
-                // Ignore malformed uri, then attempt to extract resource ID.
-            }
-            if (ret == null) {
-                ret = sResDrawableIdHelper.getResourceDrawableUri(context, iconSource);
-            }
-        }
-        return ret;
-    }
-
-}

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

@@ -1,28 +0,0 @@
-package com.reactnativenavigation.utils;
-
-import android.content.Context;
-import android.graphics.PorterDuff;
-import android.graphics.PorterDuffColorFilter;
-import android.graphics.drawable.Drawable;
-
-/**
- * Created by guyc on 23/04/16.
- */
-public class ImageUtils {
-
-    public static void tint(Drawable drawable, int tint) {
-        drawable.setColorFilter(new PorterDuffColorFilter(tint, PorterDuff.Mode.SRC_IN));
-    }
-
-    /**
-     * This method converts dp unit to equivalent pixels, depending on device density.
-     *
-     * @param dp      A value in dp (density independent pixels) unit. Which we need to convert into pixels
-     * @param context Context to get resources and device specific display metrics
-     * @return A float value to represent px equivalent to dp depending on device density
-     */
-    public static float convertDpToPixel(float dp, Context context) {
-        float scale = context.getResources().getDisplayMetrics().density;
-        return dp * scale + 0.5f;
-    }
-}

android/app/src/main/java/com/reactnativenavigation/utils/IntentUtils.java

@@ -0,0 +1,19 @@
+package com.reactnativenavigation.utils;
+
+import android.content.Intent;
+
+import com.reactnativenavigation.NavigationApplication;
+
+public class IntentUtils {
+    public static Intent getLauncherIntent() {
+        Intent intent = NavigationApplication.instance.getPackageManager().getLaunchIntentForPackage(NavigationApplication.instance.getPackageName());
+        if (intent == null)
+            intent = new Intent();
+        intent.setPackage(null);
+        intent.setFlags(0);
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        intent.setAction(Intent.ACTION_MAIN);
+        intent.addCategory(Intent.CATEGORY_LAUNCHER);
+        return intent;
+    }
+}

android/app/src/main/java/com/reactnativenavigation/utils/KeyboardVisibilityDetector.java

@@ -0,0 +1,79 @@
+package com.reactnativenavigation.utils;
+
+import android.content.Context;
+import android.graphics.Rect;
+import android.view.View;
+import android.view.ViewTreeObserver;
+import android.view.inputmethod.InputMethodManager;
+
+import com.reactnativenavigation.NavigationApplication;
+
+public class KeyboardVisibilityDetector {
+    // 0.15 ratio is perhaps enough to determine keypad height.
+    public static final double KEYBOARD_VISIBLE_RATIO = 0.15;
+
+    private final KeyboardVisibilityLayoutListener keyboardVisibilityListener;
+    private final View screen;
+    private Runnable keyboardCloseListener;
+
+    public KeyboardVisibilityDetector(final View screen) {
+        this.screen = screen;
+        keyboardVisibilityListener = new KeyboardVisibilityLayoutListener(this);
+        screen.getViewTreeObserver().addOnGlobalLayoutListener(keyboardVisibilityListener);
+    }
+
+    public boolean isKeyboardVisible() {
+        return keyboardVisibilityListener.isKeyboardVisible();
+    }
+
+    public void setKeyboardCloseListener(Runnable keyboardCloseListener) {
+        this.keyboardCloseListener = keyboardCloseListener;
+    }
+
+    public void closeKeyboard() {
+        InputMethodManager imm = (InputMethodManager) screen.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
+        imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
+    }
+
+    private static class KeyboardVisibilityLayoutListener implements ViewTreeObserver.OnGlobalLayoutListener {
+        public static final int KEYBOARD_CLOSE_DURATION = 100;
+        private View screen;
+        private boolean isVisible = false;
+        private KeyboardVisibilityDetector detector;
+
+        public KeyboardVisibilityLayoutListener(KeyboardVisibilityDetector detector) {
+            this.detector = detector;
+            this.screen = detector.screen;
+        }
+
+        public boolean isKeyboardVisible() {
+            return isVisible;
+        }
+
+        @Override
+        public void onGlobalLayout() {
+            int screenHeight = screen.getRootView().getHeight();
+            int screenBottomY = getScreenBottomY(screen);
+
+            int keyboardHeight = screenHeight - screenBottomY;
+            if (isKeyboardVisible(screenHeight, keyboardHeight)) {
+                isVisible = true;
+            } else {
+                if (isVisible && detector.keyboardCloseListener != null) {
+                    NavigationApplication.instance.runOnMainThread(detector.keyboardCloseListener, KEYBOARD_CLOSE_DURATION);
+                }
+                isVisible = false;
+            }
+        }
+
+        private boolean isKeyboardVisible(int screenHeight, int keypadHeight) {
+            return keypadHeight > screenHeight * KEYBOARD_VISIBLE_RATIO;
+        }
+
+        private int getScreenBottomY(View screen) {
+            Rect r = new Rect();
+            screen.getWindowVisibleDisplayFrame(r);
+            return r.bottom;
+        }
+    }
+}

android/app/src/main/java/com/reactnativenavigation/utils/RefUtils.java

@@ -1,20 +0,0 @@
-package com.reactnativenavigation.utils;
-
-import java.lang.ref.WeakReference;
-
-/**
- * Created by guyc on 06/05/16.
- */
-public class RefUtils {
-    /**
-     * Extract the object within a WeakReference object
-     * @param wr the WeakReference to extract
-     * @return the object within the WR or null when object not available.
-     */
-    public static <T> T get(WeakReference<T> wr) {
-        if (wr != null) {
-            return wr.get();
-        }
-        return null;
-    }
-}

android/app/src/main/java/com/reactnativenavigation/utils/ReflectionUtils.java

@@ -1,41 +1,25 @@
 package com.reactnativenavigation.utils;
 
+import android.support.annotation.Nullable;
+
 import java.lang.reflect.Field;
-import java.lang.reflect.Method;
 
-/**
- * Created by guyc on 14/04/16.
- */
 public class ReflectionUtils {
 
-    public static boolean setField(Object obj, String name, Object value) {
+    public static void setField(Object obj, String name, Object value) {
         try {
             Field field = getField(obj.getClass(), name);
             if (field == null) {
-                return false;
+                return;
             }
             field.setAccessible(true);
             field.set(obj, value);
-            return true;
         } catch (Exception e) {
             e.printStackTrace();
         }
-        return false;
-    }
-
-    private static Field getField(Class clazz, String name) {
-        try {
-            return clazz.getDeclaredField(name);
-        } catch (NoSuchFieldException nsfe) {
-            return getField(clazz.getSuperclass(), name);
-        } catch (Exception e) {
-            return null;
-        }
     }
 
-    /**
-     * Returns the value of the field
-     */
+    @Nullable
     public static Object getDeclaredField(Object obj, String fieldName) {
         try {
             Field f = getField(obj.getClass(), fieldName);
@@ -50,14 +34,13 @@ public class ReflectionUtils {
         return null;
     }
 
-    public static Object invoke(Object object, String methodName) {
+    private static Field getField(Class clazz, String name) {
         try {
-            Method method = object.getClass().getDeclaredMethod(methodName);
-            method.setAccessible(true);
-            return method.invoke(object);
+            return clazz.getDeclaredField(name);
+        } catch (NoSuchFieldException nsfe) {
+            return getField(clazz.getSuperclass(), name);
         } catch (Exception e) {
-            e.printStackTrace();
+            return null;
         }
-        return null;
     }
 }

android/app/src/main/java/com/reactnativenavigation/utils/SdkSupports.java

@@ -1,13 +0,0 @@
-package com.reactnativenavigation.utils;
-
-import android.os.Build;
-
-/**
- * Created by guyc on 23/04/16.
- */
-public class SdkSupports {
-
-    public static boolean lollipop() {
-        return Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP;
-    }
-}

android/app/src/main/java/com/reactnativenavigation/utils/StyleHelper.java

@@ -1,50 +0,0 @@
-package com.reactnativenavigation.utils;
-
-import android.content.Context;
-import android.support.v4.content.ContextCompat;
-import android.util.Log;
-import android.view.Window;
-
-import com.reactnativenavigation.activities.BaseReactActivity;
-import com.reactnativenavigation.core.objects.Screen;
-import com.reactnativenavigation.views.RnnToolBar;
-
-/**
- * Created by guyc on 07/05/16.
- */
-public class StyleHelper {
-
-    public static void updateStyles(RnnToolBar toolBar, Screen screen) {
-        try {
-            toolBar.updateAndSetButtons(screen);
-            setWindowStyle(screen);
-        } catch (Exception e) {
-            Log.w("RNNavigation", "Tried to update styles with no screen!");
-        }
-    }
-
-    private static void setWindowStyle(Screen screen) {
-        BaseReactActivity context = ContextProvider.getActivityContext();
-        if (context != null) {
-            StyleHelper.setWindowStyle(context.getWindow(), context, screen);
-        }
-    }
-
-    public static void setWindowStyle(Window window, Context context, Screen screen) {
-        if (SdkSupports.lollipop()) {
-            final int black = ContextCompat.getColor(context, android.R.color.black);
-            if (screen.statusBarColor != null) {
-                window.setStatusBarColor(screen.statusBarColor);
-            } else {
-                window.setStatusBarColor(black);
-            }
-
-            if (screen.navigationBarColor != null) {
-                window.setNavigationBarColor(screen.navigationBarColor);
-            } else {
-                window.setNavigationBarColor(black);
-            }
-        }
-
-    }
-}

android/app/src/main/java/com/reactnativenavigation/utils/Task.java

@@ -0,0 +1,5 @@
+package com.reactnativenavigation.utils;
+
+public interface Task<T> {
+    void run(T param);
+}

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

@@ -1,9 +1,23 @@
 package com.reactnativenavigation.utils;
 
+import android.content.Context;
+import android.graphics.PorterDuff;
+import android.graphics.PorterDuffColorFilter;
+import android.graphics.drawable.Drawable;
+import android.os.Build;
+import android.util.DisplayMetrics;
 import android.view.View;
 import android.view.ViewTreeObserver;
+import android.view.WindowManager;
+
+import com.reactnativenavigation.NavigationApplication;
+import com.reactnativenavigation.params.AppStyle;
+
+import java.util.concurrent.atomic.AtomicInteger;
 
 public class ViewUtils {
+    private static final AtomicInteger viewId = new AtomicInteger(1);
+
     public static void runOnPreDraw(final View view, final Runnable task) {
         view.getViewTreeObserver().addOnPreDrawListener(new ViewTreeObserver.OnPreDrawListener() {
             @Override
@@ -17,5 +31,44 @@ public class ViewUtils {
             }
         });
     }
+
+    public static void tintDrawable(Drawable drawable, int tint, boolean enabled) {
+        drawable.setColorFilter(new PorterDuffColorFilter(enabled ? tint :
+                AppStyle.appStyle.titleBarDisabledButtonColor.getColor(),
+                PorterDuff.Mode.SRC_IN));
+    }
+
+    public static float convertDpToPixel(float dp) {
+        float scale = NavigationApplication.instance.getResources().getDisplayMetrics().density;
+        return dp * scale + 0.5f;
+    }
+
+    public static int generateViewId() {
+        if (Build.VERSION.SDK_INT >= 17) {
+            return View.generateViewId();
+        } else {
+            return compatGenerateViewId();
+        }
+    }
+
+    public static float getScreenHeight() {
+        WindowManager wm = (WindowManager) NavigationApplication.instance.getSystemService(Context.WINDOW_SERVICE);
+        DisplayMetrics metrics = new DisplayMetrics();
+        wm.getDefaultDisplay().getMetrics(metrics);
+        return metrics.heightPixels;
+    }
+
+    private static int compatGenerateViewId() {
+        for (; ; ) {
+            final int result = viewId.get();
+            // aapt-generated IDs have the high byte nonzero; clamp to the range under that.
+            int newValue = result + 1;
+            if (newValue > 0x00FFFFFF) newValue = 1; // Roll over to 1, not 0.
+            if (viewId.compareAndSet(result, newValue)) {
+                return result;
+            }
+        }
+    }
+
 }
 

android/app/src/main/java/com/reactnativenavigation/views/BottomNavigation.java

@@ -1,132 +0,0 @@
-package com.reactnativenavigation.views;
-
-import android.animation.Animator;
-import android.animation.AnimatorListenerAdapter;
-import android.animation.ObjectAnimator;
-import android.content.Context;
-import android.support.v4.view.animation.LinearOutSlowInInterpolator;
-import android.util.AttributeSet;
-import android.util.Log;
-import android.view.View;
-
-import com.aurelhubert.ahbottomnavigation.AHBottomNavigation;
-
-/**
- * Created by guyc on 10/07/16.
- */
-public class BottomNavigation extends AHBottomNavigation {
-    private static final String TAG = "BottomNavigation";
-    public static final int SCROLL_DIRECTION_UP = 0;
-    public static final int SCROLL_DIRECTION_DOWN = 1;
-
-    private static final int STATE_HIDDEN = 0;
-    private static final int STATE_ANIMATE_HIDE = 1;
-    private static final int STATE_SHOWN = 2;
-    private static final int STATE_ANIMATE_SHOW = 3;
-    public static final int DURATION = 300;
-
-    private int mState = STATE_SHOWN;
-    private ObjectAnimator mHideAnimator;
-    private ObjectAnimator mShowAnimator;
-
-
-    public BottomNavigation(Context context) {
-        super(context);
-    }
-
-    public BottomNavigation(Context context, AttributeSet attrs) {
-        super(context, attrs);
-    }
-
-    public BottomNavigation(Context context, AttributeSet attrs, int defStyleAttr) {
-        super(context, attrs, defStyleAttr);
-    }
-
-    public void toggleTabs(boolean hide, boolean animated) {
-        if (hide) {
-            hide(animated);
-        } else {
-            show(animated);
-        }
-    }
-
-    private void hide(boolean animated) {
-        if (animated) {
-            hideAnimated();
-        } else {
-            setVisibility(View.GONE);
-        }
-    }
-
-    private void hideAnimated() {
-        if (mHideAnimator == null) {
-            mHideAnimator = createHideAnimator();
-        }
-
-        mHideAnimator.start();
-    }
-
-    private ObjectAnimator createHideAnimator() {
-        ObjectAnimator hideAnimator = ObjectAnimator.ofFloat(this, "translationY", getHeight());
-        hideAnimator.setDuration(DURATION);
-        hideAnimator.addListener(new AnimatorListenerAdapter() {
-            @Override
-            public void onAnimationStart(Animator animation) {
-                mState = STATE_ANIMATE_HIDE;
-            }
-
-            @Override
-            public void onAnimationEnd(Animator animation) {
-                mState = STATE_HIDDEN;
-            }
-        });
-        hideAnimator.setInterpolator(new LinearOutSlowInInterpolator());
-        return hideAnimator;
-
-    }
-
-    private void show(boolean animated) {
-        if (animated) {
-            showAnimated();
-        } else {
-            setVisibility(View.VISIBLE);
-        }
-    }
-
-    private void showAnimated() {
-        if (mShowAnimator == null) {
-            mShowAnimator = createShowAnimator();
-        }
-
-        mShowAnimator.start();
-    }
-
-    private ObjectAnimator createShowAnimator() {
-        ObjectAnimator showAnimator = ObjectAnimator.ofFloat(this, "translationY", 0);
-        showAnimator.setDuration(DURATION);
-        showAnimator.addListener(new AnimatorListenerAdapter() {
-            @Override
-            public void onAnimationStart(Animator animation) {
-                mState = STATE_ANIMATE_SHOW;
-            }
-
-            @Override
-            public void onAnimationEnd(Animator animation) {
-                mState = STATE_SHOWN;
-            }
-        });
-        showAnimator.setInterpolator(new LinearOutSlowInInterpolator());
-        return showAnimator;
-    }
-
-
-    public void onScroll(int direction) {
-        Log.d(TAG, "onScroll() called with: " + "direction = [" + direction + "]");
-        if (direction == SCROLL_DIRECTION_DOWN && mState == STATE_SHOWN) {
-            hide(true);
-
-        } else if (direction == SCROLL_DIRECTION_UP && mState == STATE_HIDDEN) {
-            show(true);
-        }
-    }
-}

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

@@ -0,0 +1,81 @@
+package com.reactnativenavigation.views;
+
+import android.content.Context;
+import android.graphics.Color;
+
+import com.aurelhubert.ahbottomnavigation.AHBottomNavigation;
+import com.aurelhubert.ahbottomnavigation.AHBottomNavigationItem;
+import com.reactnativenavigation.animation.VisibilityAnimator;
+import com.reactnativenavigation.params.ScreenParams;
+import com.reactnativenavigation.params.StyleParams;
+import com.reactnativenavigation.utils.ViewUtils;
+
+import java.util.List;
+
+public class BottomTabs extends AHBottomNavigation {
+
+    private VisibilityAnimator visibilityAnimator;
+
+    public BottomTabs(Context context) {
+        super(context);
+        setForceTint(true);
+        setId(ViewUtils.generateViewId());
+        createVisibilityAnimator();
+    }
+
+    public void addTabs(List<ScreenParams> params, OnTabSelectedListener onTabSelectedListener) {
+        for (ScreenParams screenParams : params) {
+            AHBottomNavigationItem item = new AHBottomNavigationItem(screenParams.title, screenParams.tabIcon,
+                    Color.GRAY);
+            addItem(item);
+            setOnTabSelectedListener(onTabSelectedListener);
+        }
+    }
+
+    public void setStyleFromScreen(StyleParams params) {
+        setBackgroundColor(params.bottomTabsColor);
+
+        if (params.bottomTabsButtonColor.hasColor()) {
+            setInactiveColor(params.bottomTabsButtonColor.getColor());
+        }
+
+        if (params.selectedBottomTabsButtonColor.hasColor()) {
+            setAccentColor(params.selectedBottomTabsButtonColor.getColor());
+        }
+
+        setForceTitlesDisplay(params.forceTitlesDisplay);
+
+        setVisibility(params.bottomTabsHidden, true);
+    }
+
+    public void setVisibility(boolean hidden, boolean animated) {
+        if (visibilityAnimator != null) {
+            visibilityAnimator.setVisible(!hidden, animated);
+        } else {
+            setVisibility(hidden);
+        }
+    }
+
+    private void setBackgroundColor(StyleParams.Color bottomTabsColor) {
+        if (bottomTabsColor.hasColor()) {
+            setDefaultBackgroundColor(bottomTabsColor.getColor());
+        } else {
+            setDefaultBackgroundColor(Color.WHITE);
+        }
+    }
+
+    private void setVisibility(boolean bottomTabsHidden) {
+        setVisibility(bottomTabsHidden ? GONE : VISIBLE);
+    }
+
+    private void createVisibilityAnimator() {
+        ViewUtils.runOnPreDraw(this, new Runnable() {
+            @Override
+            public void run() {
+                visibilityAnimator = new VisibilityAnimator(BottomTabs.this,
+                        VisibilityAnimator.HideDirection.Down,
+                        getHeight());
+            }
+        });
+    }
+}

android/app/src/main/java/com/reactnativenavigation/views/ContentView.java

@@ -0,0 +1,73 @@
+package com.reactnativenavigation.views;
+
+import android.content.Context;
+import android.view.View;
+
+import com.facebook.react.ReactRootView;
+import com.reactnativenavigation.NavigationApplication;
+import com.reactnativenavigation.params.NavigationParams;
+import com.reactnativenavigation.react.ReactViewHacks;
+import com.reactnativenavigation.screens.SingleScreen;
+import com.reactnativenavigation.utils.ViewUtils;
+
+public class ContentView extends ReactRootView {
+
+    private final String screenId;
+    private final NavigationParams navigationParams;
+
+    boolean isContentVisible = false;
+    private SingleScreen.OnDisplayListener onDisplayListener;
+
+    public ContentView(Context context, String screenId, NavigationParams navigationParams) {
+        super(context);
+        this.screenId = screenId;
+        this.navigationParams = navigationParams;
+        attachToJS();
+    }
+
+    public String getNavigatorEventId() {
+        return navigationParams.navigatorEventId;
+    }
+
+    public void preventUnmountOnDetachedFromWindow() {
+        ReactViewHacks.preventUnmountOnDetachedFromWindow(this);
+    }
+
+    public void ensureUnmountOnDetachedFromWindow() {
+        ReactViewHacks.ensureUnmountOnDetachedFromWindow(this);
+    }
+
+    public void preventMountAfterReattachedToWindow() {
+        ReactViewHacks.preventMountAfterReattachedToWindow(this);
+    }
+
+    @Override
+    public void onViewAdded(final View child) {
+        super.onViewAdded(child);
+        detectContentViewVisible(child);
+    }
+
+    private void detectContentViewVisible(View child) {
+        if (onDisplayListener != null) {
+            ViewUtils.runOnPreDraw(child, new Runnable() {
+                @Override
+                public void run() {
+                    if (!isContentVisible) {
+                        isContentVisible = true;
+                        onDisplayListener.onDisplay();
+                        onDisplayListener = null;
+                    }
+                }
+            });
+        }
+    }
+
+    private void attachToJS() {
+        startReactApplication(NavigationApplication.instance.getReactGateway().getReactInstanceManager(), screenId,
+                navigationParams.toBundle());
+    }
+
+    public void setOnDisplayListener(SingleScreen.OnDisplayListener onDisplayListener) {
+        this.onDisplayListener = onDisplayListener;
+    }
+}

android/app/src/main/java/com/reactnativenavigation/views/LeftButton.java

@@ -0,0 +1,85 @@
+package com.reactnativenavigation.views;
+
+import android.content.Context;
+import android.graphics.Color;
+import android.view.View;
+
+import com.balysv.materialmenu.MaterialMenuDrawable;
+import com.reactnativenavigation.NavigationApplication;
+import com.reactnativenavigation.params.TitleBarButtonParams;
+import com.reactnativenavigation.params.TitleBarLeftButtonParams;
+
+// TODO: replace with vector menu drawable
+public class LeftButton extends MaterialMenuDrawable implements View.OnClickListener {
+
+    private static int getColor(TitleBarButtonParams params) {
+        return params != null && params.color.hasColor() ?
+                params.color.getColor() :
+                Color.BLACK;
+    }
+
+    private TitleBarLeftButtonParams params;
+    private final LeftButtonOnClickListener onClickListener;
+    private final String navigatorEventId;
+    private final boolean overrideBackPressInJs;
+
+    public LeftButton(Context context,
+                      TitleBarLeftButtonParams params,
+                      LeftButtonOnClickListener onClickListener,
+                      String navigatorEventId,
+                      boolean overrideBackPressInJs) {
+        super(context, getColor(params), Stroke.THIN);
+        this.params = params;
+        this.onClickListener = onClickListener;
+        this.navigatorEventId = navigatorEventId;
+        this.overrideBackPressInJs = overrideBackPressInJs;
+        setInitialState();
+    }
+
+    public void setIconState(TitleBarLeftButtonParams params) {
+        this.params = params;
+        if (params.color.hasColor()) {
+            setColor(params.color.getColor());
+        }
+        animateIconState(params.iconState);
+    }
+
+    @Override
+    public void onClick(View v) {
+        if (isBackButton()) {
+            handleBackButtonClick();
+        } else if (isSideMenuButton()) {
+            onClickListener.onSideMenuButtonClick();
+        } else {
+            sendClickEvent();
+        }
+    }
+
+    private void handleBackButtonClick() {
+        if (overrideBackPressInJs) {
+            NavigationApplication.instance.sendNavigatorEvent("backPress", navigatorEventId);
+        } else {
+            onClickListener.onTitleBarBackButtonClick();
+        }
+    }
+
+    private void setInitialState() {
+        if (params != null) {
+            setIconState(params.iconState);
+        } else {
+            setVisible(false);
+        }
+    }
+
+    private boolean isBackButton() {
+        return getIconState() == IconState.ARROW;
+    }
+
+    private boolean isSideMenuButton() {
+        return getIconState() == IconState.BURGER;
+    }
+
+    private void sendClickEvent() {
+        NavigationApplication.instance.sendNavigatorEvent(params.eventId, navigatorEventId);
+    }
+}

android/app/src/main/java/com/reactnativenavigation/views/LeftButtonOnClickListener.java

@@ -0,0 +1,7 @@
+package com.reactnativenavigation.views;
+
+public interface LeftButtonOnClickListener {
+    boolean onTitleBarBackButtonClick();
+
+    void onSideMenuButtonClick();
+}

android/app/src/main/java/com/reactnativenavigation/views/RctView.java

@@ -1,195 +0,0 @@
-package com.reactnativenavigation.views;
-
-import android.os.Bundle;
-import android.view.View;
-import android.view.ViewGroup;
-import android.view.ViewTreeObserver;
-import android.widget.FrameLayout;
-import android.widget.ScrollView;
-
-import com.facebook.react.ReactInstanceManager;
-import com.facebook.react.ReactRootView;
-import com.reactnativenavigation.activities.BaseReactActivity;
-import com.reactnativenavigation.activities.BottomTabActivity;
-import com.reactnativenavigation.core.objects.Screen;
-import com.reactnativenavigation.utils.BridgeUtils;
-import com.reactnativenavigation.utils.ReflectionUtils;
-
-/**
- * Created by guyc on 10/03/16.
- */
-public class RctView extends FrameLayout {
-
-    private BottomTabActivity context;
-    private ReactRootView reactRootView;
-    private ScrollView scrollView;
-    private int lastScrollY = -1;
-    private final ViewTreeObserver.OnScrollChangedListener scrollChangedListener = new ViewTreeObserver.OnScrollChangedListener() {
-        @Override
-        public void onScrollChanged() {
-            if (!scrollView.getViewTreeObserver().isAlive()) {
-                return;
-            }
-
-            final int scrollY = scrollView.getScrollY();
-            if (scrollY != lastScrollY && // Scroll position changed
-                scrollY > 0 && // Ignore top overscroll
-                scrollY < (scrollView.getChildAt(0).getHeight() - scrollView.getHeight())) { // Ignore bottom overscroll
-                int direction = scrollY > lastScrollY ?
-                        BottomNavigation.SCROLL_DIRECTION_DOWN :
-                        BottomNavigation.SCROLL_DIRECTION_UP;
-                lastScrollY = scrollY;
-                context.onScrollChanged(direction);
-            }
-        }
-    };
-    private boolean isScrollEventListenerRegistered = false;
-
-    private final View.OnAttachStateChangeListener stateChangeListener =
-            new View.OnAttachStateChangeListener() {
-                @Override
-                public void onViewAttachedToWindow(View v) {
-                    scrollView = getScrollView((ViewGroup) getParent());
-
-                    if (scrollView != null && !isScrollEventListenerRegistered) {
-                        addScrollListener();
-                    }
-                }
-
-                @Override
-                public void onViewDetachedFromWindow(final View detachedView) {
-                    removeScrollListener();
-
-                    post(new Runnable() {
-                        @Override
-                        public void run() {
-                            scrollView = getScrollView((ViewGroup) getParent());
-                            if (scrollView != null && !isScrollEventListenerRegistered) {
-                                isScrollEventListenerRegistered = true;
-                                addScrollListener();
-                            }
-                        }
-                    });
-                }
-            };
-
-    public void detachReactRootView(ReactInstanceManager reactInstanceManager) {
-        reactInstanceManager.detachRootView(reactRootView);
-    }
-
-    /**
-     * Interface used to run some code when the {@link ReactRootView} is visible.
-     */
-    public interface OnDisplayedListener {
-        /**
-         * This method will be invoked when the {@link ReactRootView} is visible.
-         */
-        void onDisplayed();
-    }
-
-    @SuppressWarnings("unchecked")
-    public RctView(BaseReactActivity ctx, ReactInstanceManager rctInstanceManager, final Screen screen,
-                   final OnDisplayedListener onDisplayedListener) {
-        super(ctx);
-        setLayoutParams(new FrameLayout.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
-
-        final OnDisplayedListener onDisplayedListenerInternal = screen.bottomTabsHiddenOnScroll ?
-            new OnDisplayedListener() {
-                @Override
-                public void onDisplayed() {
-                    if (onDisplayedListener != null) {
-                        onDisplayedListener.onDisplayed();
-                    }
-
-                    setupScrollViewWithBottomTabs();
-                }
-            } : onDisplayedListener;
-
-        reactRootView = new RnnReactRootView(ctx, onDisplayedListenerInternal);
-        reactRootView.setLayoutParams(new FrameLayout.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
-        Bundle passProps = createPassProps(screen);
-        String componentName = screen.screenId;
-        reactRootView.startReactApplication(rctInstanceManager, componentName, passProps);
-
-        addView(reactRootView);
-    }
-
-    private Bundle createPassProps(Screen screen) {
-        Bundle passProps = new Bundle();
-        passProps.putString(Screen.KEY_SCREEN_INSTANCE_ID, screen.screenInstanceId);
-        passProps.putString(Screen.KEY_NAVIGATOR_ID, screen.navigatorId);
-        passProps.putString(Screen.KEY_NAVIGATOR_EVENT_ID, screen.navigatorEventId);
-        if (screen.passedProps != null) {
-            BridgeUtils.addMapToBundle(screen.passedProps, passProps);
-        }
-        return passProps;
-    }
-
-    private void setupScrollViewWithBottomTabs() {
-        scrollView = getScrollView((ViewGroup) getParent());
-        if (scrollView != null) {
-            context = (BottomTabActivity) getContext();
-            attachStateChangeListener(scrollView);
-            addScrollListener();
-        }
-    }
-
-    private ScrollView getScrollView(ViewGroup parent) {
-        for (int i = 0; i < parent.getChildCount(); i++) {
-            View child = parent.getChildAt(i);
-
-            if (child instanceof ScrollView) {
-                return (ScrollView) child;
-            }
-
-            if (child instanceof ViewGroup) {
-                return getScrollView((ViewGroup) child);
-            }
-        }
-
-        return null;
-    }
-
-    private void attachStateChangeListener(ScrollView scrollView) {
-        scrollView.addOnAttachStateChangeListener(stateChangeListener);
-    }
-
-    private void addScrollListener() {
-        scrollView.getViewTreeObserver().addOnScrollChangedListener(scrollChangedListener);
-    }
-
-    private void removeScrollListener() {
-        scrollView.getViewTreeObserver().removeOnScrollChangedListener(scrollChangedListener);
-    }
-
-    /**
-     * Must be called before view is removed from screen, but will be added again later. Setting mAttachScheduled
-     * to true will prevent the component from getting unmounted once view is detached from screen.
-     */
-    public void onTemporallyRemovedFromScreen() {
-        // Hack in order to prevent the react view from getting unmounted
-
-        ReflectionUtils.setField(reactRootView, "mAttachScheduled", true);
-    }
-
-    /**
-     * Must be called before view is removed from screen inorder to ensure onDetachedFromScreen is properly
-     * executed and componentWillUnmount is called
-     */
-    public void onRemoveFromScreen() {
-        ReflectionUtils.setField(reactRootView, "mAttachScheduled", false);
-    }
-
-    /**
-     * Must be called when view is added again to screen inorder to ensure onDetachedFromScreen is properly
-     * executed and componentWillUnmount is called
-     */
-    public void onReAddToScreen() {
-        ReflectionUtils.setField(reactRootView, "mAttachScheduled", false);
-    }
-
-    public void detachFromScreen() {
-        ReflectionUtils.invoke(reactRootView, "onDetachedFromWindow");
-    }
-}
-

android/app/src/main/java/com/reactnativenavigation/views/RnnReactRootView.java

@@ -1,34 +0,0 @@
-package com.reactnativenavigation.views;
-
-import android.content.Context;
-import android.view.ViewTreeObserver;
-
-import com.facebook.react.ReactRootView;
-
-/**
- * Created by guyc on 11/07/16.
- */
-public class RnnReactRootView extends ReactRootView implements ViewTreeObserver.OnGlobalLayoutListener {
-    private final RctView.OnDisplayedListener mOnDisplayedListener;
-
-    public RnnReactRootView(Context context, RctView.OnDisplayedListener onDisplayedListener) {
-        super(context);
-        mOnDisplayedListener = onDisplayedListener;
-
-        if (onDisplayedListener != null) {
-            detectOnDisplay();
-        }
-    }
-
-    private void detectOnDisplay() {
-        getViewTreeObserver().addOnGlobalLayoutListener(this);
-    }
-
-    @Override
-    public void onGlobalLayout() {
-        if (getChildCount() >= 1) {
-            getViewTreeObserver().removeOnGlobalLayoutListener(this);
-            mOnDisplayedListener.onDisplayed();
-        }
-    }
-}

android/app/src/main/java/com/reactnativenavigation/views/RnnTabLayout.java

@@ -1,77 +0,0 @@
-package com.reactnativenavigation.views;
-
-import android.content.Context;
-import android.content.res.ColorStateList;
-import android.content.res.TypedArray;
-import android.graphics.drawable.Drawable;
-import android.support.design.widget.TabLayout;
-import android.util.AttributeSet;
-import android.util.TypedValue;
-
-import com.reactnativenavigation.R;
-import com.reactnativenavigation.core.objects.Screen;
-
-/**
- * Created by guyc on 07/05/16.
- */
-public class RnnTabLayout extends TabLayout {
-    private Drawable mBackground;
-    private ColorStateList mTabTextColors;
-    private int mSelectedTabIndicatorColor;
-
-    public RnnTabLayout(Context context) {
-        this(context, null);
-    }
-
-    public RnnTabLayout(Context context, AttributeSet attrs) {
-        this(context, attrs, 0);
-    }
-
-    public RnnTabLayout(Context context, AttributeSet attrs, int defStyleAttr) {
-        super(context, attrs, defStyleAttr);
-        init(context);
-    }
-
-    private void init(Context ctx) {
-        mBackground = getBackground();
-        mTabTextColors = getTabTextColors();
-
-        // Get default accent color which is used as the selected tab indicator color
-        TypedValue typedValue = new TypedValue();
-        TypedArray a = ctx.obtainStyledAttributes(typedValue.data, new int[]{R.attr.colorAccent});
-        mSelectedTabIndicatorColor = a.getColor(0, 0);
-        a.recycle();
-    }
-
-    public void setStyle(Screen screen) {
-        if (screen.toolBarColor != null) {
-            setBackgroundColor(screen.toolBarColor);
-        } else {
-            resetBackground();
-        }
-
-        if (screen.tabNormalTextColor != null && screen.tabSelectedTextColor != null) {
-            setTabTextColors(screen.tabNormalTextColor, screen.tabSelectedTextColor);
-        } else {
-            resetTextColors();
-        }
-
-        if (screen.tabIndicatorColor != null) {
-            setSelectedTabIndicatorColor(screen.tabIndicatorColor);
-        } else {
-            resetSelectedTabIndicatorColor();
-        }
-    }
-
-    public void resetBackground() {
-        setBackground(mBackground);
-    }
-
-    public void resetTextColors() {
-        setTabTextColors(mTabTextColors);
-    }
-
-    public void resetSelectedTabIndicatorColor() {
-        setSelectedTabIndicatorColor(mSelectedTabIndicatorColor);
-    }
-}

android/app/src/main/java/com/reactnativenavigation/views/RnnToolBar.java

@@ -1,439 +0,0 @@
-package com.reactnativenavigation.views;
-
-import android.app.Activity;
-import android.content.Context;
-import android.graphics.Color;
-import android.graphics.drawable.Drawable;
-import android.os.AsyncTask;
-import android.support.annotation.ColorInt;
-import android.support.annotation.NonNull;
-import android.support.annotation.UiThread;
-import android.support.v4.content.ContextCompat;
-import android.support.v4.widget.DrawerLayout;
-import android.support.v7.app.ActionBar;
-import android.support.v7.app.ActionBarDrawerToggle;
-import android.support.v7.app.AppCompatActivity;
-import android.support.v7.graphics.drawable.DrawerArrowDrawable;
-import android.support.v7.widget.Toolbar;
-import android.util.AttributeSet;
-import android.view.Gravity;
-import android.view.Menu;
-import android.view.MenuItem;
-import android.view.View;
-import android.view.ViewTreeObserver;
-import android.widget.TextView;
-
-import com.reactnativenavigation.R;
-import com.reactnativenavigation.activities.BaseReactActivity;
-import com.reactnativenavigation.core.objects.Button;
-import com.reactnativenavigation.core.objects.Screen;
-import com.reactnativenavigation.utils.ContextProvider;
-import com.reactnativenavigation.utils.IconUtils;
-import com.reactnativenavigation.utils.ImageUtils;
-
-import java.lang.ref.WeakReference;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-/**
- * Created by guyc on 09/04/16.
- */
-public class RnnToolBar extends Toolbar {
-
-    private List<Screen> mScreens;
-    private AsyncTask mDrawerIconTask;
-    private AsyncTask mSetupToolbarTask;
-    private Drawable mBackground;
-    private Drawable mDrawerIcon;
-    private DrawerLayout mDrawerLayout;
-    private ActionBarDrawerToggle mDrawerToggle;
-    private ArrayList<View> mMenuItems;
-
-    public RnnToolBar(Context context) {
-        super(context);
-        init();
-    }
-
-    public RnnToolBar(Context context, AttributeSet attrs) {
-        super(context, attrs);
-        init();
-    }
-
-    public RnnToolBar(Context context, AttributeSet attrs, int defStyleAttr) {
-        super(context, attrs, defStyleAttr);
-        init();
-    }
-
-    private void init() {
-        mMenuItems = new ArrayList<>();
-        mBackground = getBackground();
-    }
-
-    public void setScreens(List<Screen> screens) {
-        mScreens = screens;
-    }
-
-    public void setStyle(Screen screen) {
-        if (screen.toolBarColor != null) {
-            setBackgroundColor(screen.toolBarColor);
-        } else {
-            resetBackground();
-        }
-
-        if (screen.navBarTextColor != null) {
-            setTitleTextColor(screen.navBarTextColor);
-        } else {
-            resetTitleTextColor();
-        }
-
-        if (screen.toolBarHidden != null && screen.toolBarHidden) {
-            hideToolbar();
-        } else {
-            showToolbar();
-        }
-    }
-
-    private void resetBackground() {
-        setBackground(mBackground);
-    }
-
-    private void resetTitleTextColor() {
-        setTitleTextColor(ContextCompat.getColor(getContext(), android.R.color.primary_text_light));
-    }
-
-    public void handleOnCreateOptionsMenuAsync() {
-        if (mScreens != null) {
-            setupToolbarButtonsAsync(null, mScreens.get(0));
-        }
-    }
-
-    public ActionBarDrawerToggle setupDrawer(DrawerLayout drawerLayout, Screen drawerScreen, Screen screen) {
-        if (drawerLayout == null || drawerScreen == null) {
-            return null;
-        }
-
-        mDrawerLayout = drawerLayout;
-        mDrawerToggle = new ActionBarDrawerToggle(
-            ContextProvider.getActivityContext(),
-            mDrawerLayout,
-            this,
-            R.string.drawer_open,
-            R.string.drawer_close
-        );
-        mDrawerLayout.setDrawerListener(mDrawerToggle);
-        setupDrawerIconAsync(drawerScreen.icon, screen);
-
-        return mDrawerToggle;
-    }
-
-    public void setDrawerIcon(Drawable icon) {
-        mDrawerIcon = icon;
-    }
-
-    public void showDrawer(boolean animated) {
-        if (mDrawerLayout == null) {
-            return;
-        }
-
-        mDrawerLayout.openDrawer(Gravity.LEFT);
-    }
-
-    public void hideDrawer(boolean animated) {
-        if (mDrawerLayout == null) {
-            return;
-        }
-
-        mDrawerLayout.closeDrawer(Gravity.LEFT);
-    }
-
-    public void toggleDrawer(boolean animated) {
-        if (mDrawerLayout == null) {
-            return;
-        }
-
-        boolean visible = mDrawerLayout.isDrawerOpen(Gravity.LEFT);
-        if (visible) {
-            hideDrawer(animated);
-        } else {
-            showDrawer(animated);
-        }
-    }
-
-    public void setupDrawerIconAsync(String drawerIconSource, Screen screen) {
-        if (mDrawerIconTask == null) {
-            mDrawerIconTask = new SetupDrawerIconTask(this, drawerIconSource, screen).execute();
-        }
-    }
-
-    public void setupToolbarButtonsAsync(Screen newScreen) {
-        if (newScreen != null) {
-            this.setupToolbarButtonsAsync(null, newScreen);
-        }
-    }
-
-
-    public void setupToolbarButtonsAsync(Screen oldScreen, Screen newScreen) {
-        if (mSetupToolbarTask == null) {
-            mSetupToolbarTask = new SetupToolbarButtonsTask(this, oldScreen, newScreen).execute();
-        }
-    }
-
-    public void showToolbar(boolean animated) {
-        ActionBar actionBar = ((AppCompatActivity) getContext()).getSupportActionBar();
-        if (actionBar != null) {
-            actionBar.setShowHideAnimationEnabled(animated);
-            // We hide the ToolBar's parent (AppBarLayout) since this animates the shadow added by AppBar as well
-            ((View) getParent()).setVisibility(VISIBLE);
-        }
-    }
-
-    public void hideToolbar(boolean animated) {
-        ActionBar actionBar = ((AppCompatActivity) getContext()).getSupportActionBar();
-        if (actionBar != null) {
-            actionBar.setShowHideAnimationEnabled(animated);
-            // We hide the ToolBar's parent (AppBarLayout) since this animates the shadow added by AppBar as well
-            ((View) getParent()).setVisibility(GONE);
-        }
-    }
-
-    private void showToolbar() {
-        showToolbar(false);
-    }
-
-    private void hideToolbar() {
-        hideToolbar(false);
-    }
-
-    public void setNavUpButton() {
-        setNavUpButton(null);
-    }
-
-    @SuppressWarnings({"ConstantConditions"})
-    public void setNavUpButton(Screen screen) {
-        BaseReactActivity context = ContextProvider.getActivityContext();
-        if (context == null) {
-            return;
-        }
-
-        ActionBar actionBar = context.getSupportActionBar();
-        if (actionBar == null) {
-            return;
-        }
-
-        boolean isBack = screen != null;
-        boolean hasDrawer = mDrawerToggle != null;
-
-        Drawable navIcon = null;
-        DrawerArrowDrawable navArrow = null;
-        if (hasDrawer && mDrawerIcon == null) {
-            navArrow = (DrawerArrowDrawable) this.getNavigationIcon();
-        } else {
-            if (isBack && !screen.backButtonHidden) {
-                navArrow = new DrawerArrowDrawable(context);
-            } else if (hasDrawer) {
-                navIcon = mDrawerIcon;
-            }
-        }
-
-        if (navArrow != null) {
-            navArrow.setProgress(isBack ? 1.0f : 0.0f);
-            if (screen != null && screen.navBarButtonColor != null) {
-                navArrow.setColor(screen.navBarButtonColor);
-            } else {
-                navArrow.setColor(Color.BLACK);
-            }
-            navIcon = navArrow;
-        }
-
-        actionBar.setHomeAsUpIndicator(navIcon);
-        actionBar.setDisplayHomeAsUpEnabled(navIcon != null);
-    }
-
-    /**
-     * Update the ToolBar from screen. This function sets any properties that are defined
-     * in the screen.
-     * @param screen The currently displayed screen
-     */
-    @UiThread
-    public void update(@NonNull Screen screen) {
-        ((AppCompatActivity) getContext()).setSupportActionBar(this);
-        setTitle(screen.title);
-        setStyle(screen);
-    }
-
-    public void updateAndSetButtons(Screen screen) {
-        update(screen);
-        setupToolbarButtonsAsync(screen);
-    }
-
-    private static class SetupDrawerIconTask extends AsyncTask<Void, Void, Drawable> {
-        private final WeakReference<RnnToolBar> mToolbarWR;
-        private final String mDrawerIconSource;
-        private final Integer mTintColor;
-
-        public SetupDrawerIconTask(RnnToolBar toolBar, String drawerIconSource, Screen screen) {
-            mToolbarWR = new WeakReference<>(toolBar);
-            mDrawerIconSource = drawerIconSource;
-            mTintColor = screen.navBarButtonColor;
-        }
-
-        @Override
-        protected Drawable doInBackground(Void... params) {
-            Context context = ContextProvider.getActivityContext();
-            if (context == null || mDrawerIconSource == null) {
-                return null;
-            }
-
-            return IconUtils.getIcon(context, mDrawerIconSource);
-        }
-
-        @Override
-        protected void onPostExecute(Drawable drawerIcon) {
-            RnnToolBar toolBar = mToolbarWR.get();
-            if (drawerIcon != null) {
-                if (mTintColor != null) {
-                    ImageUtils.tint(drawerIcon, mTintColor);
-                }
-                toolBar.setDrawerIcon(drawerIcon);
-            }
-
-            toolBar.setNavUpButton();
-            mToolbarWR.clear();
-        }
-    }
-
-    private static class SetupToolbarButtonsTask extends AsyncTask<Void, Void, Map<String, Drawable>> {
-        private final List<Button> mOldButtons;
-        private final List<Button> mNewButtons;
-        private final WeakReference<RnnToolBar> mToolbarWR;
-        @ColorInt private final Integer mTintColor;
-        @ColorInt private final Integer mButtonTextColor;
-        private final int mIconDimensions;
-
-        public SetupToolbarButtonsTask(RnnToolBar toolBar, Screen oldScreen, Screen newScreen) {
-            mToolbarWR = new WeakReference<>(toolBar);
-            mOldButtons = oldScreen == null ? null : oldScreen.getButtons();
-            mNewButtons = newScreen.getButtons();
-            mTintColor = newScreen.navBarButtonColor;
-            mButtonTextColor = newScreen.navBarTextColor;
-            mIconDimensions = (int) ImageUtils.convertDpToPixel(48, toolBar.getContext());
-        }
-
-        @Override
-        protected Map<String, Drawable> doInBackground(Void... params) {
-            Context context = ContextProvider.getActivityContext();
-            if (context == null) {
-                return null;
-            }
-
-            Map<String, Drawable> icons = new HashMap<>();
-            for (Button button : mNewButtons) {
-                if (button.hasIcon()) {
-                    icons.put(button.id, button.getIcon(context, mIconDimensions));
-                }
-            }
-            return icons;
-        }
-
-        @Override
-        protected void onPostExecute(Map<String, Drawable> icons) {
-            final Context context = ContextProvider.getActivityContext();
-            if (context == null) {
-                return;
-            }
-
-            Menu menu = ((BaseReactActivity) context).getMenu();
-            if (menu == null) {
-                RnnToolBar toolBar = mToolbarWR.get();
-                if (toolBar != null) {
-                    toolBar.mSetupToolbarTask = null;
-                }
-                mToolbarWR.clear();
-                return;
-            }
-
-            // Remove prev screen buttons
-            if(mOldButtons == null) {
-                menu.clear();
-            } else {
-                for (Button btn : mOldButtons) {
-                    menu.removeItem(btn.getItemId());
-                }
-            }
-
-            // Add new screen buttons
-            final List<String> textButtons = new ArrayList<>();
-            final int size = mNewButtons.size();
-            for (int i = 0; i < size; i++) {
-                Button button = mNewButtons.get(i);
-                MenuItem item = menu.add(Menu.NONE, button.getItemId(), size - i - 1, button.title);
-                item.setShowAsAction(getMenuItemShowAction(button.showAsAction));
-
-                // Set button icon
-                if (button.hasIcon()) {
-                    Drawable icon = icons.get(button.id);
-                    if (mTintColor != null) {
-                        ImageUtils.tint(icon, mTintColor);
-                    }
-                    item.setIcon(icon);
-                } else {
-                    textButtons.add(button.title);
-                }
-
-                // Disable button if needed
-                if (button.disabled) {
-                    item.setEnabled(false);
-                }
-            }
-
-            final RnnToolBar toolBar = mToolbarWR.get();
-            if (toolBar != null) {
-                // Tint overflow icon which appears when there's not enough space in Toolbar for icons
-                if (mTintColor != null) {
-                    ImageUtils.tint(toolBar.getOverflowIcon(), mTintColor);
-                }
-
-                // Tint text buttons
-                if (textButtons.size() > 0 && mButtonTextColor != null) {
-                    final View decorView = ((Activity) context).getWindow().getDecorView();
-                    decorView.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
-                        @Override
-                        public void onGlobalLayout() {
-                            decorView.getViewTreeObserver().removeOnGlobalLayoutListener(this);
-
-                            // Find TextViews
-                            for (String text : textButtons) {
-                                decorView.findViewsWithText(toolBar.mMenuItems, text, View.FIND_VIEWS_WITH_CONTENT_DESCRIPTION);
-                            }
-
-                            // Set text color
-                            for (View button : toolBar.mMenuItems) {
-                                ((TextView) button).setTextColor(mButtonTextColor);
-                            }
-
-                            toolBar.mMenuItems.clear();
-                        }
-                    });
-                }
-
-                toolBar.mSetupToolbarTask = null;
-                mToolbarWR.clear();
-            }
-        }
-
-        private int getMenuItemShowAction(String action) {
-            switch (action) {
-                case "never":
-                    return MenuItem.SHOW_AS_ACTION_NEVER;
-                case "always":
-                    return MenuItem.SHOW_AS_ACTION_ALWAYS;
-                case "withText":
-                    return MenuItem.SHOW_AS_ACTION_WITH_TEXT;
-                default:
-                    return MenuItem.SHOW_AS_ACTION_IF_ROOM;
-            }
-        }
-    }
-}

android/app/src/main/java/com/reactnativenavigation/views/ScreenStack.java

@@ -1,179 +0,0 @@
-package com.reactnativenavigation.views;
-
-import android.animation.LayoutTransition;
-import android.content.Context;
-import android.support.design.widget.CoordinatorLayout;
-import android.util.AttributeSet;
-import android.view.ViewGroup;
-
-import com.facebook.react.ReactInstanceManager;
-import com.reactnativenavigation.activities.BaseReactActivity;
-import com.reactnativenavigation.core.RctManager;
-import com.reactnativenavigation.core.objects.Screen;
-
-import java.util.Stack;
-
-import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
-
-public class ScreenStack extends android.support.design.widget.CoordinatorLayout {
-
-    private static final int DISAPPEAR_ANIMATION_DELAY = 200;
-
-    private static class ScreenView {
-        Screen screen;
-        RctView view;
-
-        public ScreenView(Screen screen, RctView view) {
-            this.screen = screen;
-            this.view = view;
-        }
-    }
-
-    private final Stack<ScreenView> mStack = new Stack<>();
-    private final ReactInstanceManager mReactInstanceManager = RctManager.getInstance().getReactInstanceManager();
-    private BaseReactActivity mReactActivity;
-
-    public ScreenStack(BaseReactActivity context) {
-        super(context);
-        init(context);
-    }
-
-    public ScreenStack(Context context, AttributeSet attrs) {
-        super(context, attrs);
-        init(context);
-    }
-
-    private void init(Context context) {
-        mReactActivity = (BaseReactActivity) context;
-        setLayoutTransition(new LayoutTransition());
-    }
-
-    public void push(Screen screen) {
-        push(screen, null);
-    }
-
-    public void push(Screen screen, RctView.OnDisplayedListener onDisplayed) {
-        RctView oldView = mStack.isEmpty() ? null : mStack.peek().view;
-        RctView view = new RctView(mReactActivity, mReactInstanceManager, screen, onDisplayed);
-        if (oldView != null) {
-            addView(view, MATCH_PARENT, MATCH_PARENT);
-
-            oldView.onTemporallyRemovedFromScreen();
-            getLayoutTransition().setStartDelay(LayoutTransition.DISAPPEARING, DISAPPEAR_ANIMATION_DELAY);
-            removeView(oldView);
-            getLayoutTransition().setStartDelay(LayoutTransition.DISAPPEARING, 0);
-        } else {
-            addView(view, MATCH_PARENT, MATCH_PARENT);
-        }
-        mStack.push(new ScreenView(screen, view));
-    }
-
-    public Screen pop() {
-        if (mStack.isEmpty() || getStackSize() == 1) {
-            return null;
-        }
-
-        ScreenView popped = mStack.pop();
-
-        RctView newView = mStack.peek().view;
-        addView(newView);
-        newView.onReAddToScreen();
-
-        popped.view.onRemoveFromScreen();
-        removeView(popped.view);
-        return popped.screen;
-    }
-
-    public Screen popToRoot() {
-        if (mStack.isEmpty() || getStackSize() <= 1) {
-            return null;
-        }
-
-        ScreenView oldScreenView = null;
-        while (getStackSize() > 1) {
-            ScreenView popped = mStack.pop();
-            popped.view.onRemoveFromScreen();
-            removeView(popped.view);
-            if (oldScreenView == null) {
-                oldScreenView = popped;
-            }
-        }
-
-        if (!mStack.isEmpty()) {
-            addView(mStack.peek().view, 0);
-        }
-
-        return oldScreenView != null ? oldScreenView.screen : null;
-    }
-
-    public Screen resetTo(Screen screen) {
-        return resetTo(screen, null);
-    }
-
-    public Screen resetTo(Screen screen, RctView.OnDisplayedListener onDisplayed) {
-        RctView view = new RctView(mReactActivity, mReactInstanceManager, screen, onDisplayed);
-        addView(view, MATCH_PARENT, MATCH_PARENT);
-
-        ScreenView oldScreenView = null;
-        if (!mStack.isEmpty()) {
-            while (getStackSize() > 0) {
-                ScreenView popped = mStack.pop();
-                popped.view.onRemoveFromScreen();
-                removeView(popped.view);
-                if (oldScreenView == null) {
-                    oldScreenView = popped;
-                }
-            }
-        }
-
-        // Add screen to stack after it's clear
-        mStack.push(new ScreenView(screen, view));
-
-        if (oldScreenView == null) {
-            return null;
-        }
-
-        return oldScreenView.screen;
-    }
-
-    public boolean isEmpty() {
-        return mStack.isEmpty();
-    }
-
-    public int getStackSize() {
-        return mStack.size();
-    }
-
-    public Screen peek() {
-        return mStack.peek().screen;
-    }
-
-    /**
-     * Remove the ScreenStack from {@code parent} while preventing all child react views from getting unmounted
-     */
-    public void removeFromScreen(ViewGroup parent) {
-        mStack.peek().view.onTemporallyRemovedFromScreen();
-
-        parent.removeView(this);
-    }
-
-    /**
-     * Add ScreenStack to {@code parent}
-     */
-    public void addToScreen(ViewGroup parent) {
-        mStack.peek().view.onReAddToScreen();
-
-        parent.addView(this, new CoordinatorLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT));
-    }
-
-    public void removeAllReactViews() {
-        while (!mStack.empty()) {
-            RctView view = mStack.pop().view;
-            // Ensure view will be properly detached and unmounted
-            view.onRemoveFromScreen();
-            // Unmount the view
-            view.detachReactRootView(mReactInstanceManager);
-        }
-        removeAllViews();
-    }
-}

android/app/src/main/java/com/reactnativenavigation/views/ScrollDirectionListener.java

@@ -0,0 +1,53 @@
+package com.reactnativenavigation.views;
+
+import android.view.ViewGroup;
+import android.view.ViewTreeObserver;
+
+public class ScrollDirectionListener implements ViewTreeObserver.OnScrollChangedListener {
+    public enum Direction {
+        Up, Down
+    }
+
+    public interface OnScrollChanged {
+        void onScrollChanged(Direction direction);
+    }
+
+    private final ViewGroup view;
+    private OnScrollChanged onChanged;
+    private int lastScrollY = -1;
+
+    public ScrollDirectionListener(ViewGroup view, OnScrollChanged onChanged) {
+        this.view = view;
+        this.onChanged = onChanged;
+    }
+
+    @Override
+    public void onScrollChanged() {
+        if (!view.getViewTreeObserver().isAlive()) {
+            return;
+        }
+
+        final int scrollY = view.getScrollY();
+        if (isScrollPositionChanged(scrollY) && !isTopOverscroll(scrollY) && !isBottomOverscroll(scrollY)) {
+            onChanged.onScrollChanged(getScrollDirection(scrollY));
+            lastScrollY = scrollY;
+        }
+    }
+
+    private Direction getScrollDirection(int scrollY) {
+        return scrollY > lastScrollY ? Direction.Down : Direction.Up;
+    }
+
+    private boolean isBottomOverscroll(int scrollY) {
+        return scrollY >= (view.getChildAt(0).getHeight() - view.getHeight());
+    }
+
+    private boolean isTopOverscroll(int scrollY) {
+        return scrollY <= 0;
+    }
+
+    private boolean isScrollPositionChanged(int scrollY) {
+        return scrollY != lastScrollY;
+    }
+
+}

android/app/src/main/java/com/reactnativenavigation/views/SideMenu.java

@@ -0,0 +1,74 @@
+package com.reactnativenavigation.views;
+
+import android.content.Context;
+import android.support.v4.widget.DrawerLayout;
+import android.view.Gravity;
+import android.widget.RelativeLayout;
+
+import com.reactnativenavigation.params.SideMenuParams;
+import com.reactnativenavigation.utils.ViewUtils;
+
+public class SideMenu extends DrawerLayout {
+
+    private ContentView sideMenuView;
+    private RelativeLayout contentContainer;
+
+    public RelativeLayout getContentContainer() {
+        return contentContainer;
+    }
+
+    public void destroy() {
+        sideMenuView.ensureUnmountOnDetachedFromWindow();
+        removeView(sideMenuView);
+    }
+
+    public void setVisible(boolean visible, boolean animated) {
+        if (!isShown() && visible) {
+            openDrawer(animated);
+        }
+
+        if (isShown() && !visible) {
+            closeDrawer(animated);
+        }
+    }
+
+    public void openDrawer() {
+        openDrawer(Gravity.LEFT);
+    }
+
+    public void openDrawer(boolean animated) {
+        openDrawer(Gravity.LEFT, animated);
+    }
+
+    public void closeDrawer(boolean animated) {
+        closeDrawer(Gravity.LEFT, animated);
+    }
+
+    public void toggleVisible(boolean animated) {
+        if (isShown()) {
+            closeDrawer(animated);
+        } else {
+            openDrawer(animated);
+        }
+    }
+
+    public SideMenu(Context context, SideMenuParams sideMenuParams) {
+        super(context);
+        createContentContainer();
+        createSideMenu(sideMenuParams);
+    }
+
+    private void createContentContainer() {
+        LayoutParams lp = new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
+        contentContainer = new RelativeLayout(getContext());
+        contentContainer.setId(ViewUtils.generateViewId());
+        addView(contentContainer, lp);
+    }
+
+    private void createSideMenu(SideMenuParams sideMenuParams) {
+        sideMenuView = new ContentView(getContext(), sideMenuParams.screenId, sideMenuParams.navigationParams);
+        LayoutParams lp = new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.MATCH_PARENT);
+        lp.gravity = Gravity.START;
+        addView(sideMenuView, lp);
+    }
+}

android/app/src/main/java/com/reactnativenavigation/views/TitleBar.java

@@ -0,0 +1,130 @@
+package com.reactnativenavigation.views;
+
+import android.content.Context;
+import android.graphics.drawable.Drawable;
+import android.support.v7.widget.ActionMenuView;
+import android.support.v7.widget.Toolbar;
+import android.view.Menu;
+import android.view.View;
+
+import com.reactnativenavigation.animation.VisibilityAnimator;
+import com.reactnativenavigation.params.StyleParams;
+import com.reactnativenavigation.params.TitleBarButtonParams;
+import com.reactnativenavigation.params.TitleBarLeftButtonParams;
+import com.reactnativenavigation.utils.ViewUtils;
+
+import java.util.List;
+
+public class TitleBar extends Toolbar {
+
+    private boolean hideOnScroll = false;
+    private VisibilityAnimator visibilityAnimator;
+    private LeftButton leftButton;
+    private ActionMenuView actionMenuView;
+
+    public TitleBar(Context context) {
+        super(context);
+    }
+
+    @Override
+    public void onViewAdded(View child) {
+        super.onViewAdded(child);
+        if (child instanceof ActionMenuView) {
+            actionMenuView = (ActionMenuView) child;
+        }
+    }
+
+    public void setRightButtons(List<TitleBarButtonParams> rightButtons, String navigatorEventId) {
+        Menu menu = getMenu();
+        menu.clear();
+
+        if (rightButtons == null) {
+            return;
+        }
+
+        addButtonsToTitleBar(rightButtons, navigatorEventId, menu);
+    }
+
+    public void setLeftButton(TitleBarLeftButtonParams leftButtonParams,
+                              LeftButtonOnClickListener leftButtonOnClickListener, String navigatorEventId, boolean overrideBackPressInJs) {
+        if (shouldSetLeftButton(leftButtonParams)) {
+            createAndSetLeftButton(leftButtonParams, leftButtonOnClickListener, navigatorEventId, overrideBackPressInJs);
+        } else if (hasLeftButton()) {
+            updateLeftButton(leftButtonParams);
+        }
+    }
+
+    public void setStyle(StyleParams params) {
+        setVisibility(params.titleBarHidden ? GONE : VISIBLE);
+        setTitleTextColor(params);
+        colorOverflowButton(params);
+    }
+
+    private void colorOverflowButton(StyleParams params) {
+        Drawable overflowIcon = actionMenuView.getOverflowIcon();
+        if (shouldColorOverflowButton(params, overflowIcon)) {
+            ViewUtils.tintDrawable(overflowIcon, params.titleBarButtonColor.getColor(), true);
+        }
+    }
+
+    private boolean shouldColorOverflowButton(StyleParams params, Drawable overflowIcon) {
+        return overflowIcon != null && params.titleBarButtonColor.hasColor();
+    }
+
+    private void setTitleTextColor(StyleParams params) {
+        if (params.titleBarTitleColor.hasColor()) {
+            setTitleTextColor(params.titleBarTitleColor.getColor());
+        }
+    }
+
+    private void addButtonsToTitleBar(List<TitleBarButtonParams> rightButtons, String navigatorEventId, Menu menu) {
+        for (int i = 0; i < rightButtons.size(); i++) {
+            final TitleBarButton button = new TitleBarButton(menu, this, rightButtons.get(i), navigatorEventId);
+            addButtonInReverseOrder(rightButtons, i, button);
+        }
+    }
+
+    private void addButtonInReverseOrder(List<TitleBarButtonParams> rightButtons, int i, TitleBarButton button) {
+        final int index = rightButtons.size() - i - 1;
+        button.addToMenu(index);
+    }
+
+    private boolean hasLeftButton() {
+        return leftButton != null;
+    }
+
+    private void updateLeftButton(TitleBarLeftButtonParams leftButtonParams) {
+        leftButton.setIconState(leftButtonParams);
+    }
+
+    private boolean shouldSetLeftButton(TitleBarLeftButtonParams leftButtonParams) {
+        return leftButton == null && leftButtonParams != null;
+    }
+
+    private void createAndSetLeftButton(TitleBarLeftButtonParams leftButtonParams,
+                                        LeftButtonOnClickListener leftButtonOnClickListener,
+                                        String navigatorEventId,
+                                        boolean overrideBackPressInJs) {
+        leftButton = new LeftButton(getContext(), leftButtonParams, leftButtonOnClickListener, navigatorEventId,
+                overrideBackPressInJs);
+        setNavigationOnClickListener(leftButton);
+        setNavigationIcon(leftButton);
+    }
+
+    public void setHideOnScroll(boolean hideOnScroll) {
+        this.hideOnScroll = hideOnScroll;
+    }
+
+    public void onScrollChanged(ScrollDirectionListener.Direction direction) {
+        if (hideOnScroll) {
+            if (visibilityAnimator == null) {
+                createScrollAnimator();
+            }
+            visibilityAnimator.onScrollChanged(direction);
+        }
+    }
+
+    private void createScrollAnimator() {
+        visibilityAnimator = new VisibilityAnimator(this, VisibilityAnimator.HideDirection.Up, getHeight());
+    }
+}

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

@@ -0,0 +1,98 @@
+package com.reactnativenavigation.views;
+
+import android.support.annotation.NonNull;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.widget.TextView;
+
+import com.reactnativenavigation.NavigationApplication;
+import com.reactnativenavigation.params.TitleBarButtonParams;
+import com.reactnativenavigation.utils.ViewUtils;
+
+import java.util.ArrayList;
+
+public class TitleBarButton implements MenuItem.OnMenuItemClickListener {
+
+    private final Menu menu;
+    private final View parent;
+    private TitleBarButtonParams buttonParams;
+    private String navigatorEventId;
+
+    public TitleBarButton(Menu menu, View parent, TitleBarButtonParams buttonParams, String navigatorEventId) {
+        this.menu = menu;
+        this.parent = parent;
+        this.buttonParams = buttonParams;
+        this.navigatorEventId = navigatorEventId;
+    }
+
+    public MenuItem addToMenu(int index) {
+        MenuItem item = menu.add(Menu.NONE, Menu.NONE, index, buttonParams.label);
+        item.setShowAsAction(buttonParams.showAsAction.action);
+        item.setEnabled(buttonParams.enabled);
+        setIcon(item);
+        setColor();
+        item.setOnMenuItemClickListener(this);
+        return item;
+    }
+
+
+    private void setIcon(MenuItem item) {
+        if (hasIcon()) {
+            item.setIcon(buttonParams.icon);
+        }
+    }
+
+    private void setColor() {
+        if (!hasColor()) {
+            return;
+        }
+
+        if (hasIcon()) {
+            setIconColor();
+        } else {
+            setTextColor();
+        }
+    }
+
+    private void setIconColor() {
+        ViewUtils.tintDrawable(buttonParams.icon, buttonParams.color.getColor(), buttonParams.enabled);
+    }
+
+    private void setTextColor() {
+        ViewUtils.runOnPreDraw(parent, new Runnable() {
+            @Override
+            public void run() {
+                ArrayList<View> outViews = findActualTextViewInMenuByLabel();
+                setTextColorForFoundButtonViews(outViews);
+            }
+        });
+    }
+
+    @NonNull
+    private ArrayList<View> findActualTextViewInMenuByLabel() {
+        ArrayList<View> outViews = new ArrayList<>();
+        parent.findViewsWithText(outViews, buttonParams.label, View.FIND_VIEWS_WITH_CONTENT_DESCRIPTION);
+        return outViews;
+    }
+
+    private void setTextColorForFoundButtonViews(ArrayList<View> outViews) {
+        for (View button : outViews) {
+            ((TextView) button).setTextColor(buttonParams.color.getColor());
+        }
+    }
+
+    private boolean hasIcon() {
+        return buttonParams.icon != null;
+    }
+
+    private boolean hasColor() {
+        return buttonParams.color.hasColor();
+    }
+
+    @Override
+    public boolean onMenuItemClick(MenuItem item) {
+        NavigationApplication.instance.sendNavigatorEvent(buttonParams.eventId, navigatorEventId);
+        return true;
+    }
+}

android/app/src/main/java/com/reactnativenavigation/views/TitleBarMenuButton.java

@@ -0,0 +1,7 @@
+package com.reactnativenavigation.views;
+
+public class TitleBarMenuButton {
+
+    public TitleBarMenuButton() {
+    }
+}

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

@@ -0,0 +1,74 @@
+package com.reactnativenavigation.views;
+
+import android.content.Context;
+import android.support.design.widget.AppBarLayout;
+import android.support.design.widget.TabLayout;
+
+import com.reactnativenavigation.params.StyleParams;
+import com.reactnativenavigation.params.TitleBarButtonParams;
+import com.reactnativenavigation.params.TitleBarLeftButtonParams;
+import com.reactnativenavigation.utils.ViewUtils;
+
+import java.util.List;
+
+public class TopBar extends AppBarLayout {
+
+    private TitleBar titleBar;
+    private TopTabs topTabs;
+
+    public TopBar(Context context) {
+        super(context);
+        setFitsSystemWindows(true);
+        setId(ViewUtils.generateViewId());
+    }
+
+    public void addTitleBarAndSetButtons(List<TitleBarButtonParams> rightButtons,
+                                         TitleBarLeftButtonParams leftButton,
+                                         LeftButtonOnClickListener leftButtonOnClickListener,
+                                         String navigatorEventId, boolean overrideBackPressInJs) {
+        titleBar = new TitleBar(getContext());
+        addView(titleBar);
+        titleBar.setRightButtons(rightButtons, navigatorEventId);
+        titleBar.setLeftButton(leftButton, leftButtonOnClickListener, navigatorEventId, overrideBackPressInJs);
+    }
+
+    public void setTitle(String title) {
+        titleBar.setTitle(title);
+    }
+
+    public void setStyle(StyleParams styleParams) {
+        if (styleParams.topBarColor.hasColor()) {
+            setBackgroundColor(styleParams.topBarColor.getColor());
+        }
+        setVisibility(styleParams.topBarHidden ? GONE : VISIBLE);
+        titleBar.setStyle(styleParams);
+        setTopTabsStyle(styleParams);
+    }
+
+    public void setTitleBarRightButtons(String navigatorEventId, List<TitleBarButtonParams> titleBarButtons) {
+        titleBar.setRightButtons(titleBarButtons, navigatorEventId);
+    }
+
+    public TabLayout initTabs() {
+        topTabs = new TopTabs(getContext());
+        addView(topTabs);
+        return topTabs;
+    }
+
+    public void setTitleBarLeftButton(String navigatorEventId,
+                                      LeftButtonOnClickListener leftButtonOnClickListener,
+                                      TitleBarLeftButtonParams titleBarLeftButtonParams,
+                                      boolean overrideBackPressInJs) {
+        titleBar.setLeftButton(titleBarLeftButtonParams, leftButtonOnClickListener, navigatorEventId,
+                overrideBackPressInJs);
+    }
+
+    private void setTopTabsStyle(StyleParams style) {
+        if (topTabs == null) {
+            return;
+        }
+
+        topTabs.setTopTabsTextColor(style);
+        topTabs.setSelectedTabIndicatorStyle(style);
+    }
+}

android/app/src/main/java/com/reactnativenavigation/views/TopTabs.java

@@ -0,0 +1,40 @@
+package com.reactnativenavigation.views;
+
+import android.content.Context;
+import android.content.res.ColorStateList;
+import android.support.design.widget.TabLayout;
+
+import com.reactnativenavigation.params.StyleParams;
+
+public class TopTabs extends TabLayout {
+
+    public TopTabs(Context context) {
+        super(context);
+    }
+
+    void setSelectedTabIndicatorStyle(StyleParams style) {
+        if (style.selectedTopTabIndicatorColor.hasColor()) {
+            setSelectedTabIndicatorColor(style.selectedTopTabIndicatorColor.getColor());
+        }
+
+        if (style.selectedTopTabIndicatorHeight >= 0) {
+            setSelectedTabIndicatorHeight(style.selectedTopTabIndicatorHeight);
+        }
+    }
+
+    void setTopTabsTextColor(StyleParams style) {
+        ColorStateList originalTabColors = getTabTextColors();
+        int selectedTabColor = originalTabColors != null ? originalTabColors.getColorForState(TabLayout.SELECTED_STATE_SET, -1) : -1;
+        int tabTextColor = originalTabColors != null ? originalTabColors.getColorForState(TabLayout.EMPTY_STATE_SET, -1) : -1;
+
+        if (style.topTabTextColor.hasColor()) {
+            tabTextColor = style.topTabTextColor.getColor();
+        }
+
+        if (style.selectedTopTabTextColor.hasColor()) {
+            selectedTabColor = style.selectedTopTabTextColor.getColor();
+        }
+
+        setTabTextColors(tabTextColor, selectedTabColor);
+    }
+}