Top bar options changes (#2771)

* Rename TopBar.animateHide to animate

also fix some options in playground app

* Consolidate topBar visibility in childWillDisappear

* Rename BottomTabs.animateHide to animate

lib/android/app/src/main/java/com/reactnativenavigation/anim/NavigationAnimator.java

 
     public void animatePop(View view, @Nullable final NavigationAnimationListener animationListener) {
         ObjectAnimator alpha = ObjectAnimator.ofFloat(view, View.ALPHA, 1, 0);
-        alpha.setInterpolator(ACCELERATE_INTERPOLATOR);
+        ObjectAnimator translationY = ObjectAnimator.ofFloat(view, View.TRANSLATION_Y, 0, this.translationY);
 
         AnimatorSet set = new AnimatorSet();
         set.addListener(new AnimatorListenerAdapter() {
                 }
             }
         });
-        ObjectAnimator translationY = ObjectAnimator.ofFloat(view, View.TRANSLATION_Y, 0, this.translationY);
-        translationY.setInterpolator(ACCELERATE_INTERPOLATOR);
-        translationY.setDuration(DURATION);
-        alpha.setDuration(DURATION);
         set.playTogether(translationY, alpha);
+        set.setDuration(DURATION);
+        set.setInterpolator(ACCELERATE_INTERPOLATOR);
         set.start();
     }
 }

lib/android/app/src/main/java/com/reactnativenavigation/anim/TopBarAnimator.java

 
     private TopBar topBar;
     private View contentView;
+    private ObjectAnimator hideAnimator;
+    private ObjectAnimator showAnimator;
 
     public TopBarAnimator(TopBar topBar) {
         this.topBar = topBar;
     }
 
