Initial implementation of willAppear and willDisappear (#2748)

* Initial implementation of willAppear and willDisappear

Currently only implemented on pop in StackController

* call clearOptions on super
* TopTabs visible

* fix unit

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

 import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
 
+import com.reactnativenavigation.parse.params.Bool;
+import com.reactnativenavigation.parse.params.NullBool;
+import com.reactnativenavigation.parse.parsers.BoolParser;
+
 import org.json.JSONObject;
 
 public class TopTabsOptions implements DEFAULT_VALUES {
     @NonNull public Color selectedTabColor = new NullColor();
     @NonNull public Color unselectedTabColor = new NullColor();
     @NonNull public Number fontSize = new NullNumber();
+    @NonNull public Bool visible = new NullBool();
 
     public static TopTabsOptions parse(@Nullable JSONObject json) {
         TopTabsOptions result = new TopTabsOptions();
         result.selectedTabColor = ColorParser.parse(json, "selectedColor");
         result.unselectedTabColor = ColorParser.parse(json, "unselectedTabColor");
         result.fontSize = NumberParser.parse(json, "fontSize");
+        result.visible = BoolParser.parse(json, "visible");
         return result;
     }
 
         if (other.selectedTabColor.hasValue()) selectedTabColor = other.selectedTabColor;
         if (other.unselectedTabColor.hasValue()) unselectedTabColor = other.unselectedTabColor;
         if (other.fontSize.hasValue()) fontSize = other.fontSize;
+        if (other.visible.hasValue()) visible = other.visible;
     }
 
     void mergeWithDefault(TopTabsOptions defaultOptions) {
         if (!selectedTabColor.hasValue()) selectedTabColor = defaultOptions.selectedTabColor;
         if (!unselectedTabColor.hasValue()) unselectedTabColor = defaultOptions.unselectedTabColor;
         if (!fontSize.hasValue()) fontSize = defaultOptions.fontSize;
+        if (!visible.hasValue()) visible = defaultOptions.visible;
     }
 }

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

     private void applyTopTabsOptions(TopTabsOptions options) {
         topBar.applyTopTabsColors(options.selectedTabColor, options.unselectedTabColor);
         topBar.applyTopTabsFontSize(options.fontSize);
+        topBar.setTopTabsVisible(options.visible.isTrueOrUndefined());
     }
 
     private void applyTopTabOptions(TopTabOptions topTabOptions) {

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

 
 	@CallSuper
     void clearOptions() {
+	    applyOnParentController(parent -> ((ParentController) parent).clearOptions());
         options = initialOptions.copy();
     }
 
     public void setupTopTabsWithViewPager(ViewPager viewPager) {
 
     }
+
+    public void clearTopTabs() {
+
+    }
 }

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

         }
 
         final ViewController poppedTop = stack.pop();
-        ViewController newTop = stack.peek();
+        final ViewController newTop = stack.peek();
+        popInternal(poppedTop, newTop);
 
-        View enteringView = newTop.getView();
-        final View exitingView = poppedTop.getView();
-        getView().addView(enteringView, getView().getChildCount() - 1);
-
-        finishPopping(exitingView, poppedTop, promise);
+        finishPopping(poppedTop.getView(), poppedTop, promise);
     }
 
 	private void animatePop(final Promise promise) {
 		}
 
 		final ViewController poppedTop = stack.pop();
-		ViewController newTop = stack.peek();
+        final ViewController newTop = stack.peek();
+        popInternal(poppedTop, newTop);
 
-		View enteringView = newTop.getView();
-		final View exitingView = poppedTop.getView();
-		getView().addView(enteringView, getView().getChildCount() - 1);
-
-        animator.animatePop(exitingView, () -> finishPopping(exitingView, poppedTop, promise));
+        animator.animatePop(poppedTop.getView(), () -> finishPopping(poppedTop.getView(), poppedTop, promise));
 	}
 
+    private void popInternal(ViewController poppedTop, ViewController newTop) {
+        poppedTop.onViewWillDisappear();
+        newTop.onViewWillAppear();
+        View enteringView = newTop.getView();
+        getView().addView(enteringView, getView().getChildCount() - 1);
+    }
+
     boolean canPop() {
         return stack.size() > 1;
     }
 
     @Override
     public void setupTopTabsWithViewPager(ViewPager viewPager) {
-        stackLayout.setupTopTabsWithViewPager(viewPager);
+        stackLayout.initTopTabs(viewPager);
+    }
+
+    @Override
+    public void clearTopTabs() {
+        stackLayout.clearTopTabs();
     }
 }

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

         return getView().equals(component);
     }
 
