Find proper ScrollView and detect scroll

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.util.Log;
 import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewTreeObserver;
+import android.widget.ScrollView;
 
 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.RctView;
 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;
 
+    private ScrollView mScrollView;
+    private ViewTreeObserver.OnScrollChangedListener mScrollChangedListener;
+    private final View.OnAttachStateChangeListener mScrollViewStateChangeListener =
+            new View.OnAttachStateChangeListener() {
+                @Override
+                public void onViewAttachedToWindow(View v) {
+
+                }
+
+                @Override
+                public void onViewDetachedFromWindow(View detachedScrollView) {
+                    detachedScrollView.getViewTreeObserver().removeOnScrollChangedListener(mScrollChangedListener);
+                    detachedScrollView.removeOnAttachStateChangeListener(this);
+
+                    mContentFrame.post(new Runnable() {
+                        @Override
+                        public void run() {
+                            mScrollView = getScrollView(mContentFrame);
+                            if (mScrollView != null) {
+                                mScrollView.addOnAttachStateChangeListener(mScrollViewStateChangeListener);
+                                addScrollListener(mScrollView);
+                            }
+                        }
+                    });
+                }
+            };
+
     @Override
     protected void handleOnCreate() {
         super.handleOnCreate();
 
         setContentView(R.layout.bottom_tab_activity);
         mToolbar = (RnnToolBar) findViewById(R.id.toolbar);
-        mBottomNavigation = (AHBottomNavigation) findViewById(R.id.bottom_tab_bar);
+        mBottomNavigation = (BottomNavigation) findViewById(R.id.bottom_tab_bar);
         mContentFrame = (CoordinatorLayout) findViewById(R.id.contentFrame);
 
         final ArrayList<Screen> screens = (ArrayList<Screen>) getIntent().getSerializableExtra(EXTRA_SCREENS);
                 setupToolbar(screens);
             }
         });
+
+        mContentFrame.setOnHierarchyChangeListener(new ViewGroup.OnHierarchyChangeListener() {
+            @Override
+            public void onChildViewAdded(View parent, View child) {
+                Log.i(TAG, "onChildViewAdded: " + child.getClass());
+            }
+
+            @Override
+            public void onChildViewRemoved(View parent, View child) {
+                Log.d(TAG, "onChildViewRemoved: " + child.getClass());
+            }
+        });
     }
 
     private void setupPages(ArrayList<Screen> screens) {
 
     private void setupBottomTabs(Screen initialScreen) {
         if (initialScreen.bottomTabsHiddenOnScroll) {
+            mScrollView = getScrollView(mContentFrame);
+            if (mScrollView != null) {
+                attachStateChangeListener(mScrollView);
+                addScrollListener(mScrollView);
+            }
+        }
+    }
+
+    private void attachStateChangeListener(ScrollView scrollView) {
+        scrollView.addOnAttachStateChangeListener(mScrollViewStateChangeListener);
+    }
+
+    private void addScrollListener(final ScrollView scrollView) {
+        mScrollChangedListener = new ViewTreeObserver.OnScrollChangedListener() {
+            @Override
+            public void onScrollChanged() {
+                if (scrollView.getViewTreeObserver().isAlive()) {
+                    Log.i(TAG, "onScrollChanged: " + scrollView.getScrollY());
+                }
+            }
+        };
+        scrollView.getViewTreeObserver().addOnScrollChangedListener(mScrollChangedListener);
+    }
+
+    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;
     }
 
     @Override
 
     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);
+
+            if (i == 0) {
+                stack.push(screen, new RctView.OnDisplayedListener() {
+                    @Override
+                    public void onDisplayed() {
+                        setupBottomTabs(screen);
+                    }
+                });
+            } else {
+                stack.push(screen);
+            }
+
             mScreenStacks.add(stack);
             AHBottomNavigationItem item = new AHBottomNavigationItem(screen.label, icons.get(screen), Color.GRAY);
             mBottomNavigation.addItem(item);

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;
     public final String icon;
     public ArrayList<Button> buttons;
     public final boolean backButtonHidden;
-    public final boolean bottomTabsHiddenOnScroll;
+    public boolean bottomTabsHiddenOnScroll;
     public HashMap<String, Object> passedProps = new HashMap<>();
 
     // Navigation styling
         }
         buttons = getButtons(screen);
         backButtonHidden = getBoolean(screen, KEY_BACK_BUTTON_HIDDEN);
-        bottomTabsHiddenOnScroll = getBoolean(screen, KEY_BOTTOM_TABS_HIDDEN_ON_SCROLL);
         setToolbarStyle(screen);
     }
 
             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/RctView.java

 package com.reactnativenavigation.views;
 
 import android.os.Bundle;
-import android.view.ViewTreeObserver;
 import android.widget.FrameLayout;
 
 import com.facebook.react.ReactInstanceManager;
         super(ctx);
         setLayoutParams(new FrameLayout.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
 
-        mReactRootView = new ReactRootView(ctx);
+        mReactRootView = new RnnReactRootView(ctx, onDisplayedListener);
         mReactRootView.setLayoutParams(new FrameLayout.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
 
         String componentName = screen.screenId;
 
         mReactRootView.startReactApplication(rctInstanceManager, componentName, passProps);
 
-        if (onDisplayedListener != null) {
-            mReactRootView.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
-                @Override
-                public void onGlobalLayout() {
-                    onDisplayedListener.onDisplayed();
-                    mReactRootView.getViewTreeObserver().removeOnGlobalLayoutListener(this);
-                }
-            });
-        }
-
         addView(mReactRootView);
     }
 

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();
+        }
+    }
+}