Topbar anim (#2904)

* WIP

* Apply default options when screen options are null

* modal animations

* fix tests

* refactor

* refactor

* refactor

* refactor

* test fix

* topBar anim

* child disappear bug

* Update app.js

* Update WelcomeScreen.js

* fix tests

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

 import android.animation.Animator;
 import android.animation.AnimatorListenerAdapter;
 import android.animation.AnimatorSet;
-import android.animation.ObjectAnimator;
 import android.content.Context;
-import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
 import android.view.View;
-import android.view.animation.AccelerateInterpolator;
-import android.view.animation.DecelerateInterpolator;
-
-import com.reactnativenavigation.parse.AnimationsOptions;
-import com.reactnativenavigation.utils.UiUtils;
 
 @SuppressWarnings("ResourceType")
 public class NavigationAnimator extends BaseAnimator {
     public void animatePush(final View view, @Nullable final AnimationListener animationListener) {
         view.setVisibility(View.INVISIBLE);
         AnimatorSet set;
-        if (options.push.hasValue()) {
-            set = options.push.getAnimation(view);
+        if (options.push.content.hasValue()) {
+            set = options.push.content.getAnimation(view);
         } else {
             set = getDefaultPushAnimation(view);
         }
 
     public void animatePop(View view, @Nullable final AnimationListener animationListener) {
         AnimatorSet set;
-        if (options.pop.hasValue()) {
-            set = options.pop.getAnimation(view);
+        if (options.pop.content.hasValue()) {
+            set = options.pop.content.getAnimation(view);
         } else {
             set = getDefaultPopAnimation(view);
         }

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

 
 import android.animation.Animator;
 import android.animation.AnimatorListenerAdapter;
+import android.animation.AnimatorSet;
 import android.animation.ObjectAnimator;
 import android.animation.TimeInterpolator;
 import android.view.View;
-import android.view.ViewGroup;
 import android.view.animation.AccelerateInterpolator;
 import android.view.animation.DecelerateInterpolator;
 
+import com.reactnativenavigation.parse.AnimationOptions;
 import com.reactnativenavigation.views.TopBar;
 
 public class TopBarAnimator {
 
+    private static final int DEFAULT_COLLAPSE_DURATION = 100;
     private static final int DURATION_TOPBAR = 300;
     private final DecelerateInterpolator decelerateInterpolator = new DecelerateInterpolator();
     private final AccelerateInterpolator accelerateInterpolator = new AccelerateInterpolator();
 
     private TopBar topBar;
-    private View contentView;
-    private ObjectAnimator hideAnimator;
-    private ObjectAnimator showAnimator;
+    private AnimatorSet hideAnimator;
+    private AnimatorSet showAnimator;
 
     public TopBarAnimator(TopBar topBar) {
         this.topBar = topBar;
     }
 
-    public void show() {
-        show(-1 * topBar.getMeasuredHeight(), decelerateInterpolator, DURATION_TOPBAR);
+    public void show(AnimationOptions options) {
+        if (options.hasValue()) {
+            showAnimator = options.getAnimation(topBar);
+        } else {
+            showAnimator = getDefaultShowAnimator(-1 * topBar.getMeasuredHeight(), decelerateInterpolator, DURATION_TOPBAR);
+        }
+        show();
     }
 
-    public void show(float startTranslation, TimeInterpolator interpolator, int duration) {
-        showAnimator = ObjectAnimator.ofFloat(topBar, View.TRANSLATION_Y, startTranslation, 0);
-        showAnimator.setInterpolator(interpolator);
-        showAnimator.setDuration(duration);
+    public void show(float startTranslation) {
+        showAnimator = getDefaultShowAnimator(startTranslation, null, DEFAULT_COLLAPSE_DURATION);
+        show();
+    }
 
+    private void show() {
         showAnimator.addListener(new AnimatorListenerAdapter() {
-
             @Override
             public void onAnimationStart(Animator animation) {
                 topBar.setVisibility(View.VISIBLE);
             }
-
-            @Override
-            public void onAnimationEnd(Animator animation) {
-                if (contentView != null) {
-                    ViewGroup.LayoutParams layoutParams = contentView.getLayoutParams();
-                    layoutParams.height = ViewGroup.LayoutParams.MATCH_PARENT;
-                    contentView.setLayoutParams(layoutParams);
-                }
-            }
         });
         showAnimator.start();
     }
 
-    public void hide() {
-        hide(0, accelerateInterpolator, DURATION_TOPBAR);
+    private AnimatorSet getDefaultShowAnimator(float startTranslation, TimeInterpolator interpolator, int duration) {
+        ObjectAnimator showAnimator = ObjectAnimator.ofFloat(topBar, View.TRANSLATION_Y, startTranslation, 0);
+        showAnimator.setInterpolator(interpolator);
+        showAnimator.setDuration(duration);
+        AnimatorSet set = new AnimatorSet();
+        set.play(showAnimator);
+        return set;
+    }
+
+    public void hide(AnimationOptions options, AnimationListener listener) {
+        if (options.hasValue()) {
+            hideAnimator = options.getAnimation(topBar);
+        } else {
+            hideAnimator = getDefaultHideAnimator(0, accelerateInterpolator, DURATION_TOPBAR);
+        }
+        hide(listener);
     }
 
-    void hide(float startTranslation, TimeInterpolator interpolator, int duration) {
-        hideAnimator = ObjectAnimator.ofFloat(topBar, View.TRANSLATION_Y, startTranslation, -1 * topBar.getMeasuredHeight());
-        hideAnimator.setInterpolator(interpolator);
-        hideAnimator.setDuration(duration);
+    void hide(float startTranslation) {
+        hideAnimator = getDefaultHideAnimator(startTranslation, null, DEFAULT_COLLAPSE_DURATION);
+        hide(null);
+    }
 
+    private void hide(AnimationListener listener) {
         hideAnimator.addListener(new AnimatorListenerAdapter() {
             @Override
             public void onAnimationEnd(Animator animation) {
-                if (contentView != null) {
-                    ViewGroup.LayoutParams layoutParams = contentView.getLayoutParams();
-                    layoutParams.height = ViewGroup.LayoutParams.MATCH_PARENT;
-                    contentView.setLayoutParams(layoutParams);
-                }
-
                 topBar.setVisibility(View.GONE);
+                if (listener != null) listener.onAnimationEnd();
             }
         });
         hideAnimator.start();
     }
 
+    private AnimatorSet getDefaultHideAnimator(float startTranslation, TimeInterpolator interpolator, int duration) {
+        ObjectAnimator hideAnimator = ObjectAnimator.ofFloat(topBar, View.TRANSLATION_Y, startTranslation, -1 * topBar.getMeasuredHeight());
+        hideAnimator.setInterpolator(interpolator);
+        hideAnimator.setDuration(duration);
+        AnimatorSet set = new AnimatorSet();
+        set.play(hideAnimator);
+        return set;
+    }
+
     public boolean isRunning() {
         return (hideAnimator != null && hideAnimator.isRunning()) || (showAnimator != null && showAnimator.isRunning());
     }

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

 
     @Override
     public void onShow() {
-        animator.show(topBar.getTranslationY(), null, 100);
+        animator.show(topBar.getTranslationY());
     }
 
     @Override
     public void onHide() {
-        animator.hide(topBar.getTranslationY(), null, 100);
+        animator.hide(topBar.getTranslationY());
     }
 }

lib/android/app/src/main/java/com/reactnativenavigation/interfaces/ChildDisappearListener.java

+package com.reactnativenavigation.interfaces;
+
+
+public interface ChildDisappearListener {
+    void childDisappear();
+}

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

         AnimationsOptions options = new AnimationsOptions();
         if (json == null) return options;
 
-        options.push = AnimationOptions.parse(json.optJSONObject("push"));
-        options.pop = AnimationOptions.parse(json.optJSONObject("pop"));
+        options.push = NestedAnimationsOptions.parse(json.optJSONObject("push"));
+        options.pop = NestedAnimationsOptions.parse(json.optJSONObject("pop"));
         options.startApp = AnimationOptions.parse(json.optJSONObject("startApp"));
         options.showModal = AnimationOptions.parse(json.optJSONObject("showModal"));
         options.dismissModal = AnimationOptions.parse(json.optJSONObject("dismissModal"));
         return options;
     }
 
-    public AnimationOptions push = new AnimationOptions();
-    public AnimationOptions pop = new AnimationOptions();
+    public NestedAnimationsOptions push = new NestedAnimationsOptions();
+    public NestedAnimationsOptions pop = new NestedAnimationsOptions();
     public AnimationOptions startApp = new AnimationOptions();
     public AnimationOptions showModal = new AnimationOptions();
     public AnimationOptions dismissModal = new AnimationOptions();
         startApp.mergeWith(other.startApp);
         showModal.mergeWith(other.showModal);
         dismissModal.mergeWith(other.dismissModal);
-
     }
 
     void mergeWithDefault(AnimationsOptions defaultOptions) {

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

+package com.reactnativenavigation.parse;
+
+
+import org.json.JSONObject;
+
+public class NestedAnimationsOptions {
+    public static NestedAnimationsOptions parse(JSONObject json) {
+        NestedAnimationsOptions options = new NestedAnimationsOptions();
+        if (json == null) return options;
+
+        options.content = AnimationOptions.parse(json.optJSONObject("content"));
+        options.bottomTabs = AnimationOptions.parse(json.optJSONObject("bottomTabs"));
+        options.topBar = AnimationOptions.parse(json.optJSONObject("topBar"));
+
+        return options;
+    }
+
+    public AnimationOptions content = new AnimationOptions();
+    public AnimationOptions bottomTabs = new AnimationOptions();
+    public AnimationOptions topBar = new AnimationOptions();
+
+    void mergeWith(NestedAnimationsOptions other) {
+        topBar.mergeWith(other.topBar);
+        content.mergeWith(other.content);
+        bottomTabs.mergeWith(other.bottomTabs);
+    }
+
+    void mergeWithDefault(NestedAnimationsOptions defaultOptions) {
+        content.mergeWithDefault(defaultOptions.content);
+        bottomTabs.mergeWithDefault(defaultOptions.bottomTabs);
+        topBar.mergeWithDefault(defaultOptions.topBar);
+    }
+}

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

 package com.reactnativenavigation.presentation;
 
 import android.app.Activity;
+import android.support.annotation.NonNull;
 
+import com.reactnativenavigation.interfaces.ChildDisappearListener;
+import com.reactnativenavigation.parse.AnimationsOptions;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.OrientationOptions;
 import com.reactnativenavigation.parse.TopBarOptions;
     public void applyChildOptions(Options options, Component child) {
         applyOrientation(options.orientationOptions);
         applyButtons(options.topBarOptions.leftButtons, options.topBarOptions.rightButtons);
-        applyTopBarOptions(options.topBarOptions, child);
+        applyTopBarOptions(options.topBarOptions, child, options.animationsOptions);
         applyTopTabsOptions(options.topTabsOptions);
         applyTopTabOptions(options.topTabOptions);
     }
         ((Activity) topBar.getContext()).setRequestedOrientation(options.getValue());
     }
 
-    private void applyTopBarOptions(TopBarOptions options, Component component) {
+    private void applyTopBarOptions(TopBarOptions options, Component component, AnimationsOptions animationOptions) {
         if (options.title.text.hasValue()) topBar.setTitle(options.title.text.get());
-        if (options.title.component.hasValue()) topBar.setComponent(options.title.component.get(), options.title.alignment);
+        if (options.title.component.hasValue())
+            topBar.setComponent(options.title.component.get(), options.title.alignment);
         topBar.setBackgroundColor(options.background.color);
         topBar.setTitleTextColor(options.title.color);
         topBar.setTitleFontSize(options.title.fontSize);
 
         topBar.setTitleTypeface(options.title.fontFamily);
         if (options.visible.isFalse()) {
-            topBar.hide(options.animate);
+            if (options.animate.isTrueOrUndefined()) {
+                topBar.hideAnimate(animationOptions.pop.topBar);
+            } else {
+                topBar.hide();
+            }
         }
         if (options.visible.isTrueOrUndefined()) {
-            topBar.show(options.animate);
+            if (options.animate.isTrueOrUndefined()) {
+                topBar.showAnimate(animationOptions.push.topBar);
+            } else {
+                topBar.show();
+            }
         }
         if (options.drawBehind.isTrue()) {
             component.drawBehindTopBar();
         }
     }
 
-    public void onChildWillDisappear(Options disappearing, Options appearing) {
+    public void onChildWillDisappear(Options disappearing, Options appearing, @NonNull ChildDisappearListener childDisappearListener) {
         if (disappearing.topBarOptions.visible.isTrueOrUndefined() && appearing.topBarOptions.visible.isFalse()) {
-            topBar.hide(disappearing.topBarOptions.animate);
+            if (disappearing.topBarOptions.animate.isTrueOrUndefined()) {
+                topBar.hideAnimate(disappearing.animationsOptions.pop.topBar, childDisappearListener::childDisappear);
+            } else {
+                topBar.hide();
+                childDisappearListener.childDisappear();
+            }
+        } else {
+            childDisappearListener.childDisappear();
         }
     }
 }

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

 
 import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
 
-public class StackController extends ParentController <StackLayout> {
+public class StackController extends ParentController<StackLayout> {
 
     private static final NoOpPromise NO_OP = new NoOpPromise();
     private final IdStack<ViewController> stack = new IdStack<>();
     public void animatePush(final ViewController child, final Promise promise) {
         final ViewController toRemove = stack.peek();
 
-		child.setParentController(this);
-		stack.push(child.getId(), child);
-		View enteringView = child.getView();
-		getView().addView(enteringView, MATCH_PARENT, MATCH_PARENT);
+        child.setParentController(this);
+        stack.push(child.getId(), child);
+        View enteringView = child.getView();
+        getView().addView(enteringView, MATCH_PARENT, MATCH_PARENT);
 
         if (toRemove != null) {
             animator.animatePush(enteringView, () -> {
         finishPopping(exitingController.getView(), exitingController, promise);
     }
 
-	void animatePop(final Promise promise) {
-		if (!canPop()) {
-			Navigator.rejectPromise(promise);
-			return;
-		}
+    void animatePop(final Promise promise) {
+        if (!canPop()) {
+            Navigator.rejectPromise(promise);
+            return;
+        }
 
-		final ViewController exitingController = stack.pop();
+        final ViewController exitingController = stack.pop();
         final ViewController enteringController = stack.peek();
         popInternal(exitingController, enteringController);
 
-        animator.animatePop(exitingController.getView(), () -> finishPopping(exitingController.getView(), exitingController, promise));
-	}
+        animator.animatePop(exitingController.getView(), () -> finishPopping(exitingController.getView(),
+                exitingController, promise));
+    }
 
     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()));
+        getView().onChildWillDisappear(disappearing.options, appearing.options, () ->
+                getView().addView(appearing.getView(), getView().indexOfChild(disappearing.getView()))
+        );
     }
 
     boolean canPop() {
         return stack.size() > 1;
     }
 
-	private void finishPopping(View exitingView, ViewController poppedTop, Promise promise) {
-		getView().removeView(exitingView);
-		poppedTop.destroy();
+    private void finishPopping(View exitingView, ViewController poppedTop, Promise promise) {
+        getView().removeView(exitingView);
+        poppedTop.destroy();
         promise.resolve(poppedTop.getId());
-	}
-
-	void popSpecific(final ViewController childController, Promise promise) {
-		if (stack.isTop(childController.getId())) {
-			animatePop(promise);
-		} else {
-			stack.remove(childController.getId());
-			childController.destroy();
+    }
+
+    void popSpecific(final ViewController childController, Promise promise) {
+        if (stack.isTop(childController.getId())) {
+            animatePop(promise);
+        } else {
+            stack.remove(childController.getId());
+            childController.destroy();
             promise.resolve(childController.getId());
-		}
-	}
-
-	void popTo(final ViewController viewController, Promise promise) {
-		if (!stack.containsId(viewController.getId())) {
-			Navigator.rejectPromise(promise);
-			return;
-		}
-
-		Iterator<String> iterator = stack.iterator();
-		String currentControlId = iterator.next();
-		while (!viewController.getId().equals(currentControlId)) {
-			String nextControlId = iterator.next();
-			boolean animate = nextControlId.equals(viewController.getId());
-			if (animate) {
-			    animatePop(promise);
+        }
+    }
+
+    void popTo(final ViewController viewController, Promise promise) {
+        if (!stack.containsId(viewController.getId())) {
+            Navigator.rejectPromise(promise);
+            return;
+        }
+
+        Iterator<String> iterator = stack.iterator();
+        String currentControlId = iterator.next();
+        while (!viewController.getId().equals(currentControlId)) {
+            String nextControlId = iterator.next();
+            boolean animate = nextControlId.equals(viewController.getId());
+            if (animate) {
+                animatePop(promise);
             } else {
-			    pop(NO_OP);
+                pop(NO_OP);
             }
-			currentControlId = nextControlId;
-		}
-	}
+            currentControlId = nextControlId;
+        }
+    }
 
-	void popToRoot(Promise promise) {
-		while (canPop()) {
-			boolean animate = stack.size() == 2; // First element is root
+    void popToRoot(Promise promise) {
+        while (canPop()) {
+            boolean animate = stack.size() == 2; // First element is root
             if (animate) {
                 animatePop(promise);
             } else {
                 pop(NO_OP);
             }
-		}
-	}
-
-	ViewController peek() {
-		return stack.peek();
-	}
-
-	public int size() {
-		return stack.size();
-	}
-
-	public boolean isEmpty() {
-		return stack.isEmpty();
-	}
-
-	@Override
-	public boolean handleBack() {
-		if (canPop()) {
-			animatePop(NO_OP);
-			return true;
-		}
+        }
+    }
+
+    ViewController peek() {
+        return stack.peek();
+    }
+
+    public int size() {
+        return stack.size();
+    }
+
+    public boolean isEmpty() {
+        return stack.isEmpty();
+    }
+
+    @Override
+    public boolean handleBack() {
+        if (canPop()) {
+            animatePop(NO_OP);
+            return true;
+        }
         return false;
-	}
+    }
 
     @Override
     public void sendOnNavigationButtonPressed(String buttonId) {
         return new StackLayout(getActivity(), topBarButtonCreator, titleBarReactViewCreator, this::sendOnNavigationButtonPressed);
     }
 
-	@NonNull
-	@Override
-	public Collection<ViewController> getChildControllers() {
-		return stack.values();
-	}
+    @NonNull
+    @Override
+    public Collection<ViewController> getChildControllers() {
+        return stack.values();
+    }
 
     @Override
     public void setupTopTabsWithViewPager(ViewPager viewPager) {
     }
 
     @RestrictTo(RestrictTo.Scope.TESTS)
-    StackLayout getStackLayout() {return getView();}
+    StackLayout getStackLayout() {
+        return getView();
+    }
 }

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

 import android.support.v4.view.ViewPager;
 import android.widget.RelativeLayout;
 
+import com.reactnativenavigation.interfaces.ChildDisappearListener;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.presentation.OptionsPresenter;
 import com.reactnativenavigation.utils.CompatUtils;
         optionsPresenter.applyChildOptions(options, child);
     }
 
-    public void onChildWillDisappear(Options disappearing, Options appearing) {
-        new OptionsPresenter(topBar).onChildWillDisappear(disappearing, appearing);
+    public void onChildWillDisappear(Options disappearing, Options appearing, ChildDisappearListener childDisappearListener) {
+        new OptionsPresenter(topBar).onChildWillDisappear(disappearing, appearing, childDisappearListener);
     }
 
     public void clearOptions() {

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

 import android.view.View;
 import android.widget.TextView;
 
+import com.reactnativenavigation.anim.AnimationListener;
 import com.reactnativenavigation.anim.TopBarAnimator;
 import com.reactnativenavigation.anim.TopBarCollapseBehavior;
 import com.reactnativenavigation.interfaces.ScrollEventListener;
+import com.reactnativenavigation.parse.AnimationOptions;
+import com.reactnativenavigation.parse.AnimationsOptions;
 import com.reactnativenavigation.parse.TitleOptions;
-import com.reactnativenavigation.parse.params.Bool;
 import com.reactnativenavigation.parse.params.Button;
 import com.reactnativenavigation.parse.params.Color;
 import com.reactnativenavigation.parse.params.Fraction;
         collapsingBehavior.disableCollapse();
     }
 
-    public void show(Bool animated) {
-        if (getVisibility() == View.VISIBLE) {
-            return;
-        }
-        if (animated.isTrueOrUndefined()) {
-            animator.show();
-        } else if (!animator.isRunning()) {
-            setVisibility(View.VISIBLE);
-        }
+    public void show() {
+        if (visible()) return;
+        setVisibility(View.VISIBLE);
     }
 
-    public void hide(Bool animated) {
-        if (getVisibility() == View.GONE) {
-            return;
-        }
-        if (animated.isTrueOrUndefined()) {
-            animator.hide();
-        } else if (!animator.isRunning()){
-            setVisibility(View.GONE);
-        }
+    private boolean visible() {
+        return getVisibility() == View.VISIBLE;
+    }
+
+    public void showAnimate(AnimationOptions options) {
+        if (visible()) return;
+        animator.show(options);
+    }
+
+    public void hide() {
+        setVisibility(View.GONE);
+    }
+
+    public void hideAnimate(AnimationOptions options) {
+        hideAnimate(options, null);
+    }
+
+    public void hideAnimate(AnimationOptions options, AnimationListener listener) {
+        animator.hide(options, listener);
     }
 
     @Override

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

                 uut.animatePop(new MockPromise() {
                     @Override
                     public void resolve(@Nullable Object value) {
-                        verify(stackLayout[0], times(1)).onChildWillDisappear(child2.options, child1.options);
+                        verify(stackLayout[0], times(1)).onChildWillDisappear(child2.options, child1.options, () -> {
+                        });
                     }
                 });
             }
         uut.animatePop(new MockPromise() {
             @Override
             public void resolve(@Nullable Object value) {
-                verify(uut.getTopBar(), times(1)).hide(child2.options.topBarOptions.animate);
+                verify(uut.getTopBar(), times(1)).hide();
             }
         });
     }

lib/android/app/src/test/java/com/reactnativenavigation/views/TopBarTest.java

 import com.reactnativenavigation.anim.TopBarAnimator;
 import com.reactnativenavigation.mocks.TitleBarReactViewCreatorMock;
 import com.reactnativenavigation.mocks.TopBarButtonCreatorMock;
-import com.reactnativenavigation.parse.params.Bool;
+import com.reactnativenavigation.parse.AnimationOptions;
 import com.reactnativenavigation.parse.params.Button;
-import com.reactnativenavigation.parse.params.NullBool;
 import com.reactnativenavigation.parse.params.Text;
 import com.reactnativenavigation.utils.TitleBarHelper;
 import com.reactnativenavigation.viewcontrollers.TopBarButtonController;
     }
 
     @Test
-    public void hide_animateHideUnlessSpecifiedOtherwise() throws Exception {
-        uut.hide(new NullBool());
-        verify(animator, times(1)).hide();
+    public void hide_animate() throws Exception {
+        AnimationOptions options = new AnimationOptions();
+        uut.hideAnimate(options);
+        verify(animator, times(1)).hide(options, null);
     }
 
     @Test
-    public void show_animateShowUnlessSpecifiedOtherwise() throws Exception {
-        uut.hide(new Bool(false));
-        uut.show(new NullBool());
-        verify(animator, times(1)).show();
+    public void show_animate() throws Exception {
+        AnimationOptions options = new AnimationOptions();
+        uut.hide();
+        uut.showAnimate(options);
+        verify(animator, times(1)).show(options);
     }
 
     @Test

playground/src/app.js

     Navigation.setDefaultOptions({
       _animations: {
         push: {
-          y: {
-            from: 1000,
-            to: 0,
-            duration: 500,
-            interpolation: 'decelerate',
-          },
-          x: {
-            from: 1000,
-            to: 0,
-            duration: 500,
-            interpolation: 'decelerate',
-            startDelay: 100
+          topBar: {
+            y: {
+              from: 1000,
+              to: 0,
+              duration: 500,
+              interpolation: 'accelerate',
+            },
+            alpha: {
+              from: 0,
+              to: 1,
+              duration: 500,
+              interpolation: 'accelerate'
+            }
           },
-          scaleY: {
-            from: 0,
-            to: 1,
-            duration: 1000,
-            interpolation: 'decelerate',
+          content: {
+            y: {
+              from: 1000,
+              to: 0,
+              duration: 500,
+              interpolation: 'accelerate',
+            },
+            alpha: {
+              from: 0,
+              to: 1,
+              duration: 500,
+              interpolation: 'accelerate'
+            }
           }
         },
         pop: {
-          rotationY: {
-            from: 0,
-            to: -360,
-            duration: 500,
-            interpolation: 'accelerate',
-          },
-          x: {
-            from: 0,
-            to: -1000,
-            duration: 500,
-            interpolation: 'accelerate',
-            startDelay: 100
+          topBar: {
+            y: {
+              from: 0,
+              to: 100,
+              duration: 500,
+              interpolation: 'decelerate',
+            },
+            alpha: {
+              from: 1,
+              to: 0,
+              duration: 500,
+              interpolation: 'decelerate'
+            }
           },
-          alpha: {
-            from: 1,
-            to: 0,
-            duration: 500
+          content: {
+            y: {
+              from: 0,
+              to: 1000,
+              duration: 500,
+              interpolation: 'decelerate',
+            },
+            alpha: {
+              from: 1,
+              to: 0,
+              duration: 500,
+              interpolation: 'decelerate'
+            }
           }
         }
       }