+    public void onViewWillAppear() {
+
+    }
+
     public void onViewAppeared() {
         isShown = true;
         applyOptions(options);
         });
     }
 
+    public void onViewWillDisappear() {
+
+    }
+
     public void onViewDisappear() {
         isShown = false;
     }

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

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

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

         topBar.clear();
     }
 
-    public void setupTopTabsWithViewPager(ViewPager viewPager) {
-        topBar.setupTopTabsWithViewPager(viewPager);
+    public void initTopTabs(ViewPager viewPager) {
+        topBar.initTopTabs(viewPager);
+    }
+
+    public void clearTopTabs() {
+        topBar.clearTopTabs();
     }
 }

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

 import android.content.Context;
 import android.graphics.Typeface;
 import android.support.annotation.Nullable;
+import android.support.annotation.VisibleForTesting;
 import android.support.design.widget.AppBarLayout;
 import android.support.v4.view.ViewPager;
 import android.support.v7.widget.Toolbar;
         topTabs.applyTopTabsFontSize(fontSize);
     }
 
+    public void setTopTabsVisible(boolean visible) {
+        topTabs.setVisibility(this, visible);
+    }
+
     public void setButtons(ArrayList<Button> leftButtons, ArrayList<Button> rightButtons) {
         setLeftButtons(leftButtons);
         setRightButtons(rightButtons);
         return titleBar;
     }
 
-    public void setupTopTabsWithViewPager(ViewPager viewPager) {
-        initTopTabs();
-        topTabs.setupWithViewPager(viewPager);
-    }
-
-    private void initTopTabs() {
+    public void initTopTabs(ViewPager viewPager) {
         topTabs = new TopTabs(getContext());
+        topTabs.init(viewPager);
         addView(topTabs);
     }
 
         titleBar.setTitle(null);
         titleBar.setNavigationIcon(null);
         titleBar.getMenu().clear();
-        removeView(topTabs);
+    }
+
+    @VisibleForTesting()
+    public TopTabs getTopTabs() {
+        return topTabs;
+    }
+
+    public void clearTopTabs() {
+        topTabs.clear(this);
     }
 }

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

 import android.content.Context;
 import android.graphics.Typeface;
 import android.support.design.widget.TabLayout;
+import android.support.v4.view.ViewPager;
+import android.view.ViewManager;
 
 import com.reactnativenavigation.parse.Color;
 import com.reactnativenavigation.parse.Number;
     public void applyTopTabsFontSize(Number fontSize) {
         styleHelper.applyTopTabsFontSize(fontSize);
     }
+
+    public void setVisibility(TopBar topBar, boolean visible) {
+        if (visible && getTabCount() > 0) {
+            if (getParent() == null) {
+                topBar.addView(this, 1);
+            }
+            setVisibility(VISIBLE);
+        } else {
+            topBar.removeView(this);
+        }
+    }
+
+    public void clear(ViewManager parent) {
+        setupWithViewPager(null);
+        parent.removeView(this);
+    }
+
+    public void init(ViewPager viewPager) {
+        setupWithViewPager(viewPager);
+    }
 }

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

     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_HIDDEN = 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";
     private static final int BOTTOM_TABS_CURRENT_TAB_INDEX = 1;
         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.visible.get()).isEqualTo(BOTTOM_TABS_HIDDEN.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).isEqualTo(BOTTOM_TABS_CURRENT_TAB_INDEX);
     }
         return new JSONObject()
                 .put("currentTabId", BOTTOM_TABS_CURRENT_TAB_ID)
                 .put("currentTabIndex", BOTTOM_TABS_CURRENT_TAB_INDEX)
-                .put("visible", BOTTOM_TABS_HIDDEN.get())
+                .put("visible", BOTTOM_TABS_VISIBLE.get())
                 .put("animateHide", BOTTOM_TABS_ANIMATE_HIDE.get());
     }
 
         return new JSONObject()
                 .put("currentTabId", BOTTOM_TABS_CURRENT_TAB_ID)
                 .put("currentTabIndex", BOTTOM_TABS_CURRENT_TAB_INDEX)