-    public TopBarAnimator(TopBar topBar, View contentView) {
-        this.topBar = topBar;
-        this.contentView = contentView;
-    }
-
     public void show() {
         show(-1 * topBar.getMeasuredHeight(), decelerateInterpolator, DURATION_TOPBAR);
     }
 
     public void show(float startTranslation, TimeInterpolator interpolator, int duration) {
-        ObjectAnimator topbarAnim = ObjectAnimator.ofFloat(topBar, View.TRANSLATION_Y, startTranslation, 0);
-        topbarAnim.setInterpolator(interpolator);
-        topbarAnim.setDuration(duration);
+        showAnimator = ObjectAnimator.ofFloat(topBar, View.TRANSLATION_Y, startTranslation, 0);
+        showAnimator.setInterpolator(interpolator);
+        showAnimator.setDuration(duration);
 
-        topbarAnim.addListener(new AnimatorListenerAdapter() {
+        showAnimator.addListener(new AnimatorListenerAdapter() {
 
             @Override
             public void onAnimationStart(Animator animation) {
                 }
             }
         });
-        topbarAnim.start();
+        showAnimator.start();
     }
 
     public void hide() {
     }
 
     void hide(float startTranslation, TimeInterpolator interpolator, int duration) {
-        ObjectAnimator animator = ObjectAnimator.ofFloat(topBar, View.TRANSLATION_Y, startTranslation, -1 * topBar.getMeasuredHeight());
-        animator.setInterpolator(interpolator);
-        animator.setDuration(duration);
+        hideAnimator = ObjectAnimator.ofFloat(topBar, View.TRANSLATION_Y, startTranslation, -1 * topBar.getMeasuredHeight());
+        hideAnimator.setInterpolator(interpolator);
+        hideAnimator.setDuration(duration);
 
-        animator.addListener(new AnimatorListenerAdapter() {
+        hideAnimator.addListener(new AnimatorListenerAdapter() {
             @Override
             public void onAnimationEnd(Animator animation) {
                 if (contentView != null) {
                 topBar.setVisibility(View.GONE);
             }
         });
-        animator.start();
+        hideAnimator.start();
+    }
+
+    public boolean isRunning() {
+        return (hideAnimator != null && hideAnimator.isRunning()) || (showAnimator != null && showAnimator.isRunning());
     }
 }

lib/android/app/src/main/java/com/reactnativenavigation/parse/BottomTabsOptions.java

         options.currentTabId = TextParser.parse(json, "currentTabId");
 		options.currentTabIndex = NumberParser.parse(json,"currentTabIndex");
 		options.visible = BoolParser.parse(json,"visible");
-		options.animateHide = BoolParser.parse(json,"animateHide");
+		options.animate = BoolParser.parse(json,"animate");
         options.testId = TextParser.parse(json, "testID");
 
 		return options;
     public Color backgroundColor = new NullColor();
     public Color tabColor = new NullColor();
     public Color selectedTabColor = new NullColor();
-	Bool visible = new NullBool();
-	Bool animateHide = new NullBool();
+	public Bool visible = new NullBool();
+	public Bool animate = new NullBool();
 	public Number currentTabIndex = new NullNumber();
 	public Text currentTabId = new NullText();
     public Text testId = new NullText();
 		if (other.visible.hasValue()) {
 			visible = other.visible;
 		}
-		if (other.animateHide.hasValue()) {
-			animateHide = other.animateHide;
+		if (other.animate.hasValue()) {
+			animate = other.animate;
 		}
         if (other.tabColor.hasValue()) {
             tabColor = other.tabColor;
         if (!visible.hasValue()) {
             visible = defaultOptions.visible;
         }
-        if (!animateHide.hasValue()) {
-            animateHide = defaultOptions.animateHide;
+        if (!animate.hasValue()) {
+            animate = defaultOptions.animate;
         }
         if (!tabColor.hasValue()) {
             tabColor = defaultOptions.tabColor;

lib/android/app/src/main/java/com/reactnativenavigation/parse/TopBarOptions.java

         options.textFontSize = FractionParser.parse(json, "textFontSize");
         options.textFontFamily = typefaceManager.getTypeFace(json.optString("textFontFamily", ""));
         options.visible = BoolParser.parse(json, "visible");
-        options.animateHide = BoolParser.parse(json,"animateHide");
+        options.animate = BoolParser.parse(json,"animate");
         options.hideOnScroll = BoolParser.parse(json,"hideOnScroll");
         options.drawBehind = BoolParser.parse(json,"drawBehind");
         options.rightButtons = Button.parseJsonArray(json.optJSONArray("rightButtons"));
     public Fraction textFontSize = new NullFraction();
     @Nullable public Typeface textFontFamily;
     public Bool visible = new NullBool();
-    public Bool animateHide = new NullBool();
+    public Bool animate = new NullBool();
     public Bool hideOnScroll = new NullBool();
     public Bool drawBehind = new NullBool();
     public ArrayList<Button> leftButtons;
         if (other.visible.hasValue()) {
             visible = other.visible;
         }
-        if (other.animateHide.hasValue()) {
-            animateHide = other.animateHide;
+        if (other.animate.hasValue()) {
+            animate = other.animate;
         }
         if (other.hideOnScroll.hasValue()) {
             hideOnScroll = other.hideOnScroll;
             textFontFamily = defaultOptions.textFontFamily;
         if (!visible.hasValue())
             visible = defaultOptions.visible;
-        if (!animateHide.hasValue())
-            animateHide = defaultOptions.animateHide;
+        if (!animate.hasValue())
+            animate = defaultOptions.animate;
         if (!hideOnScroll.hasValue())
             hideOnScroll = defaultOptions.hideOnScroll;
         if (!drawBehind.hasValue())

lib/android/app/src/main/java/com/reactnativenavigation/presentation/OptionsPresenter.java

 package com.reactnativenavigation.presentation;
 
-import android.view.View;
-
-import com.github.clans.fab.FloatingActionButton;
 import com.reactnativenavigation.parse.Button;
-import com.reactnativenavigation.parse.FabOptions;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.TopBarOptions;
 import com.reactnativenavigation.parse.TopTabOptions;
 import com.reactnativenavigation.parse.TopTabsOptions;
-import com.reactnativenavigation.views.Fab;
 import com.reactnativenavigation.views.ReactComponent;
 import com.reactnativenavigation.views.TopBar;
 
         this.component = component;
     }
 
+    public OptionsPresenter(TopBar topBar) {
+        this.topBar = topBar;
+    }
+
     public void applyOptions(Options options) {
         applyButtons(options.topBarOptions.leftButtons, options.topBarOptions.rightButtons);
         applyTopBarOptions(options.topBarOptions);
 
         topBar.setTitleTypeface(options.textFontFamily);
         if (options.visible.isFalse()) {
-            topBar.hide(options.animateHide);
+            topBar.hide(options.animate);
         }
         if (options.visible.isTrueOrUndefined()) {
-            topBar.show(options.animateHide);
+            topBar.show(options.animate);
         }
         if (options.drawBehind.isTrue()) {
             component.drawBehindTopBar();
             topBar.setTopTabFontFamily(topTabOptions.tabIndex, topTabOptions.fontFamily);
         }
     }
+
+    public void onChildWillDisappear(Options disappearing, Options appearing) {
+        if (disappearing.topBarOptions.visible.isTrueOrUndefined() && appearing.topBarOptions.visible.isFalse()) {
+            topBar.hide(disappearing.topBarOptions.animate);
+        }
+    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/StackController.java

     private static final NoOpPromise NO_OP = new NoOpPromise();
     private final IdStack<ViewController> stack = new IdStack<>();
     private final NavigationAnimator animator;
-    private StackLayout stackLayout;
 
     public StackController(final Activity activity, String id, Options initialOptions) {
         super(activity, id, initialOptions);
 
     @RestrictTo(RestrictTo.Scope.TESTS)
     TopBar getTopBar() {
-        return stackLayout.getTopBar();
+        return getView().getTopBar();
     }
 
     @RestrictTo(RestrictTo.Scope.TESTS)
-    StackLayout getStackLayout() {return stackLayout;}
+    StackLayout getStackLayout() {return getView();}
 
     @Override
     public void applyOptions(Options options, ReactComponent component) {
         super.applyOptions(options, component);
-        stackLayout.applyOptions(this.options, component);
+        getView().applyOptions(this.options, component);
         applyOnParentController(parentController ->
                 ((ParentController) parentController).applyOptions(this.options.copy().clearTopBarOptions(), component)
         );
-        fabOptionsPresenter.applyOptions(options.fabOptions, component, stackLayout);
+        fabOptionsPresenter.applyOptions(options.fabOptions, component, getView());
     }
 
     @Override
     void clearOptions() {
         super.clearOptions();
-        stackLayout.clearOptions();
+        getView().clearOptions();
     }
 
     public void push(ViewController child, final Promise promise) {
             return;
         }
 
-        final ViewController poppedTop = stack.pop();
-        final ViewController newTop = stack.peek();
-        popInternal(poppedTop, newTop);
+        final ViewController exitingController = stack.pop();
+        final ViewController enteringController = stack.peek();
+        popInternal(exitingController, enteringController);
 
-        finishPopping(poppedTop.getView(), poppedTop, promise);
+        finishPopping(exitingController.getView(), exitingController, promise);
     }
 
-	private void animatePop(final Promise promise) {
+	void animatePop(final Promise promise) {
 		if (!canPop()) {
 			Navigator.rejectPromise(promise);
 			return;
 		}
 
-		final ViewController poppedTop = stack.pop();
-        final ViewController newTop = stack.peek();
-        popInternal(poppedTop, newTop);
+		final ViewController exitingController = stack.pop();
+        final ViewController enteringController = stack.peek();
+        popInternal(exitingController, enteringController);
 
-        animator.animatePop(poppedTop.getView(), () -> finishPopping(poppedTop.getView(), poppedTop, promise));
+        animator.animatePop(exitingController.getView(), () -> finishPopping(exitingController.getView(), exitingController, promise));
 	}
 
-    private void popInternal(ViewController poppedTop, ViewController newTop) {
-        poppedTop.onViewWillDisappear();
-        newTop.onViewWillAppear();
-        View enteringView = newTop.getView();
-        getView().addView(enteringView, getView().getChildCount() - 1);
+    private void popInternal(ViewController disappearing, ViewController appearing) {
+        disappearing.onViewWillDisappear();
+        appearing.onViewWillAppear();
+        getView().onChildWillDisappear(disappearing.options, appearing.options);
+        getView().addView(appearing.getView(), getView().indexOfChild(disappearing.getView()));
     }
 
     boolean canPop() {
     @NonNull
     @Override
     protected StackLayout createView() {
-        stackLayout = new StackLayout(getActivity(), this::sendOnNavigationButtonPressed);
-        return stackLayout;
+        return new StackLayout(getActivity(), this::sendOnNavigationButtonPressed);
     }
 
 	@NonNull
 
     @Override
     public void setupTopTabsWithViewPager(ViewPager viewPager) {
-        stackLayout.initTopTabs(viewPager);
+        getView().initTopTabs(viewPager);
     }
 
     @Override
     public void clearTopTabs() {
-        stackLayout.clearTopTabs();
+        getView().clearTopTabs();
     }
 }

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/ViewController.java

     private boolean isShown;
     private boolean isDestroyed;
     private ViewVisibilityListener viewVisibilityListener = new ViewVisibilityListenerAdapter();
-    protected FabOptionsPresenter fabOptionsPresenter;
+    FabOptionsPresenter fabOptionsPresenter;
 
     public ViewController(Activity activity, String id, Options initialOptions) {
         this.activity = activity;

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/toptabs/TopTabsController.java

     @Override
     public void onViewWillDisappear() {
         super.onViewWillDisappear();
-        applyOnParentController(parentController -> ((ParentController) parentController).clearTopTabs());
     }
 
     @Override
     public void onViewDisappear() {
         performOnCurrentTab(ViewController::onViewDisappear);
+        applyOnParentController(parentController -> ((ParentController) parentController).clearTopTabs());
     }
 
     @Override

lib/android/app/src/main/java/com/reactnativenavigation/views/StackLayout.java

 import android.content.Context;
 import android.support.annotation.RestrictTo;
 import android.support.v4.view.ViewPager;
-import android.util.Log;
-import android.view.Gravity;
-import android.view.View;
 import android.widget.RelativeLayout;
 
-import com.github.clans.fab.FloatingActionButton;
 import com.reactnativenavigation.parse.Options;
-import com.reactnativenavigation.presentation.FabOptionsPresenter;
 import com.reactnativenavigation.presentation.OptionsPresenter;
 import com.reactnativenavigation.utils.CompatUtils;
 
 
 @SuppressLint("ViewConstructor")
 public class StackLayout extends RelativeLayout {
-
-    private final TopBar topBar;
+    private TopBar topBar;
 
     public StackLayout(Context context, TitleBarButton.OnClickListener topBarButtonClickListener) {
         super(context);
         new OptionsPresenter(topBar, component).applyOptions(options);
     }
 
-    @RestrictTo(RestrictTo.Scope.TESTS)
-    public TopBar getTopBar() {
-        return topBar;
+    public void onChildWillDisappear(Options disappearing, Options appearing) {
+        new OptionsPresenter(topBar).onChildWillDisappear(disappearing, appearing);
     }
 
     public void clearOptions() {
     public void clearTopTabs() {
         topBar.clearTopTabs();
     }
+
+    @RestrictTo(RestrictTo.Scope.TESTS)
+    public TopBar getTopBar() {
+        return topBar;
+    }
+
+    @RestrictTo(RestrictTo.Scope.TESTS)
+    public void setTopBar(TopBar topBar) {
+        this.topBar = topBar;
+    }
 }

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

         }
         if (animated.isTrueOrUndefined()) {
             animator.show();
-        } else {
+        } else if (!animator.isRunning()) {
             setVisibility(View.VISIBLE);
         }
     }
         }
         if (animated.isTrueOrUndefined()) {
             animator.hide();
-        } else {
+        } else if (!animator.isRunning()){
             setVisibility(View.GONE);
         }
     }

lib/android/app/src/test/java/com/reactnativenavigation/parse/OptionsTest.java

     private static final Bool TOP_BAR_VISIBLE = new Bool(true);
     private static final Bool TOP_BAR_DRAW_BEHIND = new Bool(true);
     private static final Bool TOP_BAR_HIDE_ON_SCROLL = new Bool(true);
-    private static final Bool BOTTOM_TABS_ANIMATE_HIDE = new Bool(true);
+    private static final Bool BOTTOM_TABS_ANIMATE = new Bool(true);
     private static final Bool BOTTOM_TABS_VISIBLE = new Bool(true);
     private static final String BOTTOM_TABS_BADGE = "3";
     private static final String BOTTOM_TABS_CURRENT_TAB_ID = "ComponentId";
         assertThat(result.topBarOptions.visible.get()).isEqualTo(TOP_BAR_VISIBLE.get());
         assertThat(result.topBarOptions.drawBehind.get()).isEqualTo(TOP_BAR_DRAW_BEHIND.get());
         assertThat(result.topBarOptions.hideOnScroll.get()).isEqualTo(TOP_BAR_HIDE_ON_SCROLL.get());
-        assertThat(result.bottomTabsOptions.animateHide.get()).isEqualTo(BOTTOM_TABS_ANIMATE_HIDE.get());
+        assertThat(result.bottomTabsOptions.animate.get()).isEqualTo(BOTTOM_TABS_ANIMATE.get());
         assertThat(result.bottomTabsOptions.visible.get()).isEqualTo(BOTTOM_TABS_VISIBLE.get());
         assertThat(result.bottomTabsOptions.currentTabId.get()).isEqualTo(BOTTOM_TABS_CURRENT_TAB_ID);
         assertThat(result.bottomTabsOptions.currentTabIndex.get()).isEqualTo(BOTTOM_TABS_CURRENT_TAB_INDEX.get());
                 .put("currentTabId", BOTTOM_TABS_CURRENT_TAB_ID)
                 .put("currentTabIndex", BOTTOM_TABS_CURRENT_TAB_INDEX.get())
                 .put("visible", BOTTOM_TABS_VISIBLE.get())
-                .put("animateHide", BOTTOM_TABS_ANIMATE_HIDE.get());
+                .put("animate", BOTTOM_TABS_ANIMATE.get());
     }
 
     @NonNull
     }
 
     @NonNull
-    private JSONObject createOtherTabBar() throws JSONException {
+    private JSONObject createOtherBottomTabs() throws JSONException {
         return new JSONObject()
                 .put("currentTabId", BOTTOM_TABS_CURRENT_TAB_ID)
                 .put("currentTabIndex", BOTTOM_TABS_CURRENT_TAB_INDEX)
                 .put("visible", BOTTOM_TABS_VISIBLE)
-                .put("animateHide", BOTTOM_TABS_ANIMATE_HIDE)
+                .put("animate", BOTTOM_TABS_ANIMATE.get())
                 .put("tabBadge", BOTTOM_TABS_BADGE);
     }
 
         JSONObject defaultJson = new JSONObject()
                 .put("topBar", createOtherTopBar())
                 .put("fab", createOtherFab())
-                .put("bottomTabs", createOtherTabBar());
+                .put("bottomTabs", createOtherBottomTabs());
         Options defaultOptions = Options.parse(mockLoader, defaultJson);
 
         JSONObject json = new JSONObject()
     public void topBar_defaultOptions() throws Exception {
         Options uut = new Options();
         assertThat(uut.topBarOptions.visible.isFalseOrUndefined()).isTrue();
-        assertThat(uut.topBarOptions.animateHide.isTrueOrUndefined()).isTrue();
+        assertThat(uut.topBarOptions.animate.isTrueOrUndefined()).isTrue();
     }
 
     @Test

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/OptionsApplyingTest.java

 
         Options opts = new Options();
         opts.topBarOptions.visible = new Bool(false);
-        opts.topBarOptions.animateHide = new Bool(false);
+        opts.topBarOptions.animate = new Bool(false);
         uut.mergeOptions(opts);
 
         assertThat(stackController.getTopBar().getVisibility()).isEqualTo(View.GONE);

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/StackControllerTest.java

 import com.reactnativenavigation.mocks.SimpleViewController;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.Text;
+import com.reactnativenavigation.parse.params.Bool;
 import com.reactnativenavigation.utils.ViewHelper;
 import com.reactnativenavigation.views.ReactComponent;
+import com.reactnativenavigation.views.StackLayout;
 
 import org.assertj.core.api.iterable.Extractor;
 import org.junit.Test;
         });
     }
 
+    @Test
+    public void pop_layoutHandlesChildWillDisappear() throws Exception {
+        final StackLayout[] stackLayout = new StackLayout[1];
+        uut = new StackController(activity, "uut", new Options()) {
+            @Override
+            protected StackLayout createView() {
+                stackLayout[0] = spy(super.createView());
+                return stackLayout[0];
+            }
+        };
+        uut.push(child1, new MockPromise());
+        uut.animatePush(child2, new MockPromise() {
+            @Override
+            public void resolve(@Nullable Object value) {
+                uut.animatePop(new MockPromise() {
+                    @Override
+                    public void resolve(@Nullable Object value) {
+                        verify(stackLayout[0], times(1)).onChildWillDisappear(child2.options, child1.options);
+                    }
+                });
+            }
+        });
+    }
+
     @Test
     public void stackOperations() throws Exception {
         assertThat(uut.peek()).isNull();
         verify(child2, times(1)).onViewWillDisappear();
     }
 
+    @Test
+    public void pop_animatesTopBarIfNeeded() throws Exception {
+        uut.ensureViewIsCreated();
+        uut.getView().setTopBar(spy(uut.getTopBar()));
+
+        child1.options.topBarOptions.visible = new Bool(false);
+        child1.options.topBarOptions.animate = new Bool(false);
+        child2.options.topBarOptions.visible = new Bool(true);
+        uut.push(child1, new MockPromise());
+        child1.onViewAppeared();
+
+        assertThat(uut.getTopBar().getVisibility()).isEqualTo(View.GONE);
+        uut.push(child2, new MockPromise());
+        uut.animatePop(new MockPromise() {
+            @Override
+            public void resolve(@Nullable Object value) {
+                verify(uut.getTopBar(), times(1)).hide(child2.options.topBarOptions.animate);
+            }
+        });
+    }
+
     @Test
     public void popSpecific_CallsDestroyOnPoppedChild() throws Exception {
         child1 = spy(child1);

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/TopTabsViewControllerTest.java

 import java.util.ArrayList;
 import java.util.List;
 
+import javax.annotation.Nullable;
+
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
     }
 
     @Test
-    public void applyOptions_tabsAreRemovedBeforeViewDisappears() throws Exception {
+    public void applyOptions_tabsAreRemovedAfterViewDisappears() throws Exception {
         parentController.getView().removeAllViews();
 
         StackController stackController = spy(new StackController(activity, "stack", new Options()));
         uut.onViewAppeared();
 
         assertThat(ViewHelper.isVisible(stackController.getTopBar().getTopTabs())).isTrue();
-        stackController.pop(new MockPromise());
-        assertThat(ViewHelper.isVisible(stackController.getTopBar().getTopTabs())).isFalse();
+        stackController.animatePop(new MockPromise() {
+            @Override
+            public void resolve(@Nullable Object value) {
+                assertThat(ViewHelper.isVisible(stackController.getTopBar().getTopTabs())).isFalse();
+            }
+        });
     }
 
     @Test

playground/src/app.js

               name: 'navigation.playground.WelcomeScreen'
             }
           }
-        ],
-        options: {
-          topBar: {
-            visible: false,
-            animateHide: false
-          }
-        }
+        ]
       }
     });
   });

playground/src/screens/OptionsScreen.js

     Navigation.setOptions(this.props.componentId, {
       topBar: {
         visible: true,
-        animateHide: true
+        animate: true
       }
     });
   }
     Navigation.setOptions(this.props.componentId, {
       topBar: {
         visible: false,
-        animateHide: true
+        animate: true
       }
     });
   }

playground/src/screens/TextScreen.js

       bottomTabs: {
         currentTabIndex: 1,
         visible: false,
-        animateHide: true
+        animate: true
       }
     });
   }

playground/src/screens/WelcomeScreen.js

   static get options() {
     return {
       topBar: {
-        largeTitle: false
+        largeTitle: false,
+        drawBehind: true,
+        visible: false,
+        animate: false
       }
     };
   }