merged from master

.npmignore

 android/bin/
 android/gen/
 android/out/
+android/app/build/
 
 # Gradle files
 android/.gradle/

README.md

     {
       label: 'One', // tab label as appears under the icon in iOS (optional)
       screen: 'example.FirstTabScreen', // unique ID registered with Navigation.registerScreen
-      icon: require('../img/one.png'), // local image asset for the tab icon unselected state (optional)
+      icon: require('../img/one.png'), // local image asset for the tab icon unselected state (optional on iOS)
       selectedIcon: require('../img/one_selected.png'), // local image asset for the tab icon selected state (optional)
       title: 'Screen One', // title of the screen as appears in the nav bar (optional)
       navigatorStyle: {}, // override the navigator style for the tab screen, see "Styling the navigator" below (optional),

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

 package com.reactnativenavigation.activities;
 
-import android.content.BroadcastReceiver;
-import android.content.Context;
 import android.content.Intent;
-import android.content.IntentFilter;
 import android.content.res.Configuration;
 import android.os.Build;
 import android.os.Bundle;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.common.ReactConstants;
-import com.facebook.react.devsupport.DevServerHelper;
 import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
 import com.facebook.react.shell.MainReactPackage;
 import com.reactnativenavigation.BuildConfig;
     public boolean onCreateOptionsMenu(Menu menu) {
         mMenu = menu;
         Screen currentScreen = getCurrentScreen();
-        if (mToolbar != null && currentScreen != null) {
+        if (mToolbar != null && currentScreen != null && !isFinishing()) {
             mToolbar.setupToolbarButtonsAsync(currentScreen);
         }
         return super.onCreateOptionsMenu(menu);
 
     @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 {
-            if (mReactInstanceManager != null) {
-                mReactInstanceManager.onBackPressed();
-            } else {
-                super.onBackPressed();
-            }
+            super.onBackPressed();
         }
     }
 

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

 import android.os.AsyncTask;
 import android.os.Bundle;
 import android.view.Menu;
+import android.view.View;
 import android.widget.FrameLayout;
 
 import com.aurelhubert.ahbottomnavigation.AHBottomNavigation;
         }
     }
 
-    @Override
-    public boolean onCreateOptionsMenu(Menu menu) {
-        boolean ret = super.onCreateOptionsMenu(menu);
-        mToolbar.handleOnCreateOptionsMenuAsync();
-        return ret;
-    }
-
     @Override
     public void push(Screen screen) {
         super.push(screen);
             }
         }
         StyleHelper.updateStyles(mToolbar, getCurrentScreen());
+
+        if (shouldToggleTabs(screen)) {
+            toggleTabs(screen.bottomTabsHidden, false);
+        }
     }
 
     @Override
         for (ScreenStack stack : mScreenStacks) {
             if (stack.peek().navigatorId.equals(navigatorId)) {
                 Screen popped = stack.pop();
-                StyleHelper.updateStyles(mToolbar, getCurrentScreen());
+                Screen currentScreen = getCurrentScreen();
+                StyleHelper.updateStyles(mToolbar, currentScreen);
+
+                if (shouldToggleTabs(currentScreen)) {
+                    toggleTabs(currentScreen.bottomTabsHidden, false);
+                }
+
                 return popped;
             }
         }
         for (ScreenStack stack : mScreenStacks) {
             if (stack.peek().navigatorId.equals(navigatorId)) {
                 Screen popped = stack.popToRoot();
-                StyleHelper.updateStyles(mToolbar, getCurrentScreen());
+                Screen currentScreen = getCurrentScreen();
+                StyleHelper.updateStyles(mToolbar, currentScreen);
+
+                if (shouldToggleTabs(currentScreen)) {
+                    toggleTabs(currentScreen.bottomTabsHidden, false);
+                }
+
                 return popped;
             }
         }
     public void toggleTabs(ReadableMap params) {
         boolean hide = params.getBoolean(KEY_HIDDEN);
         boolean animated = params.getBoolean(KEY_ANIMATED);
+        toggleTabs(hide, animated);
+    }
+
+    // TODO: support animated = false -guyca
+    private void toggleTabs(boolean hide, boolean animated) {
         if (hide) {
-            mBottomNavigation.hideBottomNavigation(animated);
+//            mBottomNavigation.hideBottomNavigation(animated);
+            mBottomNavigation.setVisibility(View.GONE);
         } else {
-            mBottomNavigation.restoreBottomNavigation(animated);
+            mBottomNavigation.setVisibility(View.VISIBLE);
+//            mBottomNavigation.restoreBottomNavigation(animated);
         }
     }
 
