SetTopBarVisibility

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

 
 import com.reactnativenavigation.views.ScrollDirectionListener;
 
-public class OnScrollAnimator {
+// TODO find a better name for this class
+public class VisibilityAnimator {
 
     public enum HideDirection {
         Up, Down
     }
 
-    private enum State {
+    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 final int shownEndValue = 0;
-    private State state = State.Shown;
+    private VisibilityState visibilityState = VisibilityState.Shown;
 
-    public OnScrollAnimator(View view, HideDirection hideDirection, int height) {
+    public VisibilityAnimator(View view, HideDirection hideDirection, int height) {
         this.view = view;
         this.hideDirection = hideDirection;
         this.hiddenEndValue = hideDirection == HideDirection.Up ? -height : height;
         }
     }
 
-    public void show() {
-        ObjectAnimator animator = createAnimator(true);
-        animator.start();
-    }
-
-    public void hide() {
-        ObjectAnimator animator = createAnimator(false);
-        animator.start();
+    public void setVisible(boolean visible, boolean animate) {
+        if (isShowing() && !visible) {
+            hide(animate);
+        } else if (isHiding() && visible) {
+            show(animate);
+        }
     }
 
     private void handleUpHidingViews(ScrollDirectionListener.Direction scrollDirection) {
-        if (scrollUp(scrollDirection) && !showing()) {
-            show();
-        } else if (scrollDown(scrollDirection) && !hiding()) {
-            hide();
+        if (scrollUp(scrollDirection) && !isShowing()) {
+            show(true);
+        } else if (scrollDown(scrollDirection) && !isHiding()) {
+            hide(true);
         }
     }
 
     private void handleDownHidingViews(ScrollDirectionListener.Direction scrollDirection) {
-        if (scrollDown(scrollDirection) && !hiding()) {
-            hide();
-        } else if (scrollUp(scrollDirection) && !showing()) {
-            show();
+        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);
         }
     }
 
         return scrollDirection == ScrollDirectionListener.Direction.Down;
     }
 
-    private boolean showing() {
-        return state == State.Shown || state == State.AnimateShow;
+    private boolean isShowing() {
+        return visibilityState == VisibilityState.Shown || visibilityState == VisibilityState.AnimateShow;
     }
 
-    private boolean hiding() {
-        return state == State.Hidden || state == State.AnimateHide;
+    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 ? shownEndValue : hiddenEndValue);
+        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) {
-                state = show ? State.AnimateShow : State.AnimateHide;
+                visibilityState = show ? VisibilityState.AnimateShow : VisibilityState.AnimateHide;
             }
 
             @Override
             public void onAnimationEnd(Animator animation) {
-                state = show ? State.Shown : State.Hidden;
+                visibilityState = show ? VisibilityState.Shown : VisibilityState.Hidden;
             }
         });
         return animator;
     }
-
 }

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

     }
 
     @ReactMethod
-    public void setTopBarVisible(final ReadableMap params) {
+    public void setTopBarVisible(String screenInstanceID, boolean hidden, boolean animated) {
+        NavigationCommandsHandler.toggleTopBarVisible(screenInstanceID, hidden, animated);
     }
 
     @ReactMethod

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

     void newStack(ScreenParams params) {
         layout.newStack(params);
     }
+
+    void setTopBarVisible(String screenInstanceID, boolean hidden, boolean animated) {
+        layout.setTopBarVisible(screenInstanceID, hidden, animated);
+    }
 }

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

             }
         });
     }
+
+    public static void toggleTopBarVisible(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);
+            }
+        });
+    }
 }

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

     void popToRoot(ScreenParams params);
 
     void newStack(ScreenParams params);
+
+    void setTopBarVisible(String screenInstanceID, boolean hidden, boolean animated);
 }

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

 import android.view.Window;
 import android.widget.RelativeLayout;
 
-import com.reactnativenavigation.animation.OnScrollAnimator;
+import com.reactnativenavigation.animation.VisibilityAnimator;
 import com.reactnativenavigation.params.ScreenParams;
 import com.reactnativenavigation.params.ScreenStyleParams;
 import com.reactnativenavigation.utils.SdkSupports;
+import com.reactnativenavigation.utils.ViewUtils;
 import com.reactnativenavigation.views.ScrollDirectionListener;
 import com.reactnativenavigation.views.TopBar;
 
 
     protected final ScreenParams screenParams;
     protected TopBar topBar;
-    private OnScrollAnimator scrollAnimator;
+    private VisibilityAnimator topBarVisibilityAnimator;
 
     public Screen(Context context, ScreenParams screenParams) {
         super(context);
 
     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());
+                }
+            }
+        });
+    }
+
     private void setStyle(ScreenStyleParams styleParams) {
         setStatusBarColor(styleParams.statusBarColor);
         setNavigationBarColor(styleParams.navigationBarColor);
 
     @Override
     public void onScrollChanged(ScrollDirectionListener.Direction direction) {
-        if (scrollAnimator == null) {
-            scrollAnimator = new OnScrollAnimator(topBar, OnScrollAnimator.HideDirection.Up, topBar.getHeight());
-        }
-        scrollAnimator.onScrollChanged(direction);
+        topBarVisibilityAnimator.onScrollChanged(direction);
     }
 
     public abstract void ensureUnmountOnDetachedFromWindow();
 
     public abstract void preventUnmountOnDetachedFromWindow();
+
+    public String getScreenInstanceId() {
+        return screenParams.screenInstanceId;
+    }
+
+    public void setTopBarVisible(boolean visible, boolean animate) {
+        topBarVisibilityAnimator.setVisible(visible, animate);
+    }
 }

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

 
 import com.reactnativenavigation.params.ScreenParams;
 
