merged from mater

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

 import android.os.AsyncTask;
 import android.os.Bundle;
 import android.support.design.widget.CoordinatorLayout;
-import android.view.View;
 
 import com.aurelhubert.ahbottomnavigation.AHBottomNavigation;
 import com.aurelhubert.ahbottomnavigation.AHBottomNavigationItem;
 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.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 int DEFAULT_TAB_SELECTED_COLOR = 0xFF0000FF;
     private static boolean DEFAULT_TAB_INACTIVE_TITLES = true;
 
-    private AHBottomNavigation mBottomNavigation;
+    private BottomNavigation mBottomNavigation;
     private CoordinatorLayout mContentFrame;
     private ArrayList<ScreenStack> mScreenStacks;
     private int mCurrentStackPosition = -1;
         reactInstanceManager = RctManager.getInstance().getReactInstanceManager();
 
         setContentView(R.layout.bottom_tab_activity);
-        toolbar = (RnnToolBar) findViewById(R.id.toolbar);
-        mBottomNavigation = (AHBottomNavigation) findViewById(R.id.bottom_tab_bar);
+        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);
         StyleHelper.updateStyles(toolbar, getCurrentScreen());
 
         if (shouldToggleTabs(screen)) {
-            toggleTabs(screen.bottomTabsHidden, false);
+            mBottomNavigation.toggleTabs(screen.bottomTabsHidden, false);
         }
     }
 
                 StyleHelper.updateStyles(toolbar, currentScreen);
 
                 if (shouldToggleTabs(currentScreen)) {
-                    toggleTabs(currentScreen.bottomTabsHidden, false);
+                    mBottomNavigation.toggleTabs(currentScreen.bottomTabsHidden, false);
                 }
 
                 return popped;
                 StyleHelper.updateStyles(toolbar, currentScreen);
 
                 if (shouldToggleTabs(currentScreen)) {
-                    toggleTabs(currentScreen.bottomTabsHidden, false);
+                    mBottomNavigation.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.setVisibility(View.GONE);
-        } else {
-            mBottomNavigation.setVisibility(View.VISIBLE);
-//            mBottomNavigation.restoreBottomNavigation(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 void setTabsWithIcons(ArrayList<Screen> screens, Map<Screen, Drawable> icons) {
         mScreenStacks = new ArrayList<>();
-        for (Screen screen : screens) {
+        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);
         this.onTabSelected(0, false);
     }
 
-
     @Override
     protected void removeAllReactViews() {
         for (ScreenStack screenStack : mScreenStacks) {

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

 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;
     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 icon;
     public ArrayList<Button> buttons;
     public final boolean backButtonHidden;
+    public boolean bottomTabsHiddenOnScroll;
     public HashMap<String, Object> passedProps = new HashMap<>();
 
     // NavigationReactModule styling
             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/utils/ReflectionUtils.java

 public class ReflectionUtils {
 
     public static boolean setField(Object obj, String name, Object value) {
-        Field field;
         try {
-            field = obj.getClass().getDeclaredField(name);
+            Field field = getField(obj.getClass(), name);
+            if (field == null) {
+                return false;
+            }
             field.setAccessible(true);
             field.set(obj, value);
             return true;
         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
+     */
     public static Object getDeclaredField(Object obj, String fieldName) {
         try {
-            Field f = obj.getClass().getDeclaredField(fieldName);
+            Field f = getField(obj.getClass(), fieldName);
+            if (f == null) {
+                return null;
+            }
             f.setAccessible(true);
             return f.get(obj);
         } catch (Exception e) {

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

+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/RctView.java

 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;
  */
 public class RctView extends FrameLayout {
 
-    private ReactRootView mReactRootView;
+    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();
+                            }
+                        }
+                    });
+                }
+            };
 
     /**
      * Interface used to run some code when the {@link ReactRootView} is visible.
     }
 
     @SuppressWarnings("unchecked")
-    public RctView(BaseReactActivity ctx, ReactInstanceManager rctInstanceManager, Screen screen,
+    public RctView(BaseReactActivity ctx, ReactInstanceManager rctInstanceManager, final Screen screen,
                    final OnDisplayedListener onDisplayedListener) {
         super(ctx);
         setLayoutParams(new FrameLayout.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
 
-        mReactRootView = new ReactRootView(ctx);
-        mReactRootView.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);
         if (screen.passedProps != null) {
             BridgeUtils.addMapToBundle(screen.passedProps, passProps);
         }
+        return passProps;
+    }
 
-        mReactRootView.startReactApplication(rctInstanceManager, componentName, passProps);
+    private void setupScrollViewWithBottomTabs() {
+        scrollView = getScrollView((ViewGroup) getParent());
+        if (scrollView != null) {
+            context = (BottomTabActivity) getContext();
+            attachStateChangeListener(scrollView);
+            addScrollListener();
+        }
+    }
 
-        if (onDisplayedListener != null) {
-            mReactRootView.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
-                @Override
-                public void onGlobalLayout() {
-                    onDisplayedListener.onDisplayed();
-                    mReactRootView.getViewTreeObserver().removeOnGlobalLayoutListener(this);
-                }
-            });
+    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);
+            }
         }
 
-        addView(mReactRootView);
+        return null;
+    }
+
+    private void attachStateChangeListener(ScrollView scrollView) {
+        scrollView.addOnAttachStateChangeListener(stateChangeListener);
+    }
+
+    private void addScrollListener() {
+        scrollView.getViewTreeObserver().addOnScrollChangedListener(scrollChangedListener);
+    }
+
+    private void removeScrollListener() {
+        scrollView.getViewTreeObserver().removeOnScrollChangedListener(scrollChangedListener);
     }
 
     /**
      */
     public void onTemporallyRemovedFromScreen() {
         // Hack in order to prevent the react view from getting unmounted
-        ReflectionUtils.setField(mReactRootView, "mAttachScheduled", true);
+
+        ReflectionUtils.setField(reactRootView, "mAttachScheduled", true);
     }
 
     /**
      * executed and componentWillUnmount is called
      */
     public void onRemoveFromScreen() {
-        ReflectionUtils.setField(mReactRootView, "mAttachScheduled", false);
+        ReflectionUtils.setField(reactRootView, "mAttachScheduled", false);
     }
 
     /**
      * executed and componentWillUnmount is called
      */
     public void onReAddToScreen() {
-        ReflectionUtils.setField(mReactRootView, "mAttachScheduled", false);
+        ReflectionUtils.setField(reactRootView, "mAttachScheduled", false);
     }
 
     public void detachFromScreen() {
-        ReflectionUtils.invoke(mReactRootView, "onDetachedFromWindow");
+        ReflectionUtils.invoke(reactRootView, "onDetachedFromWindow");
     }
 }
 

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

+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/gradle/wrapper/gradle-wrapper.properties

-#Mon Dec 28 10:00:20 PST 2015
+#Wed Jul 13 11:11:29 IDT 2016
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-2.10-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.2-all.zip