-                .put("visible", BOTTOM_TABS_HIDDEN)
+                .put("visible", BOTTOM_TABS_VISIBLE)
                 .put("animateHide", BOTTOM_TABS_ANIMATE_HIDE)
                 .put("tabBadge", BOTTOM_TABS_BADGE);
     }
         assertThat(uut.topTabsOptions.fontSize.hasValue()).isFalse();
     }
 
-
     @Test
     public void clear_topTabOptions() throws Exception {
         Options uut = new Options();

lib/android/app/src/test/java/com/reactnativenavigation/utils/ViewHelper.java

+package com.reactnativenavigation.utils;
+
+import android.view.View;
+
+public class ViewHelper {
+    public static boolean isVisible(View view) {
+        return view != null && view.getParent() != null && view.getVisibility() == View.VISIBLE;
+    }
+}

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

     }
 
     @Test
-    public void appliesTopBarHidden() throws Exception {
+    public void appliesTopBarVisible() throws Exception {
         assertThat(uut.initialOptions).isSameAs(initialNavigationOptions);
         initialNavigationOptions.topBarOptions.title = new Text("the title");
         uut.ensureViewIsCreated();

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.utils.ViewHelper;
 import com.reactnativenavigation.views.ReactComponent;
 
 import org.assertj.core.api.iterable.Extractor;
         });
     }
 
+    @Test
+    public void pop_callWillAppearWillDisappear() throws Exception {
+        child1 = spy(child1);
+        child2 = spy(child2);
+        uut.push(child1, new MockPromise());
+        uut.push(child2, new MockPromise());
+        uut.pop(new MockPromise());
+        verify(child1, times(1)).onViewWillAppear();
+        verify(child2, times(1)).onViewWillDisappear();
+    }
+
     @Test
     public void popSpecific_CallsDestroyOnPoppedChild() throws Exception {
         child1 = spy(child1);
         assertThat(optionsCaptor.getValue().topBarOptions.title.hasValue()).isFalse();
     }
 
+    @Test
+    public void applyOptions_topTabsAreNotVisibleIfNoTabsAreDefined() throws Exception {
+        uut.ensureViewIsCreated();
+        uut.push(child1, new MockPromise());
+        child1.ensureViewIsCreated();
+        child1.onViewAppeared();
+        assertThat(ViewHelper.isVisible(uut.getTopBar().getTopTabs())).isFalse();
+    }
+
     private void assertContainsOnlyId(String... ids) {
         assertThat(uut.size()).isEqualTo(ids.length);
         assertThat(uut.getChildControllers()).extracting((Extractor<ViewController, String>) ViewController::getId).containsOnly(ids);

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

 import com.reactnativenavigation.mocks.TestReactView;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.Text;
+import com.reactnativenavigation.utils.ViewHelper;
 import com.reactnativenavigation.viewcontrollers.toptabs.TopTabsAdapter;
 import com.reactnativenavigation.viewcontrollers.toptabs.TopTabsController;
 import com.reactnativenavigation.views.ReactComponent;
         assertThat(optionsCaptor.getValue().topTabOptions.title.hasValue()).isFalse();
     }
 
+    @Test
+    public void applyOptions_tabsAreRemovedBeforeViewDisappears() throws Exception {
+        parentController.getView().removeAllViews();
+
+        StackController stackController = spy(new StackController(activity, "stack", new Options()));
+        ComponentViewController first = new ComponentViewController(
+                activity,
+                "firstScreen",
+                "comp1",
+                new TestComponentViewCreator(),
+                new Options()
+        );
+        stackController.push(first, new MockPromise());
+        stackController.push(uut, new MockPromise());
+
+        first.ensureViewIsCreated();
+        uut.ensureViewIsCreated();
+        uut.onViewAppeared();
+
+        assertThat(ViewHelper.isVisible(stackController.getTopBar().getTopTabs())).isTrue();
+        stackController.pop(new MockPromise());
+        assertThat(ViewHelper.isVisible(stackController.getTopBar().getTopTabs())).isFalse();
+    }
+
     private IReactView tab(TopTabsViewPager topTabs, final int index) {
         return (IReactView) ((ViewGroup) topTabs.getChildAt(index)).getChildAt(0);
     }