+import java.util.Iterator;
 import java.util.Stack;
 
 import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
         return getStackSize() > 1;
     }
 
+    public void setTopBarVisible(String screenInstanceID, boolean visible, boolean animate) {
+        Screen screen = findScreenByScreenInstanceId(screenInstanceID);
+        if (screen != null) {
+            screen.setTopBarVisible(visible, animate);
+        }
+    }
 
-//    /**
+    private Screen findScreenByScreenInstanceId(String screenInstanceId) {
+        if (stack.isEmpty()) {
+            return null;
+        }
+
+        Iterator<Screen> iterator = stack.iterator();
+        while (iterator.hasNext()) {
+            Screen next = iterator.next();
+            if (next.getScreenInstanceId().equals(screenInstanceId)) {
+                return next;
+            }
+        }
+
+        return null;
+    }
+
+
+    //    /**
 //     * Remove the ScreenStack from {@code parent} while preventing all child react views from getting unmounted
 //        -= USE WHEN SWITCHING TABS =-
 //     */

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

     public void newStack(ScreenParams params) {
         createStack(getContext());
     }
+
+    @Override
+    public void setTopBarVisible(String screenInstanceID, boolean visible, boolean animate) {
+        stack.setTopBarVisible(screenInstanceID, visible, animate);
+    }
 }

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

 
 public class ScreenParams {
     public String screenId;
-    public String screenInstanceId;
     public Bundle passProps;
-    public String navigatorEventId;
     public List<TitleBarButtonParams> buttons;
     public String title;
     public ScreenStyleParams styleParams;
-    public Bundle navigationParams;
     public List<TopTabParams> topTabParams;
     //    public String tabLabel; TODO when tabs are supported move to TabParams
     //    public Drawable tabIcon;
 
+    // TODO navigationParams should be a class with a `toBundle` method or something. Then we wouldn't neet to keep these two fields here
+    public String screenInstanceId;
+    public String navigatorEventId;
+    public Bundle navigationParams;
+
     public boolean hasTopTabs() {
         return topTabParams != null && !topTabParams.isEmpty();
     }

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

         assertKeyExists(params, KEY_NAVIGATION_PARAMS);
         result.navigationParams = params.getBundle(KEY_NAVIGATION_PARAMS);
         result.navigatorEventId = result.navigationParams.getString(KEY_NAVIGATOR_EVENT_ID);
+        result.screenInstanceId = result.navigationParams.getString(KEY_SCREEN_INSTANCE_ID);
         result.buttons = TitleBarButtonParamsParser.parse(params.getBundle(KEY_BUTTONS));
         result.title = params.getString(KEY_TITLE);
         result.styleParams = ScreenStyleParamsParser.parse(params.getBundle(STYLE_PARAMS));

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

 import android.support.v7.widget.Toolbar;
 import android.view.Menu;
 
-import com.reactnativenavigation.animation.OnScrollAnimator;
+import com.reactnativenavigation.animation.VisibilityAnimator;
 import com.reactnativenavigation.params.TitleBarButtonParams;
 
 import java.util.List;
 public class TitleBar extends Toolbar {
 
     private boolean hideOnScroll = false;
-    private OnScrollAnimator onScrollAnimator;
+    private VisibilityAnimator visibilityAnimator;
 
     public TitleBar(Context context) {
         super(context);
 
     public void onScrollChanged(ScrollDirectionListener.Direction direction) {
         if (hideOnScroll) {
-            if (onScrollAnimator == null) {
+            if (visibilityAnimator == null) {
                 createScrollAnimator();
             }
-            onScrollAnimator.onScrollChanged(direction);
+            visibilityAnimator.onScrollChanged(direction);
         }
     }
 
     private void createScrollAnimator() {
-        onScrollAnimator = new OnScrollAnimator(this, OnScrollAnimator.HideDirection.Up, getHeight());
+        visibilityAnimator = new VisibilityAnimator(this, VisibilityAnimator.HideDirection.Up, getHeight());
     }
 }

src/Screen.js

 const _allNavigatorEventHandlers = {};
 
 class Navigator {
-  constructor(navigatorID, navigatorEventID) {
+  constructor(navigatorID, navigatorEventID, screenInstanceID) {
     this.navigatorID = navigatorID;
+    this.screenInstanceID = screenInstanceID;
     this.navigatorEventID = navigatorEventID;
     this.navigatorEventHandler = null;
     this.navigatorEventSubscription = null;
   constructor(props) {
     super(props);
     if (props.navigatorID) {
-      this.navigator = new Navigator(props.navigatorID, props.navigatorEventID);
+      this.navigator = new Navigator(props.navigatorID, props.navigatorEventID, props.screenInstanceID);
     }
   }
 

src/deprecated/platformSpecificDeprecated.android.js

 }
 
 function navigatorToggleNavBar(navigator, params) {
-  //RctActivity.toggleNavigationBar({
-  //  hidden: params.to === 'hidden',
-  //  animated: !(params.animated === false)
-  //});
+  const screenInstanceID = navigator.screenInstanceID;
+  const visible = params.to === 'shown';
+  const animated = !(params.animated === false);
+
+  newPlatformSpecific.toggleTopBarVisible(
+    screenInstanceID,
+    visible,
+    animated
+  );
 }
 
 function navigatorToggleTabs(navigator, params) {

src/platformSpecific.android.js

   NativeModules.NavigationReactModule.newStack(screenParams);
 }
 
+function toggleTopBarVisible(screenInstanceID, visible, animated) {
+  NativeModules.NavigationReactModule.setTopBarVisible(screenInstanceID, visible, animated);
+}
+
 module.exports = {
   startApp,
   push,
   pop,
   popToRoot,
-  newStack
+  newStack,
+  toggleTopBarVisible
 };