+    private boolean shouldToggleTabs(Screen newScreen) {
+        return mBottomNavigation.isShown() == newScreen.bottomTabsHidden;
+    }
+
     private static class SetupTabsTask extends AsyncTask<Void, Void, Map<Screen, Drawable>> {
         private BottomTabActivity mActivity;
         private RnnToolBar mToolBar;

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

     @Override
     protected void handleOnCreate() {
         super.handleOnCreate();
-        // Trigger react context initialization, global javascript code will now execute
-        getReactInstanceManager().createReactContextInBackground();
+        if (!getReactInstanceManager().hasStartedCreatingInitialContext()) {
+            // Trigger react context initialization, global javascript code will now execute
+            getReactInstanceManager().createReactContextInBackground();
+        }
     }
 
     @Override

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

     }
 
     protected void setupToolbar(Screen screen) {
-        mToolbar.update(screen);
         StyleHelper.updateStyles(mToolbar, screen);
     }
 

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

 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;
             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);

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

     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_PROPS = "passProps";
 
     public String title;
     @Nullable @ColorInt public Integer tabNormalTextColor;
     @Nullable @ColorInt public Integer tabSelectedTextColor;
     @Nullable @ColorInt public Integer tabIndicatorColor;
+    public Boolean bottomTabsHidden;
 
     @NonNull
     public List<Button> getButtons() {
             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);
         }
     }
 }

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

 package com.reactnativenavigation.utils;
 
+import android.support.annotation.Nullable;
+
 import com.reactnativenavigation.activities.BaseReactActivity;
 
 import java.lang.ref.WeakReference;
     /**
      * Returns the currently resumed activity or {@code null} if there is none.
      */
-    public static BaseReactActivity getActivityContext() {
+    public static @Nullable BaseReactActivity getActivityContext() {
         return sActivityWR != null ? sActivityWR.get() : null;
     }
 

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

         try {
             toolBar.updateAndSetButtons(screen);
             setWindowStyle(screen);
-            toolBar.setupToolbarButtonsAsync(screen);
         } catch (Exception e) {
             Log.w("RNNavigation", "Tried to update styles with no screen!");
         }

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

 
     @SuppressWarnings({"ConstantConditions"})
     public void setNavUpButton(Screen screen) {
-        ActionBar actionBar = ContextProvider.getActivityContext().getSupportActionBar();
+        BaseReactActivity context = ContextProvider.getActivityContext();
+        if (context == null) {
+            return;
+        }
+
+        ActionBar actionBar = context.getSupportActionBar();
         if (actionBar == null) {
             return;
         }
             navArrow = (DrawerArrowDrawable) this.getNavigationIcon();
         } else {
             if (isBack && !screen.backButtonHidden) {
-                navArrow = new DrawerArrowDrawable(ContextProvider.getActivityContext());
+                navArrow = new DrawerArrowDrawable(context);
             } else if (hasDrawer) {
                 navIcon = mDrawerIcon;
             }

src/platformSpecific.android.js

     addNavigatorParams(tab, null, idx);
     addNavigatorButtons(tab);
     addNavigationStyleParams(tab);
-    if (tab.icon) {
-      const icon = resolveAssetSource(tab.icon);
-      if (icon) {
-        tab.icon = icon.uri;
-      }
-    }
+    addTabIcon(tab);
     tab.passProps = params.passProps;
   });
 
   RctActivity.startTabBasedApp(params.tabs, params.tabsStyle, drawer);
 }
 
+function addTabIcon(tab) {
+  if (tab.icon) {
+    const icon = resolveAssetSource(tab.icon);
+    if (icon) {
+      tab.icon = icon.uri;
+    }
+  }
+
+  if (!tab.icon) {
+    throw new Error("No icon defined for tab " + tab.screen);
+  }
+}
+
 function navigatorPush(navigator, params) {
   addNavigatorParams(params, navigator);
   addNavigatorButtons(params);