Add ability to push pop screens without animation

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

 import com.reactnativenavigation.params.ScreenParams;
 import com.reactnativenavigation.params.TitleBarButtonParams;
 import com.reactnativenavigation.params.TitleBarLeftButtonParams;
-import com.reactnativenavigation.screens.ScreenAnimator;
 import com.reactnativenavigation.screens.ScreenStack;
 import com.reactnativenavigation.views.BottomTabs;
 
     private BottomTabs bottomTabs;
     private ScreenStack[] screenStacks;
     private int currentStackIndex = 0;
-    private ScreenAnimator screenAnimator;
 
     public BottomTabsLayout(AppCompatActivity activity, ActivityParams params) {
         super(activity);
 
     private void createLayout() {
         createBottomTabs();
-        createScreenAnimator();
         addBottomTabsToScreen();
         addScreenStacks();
         showInitialScreenStack();
     }
 
     private void createAndAddScreenStack(int position) {
-        ScreenStack newStack = new ScreenStack(activity, params.tabParams.get(position), this, screenAnimator);
+        ScreenStack newStack = new ScreenStack(activity, params.tabParams.get(position), this);
         screenStacks[position] = newStack;
         newStack.setVisibility(INVISIBLE);
         addScreenStack(newStack);
         bottomTabs.addTabs(params.tabParams, this);
     }
 
-    private void createScreenAnimator() {
-        screenAnimator = new ScreenAnimator(bottomTabs);
-    }
-
     private void addBottomTabsToScreen() {
         LayoutParams lp = new LayoutParams(MATCH_PARENT, WRAP_CONTENT);
         lp.addRule(ALIGN_PARENT_BOTTOM);
     @Override
     public boolean onBackPressed() {
         if (getCurrentScreenStack().canPop()) {
-            getCurrentScreenStack().pop(screenAnimator);
+            getCurrentScreenStack().pop(true);
             setBottomTabsStyleFromCurrentScreen();
             return true;
         } else {
 
     @Override
     public void push(ScreenParams screenParams) {
-        getCurrentScreenStack().push(screenAnimator, screenParams);
+        getCurrentScreenStack().push(screenParams);
         bottomTabs.setStyleFromScreen(screenParams.styleParams);
     }
 
     @Override
     public void pop(ScreenParams screenParams) {
-        getCurrentScreenStack().pop(screenAnimator);
+        getCurrentScreenStack().pop(screenParams.animateScreenTransitions);
         setBottomTabsStyleFromCurrentScreen();
     }
 
     @Override
     public void popToRoot(ScreenParams params) {
-        getCurrentScreenStack().popToRoot(screenAnimator);
+        getCurrentScreenStack().popToRoot(params.animateScreenTransitions);
         setBottomTabsStyleFromCurrentScreen();
     }
 
         currentScreenStack.destroy();
         removeView(currentScreenStack);
 
-        ScreenStack newStack = new ScreenStack(activity, params, this, screenAnimator);
+        ScreenStack newStack = new ScreenStack(activity, params, this);
         screenStacks[currentStackIndex] = newStack;
         addView(newStack, 0, new RelativeLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT));
 
     @Override
     public boolean onTitleBarBackPress() {
         if (getCurrentScreenStack().canPop()) {
-            getCurrentScreenStack().pop(screenAnimator);
+            getCurrentScreenStack().pop(true);
             setBottomTabsStyleFromCurrentScreen();
             return true;
         }

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

         super(activity);
         this.activity = activity;
         this.screenParams = screenParams;
-        createScreenAnimator();
         createStack();
     }
 
-    private void createScreenAnimator() {
-        screenAnimator = new ScreenAnimator();
-    }
-
     private void createStack() {
         if (stack != null) {
             stack.destroy();
             removeView(stack);
         }
-        stack = new ScreenStack(activity, screenParams, this, screenAnimator);
+        stack = new ScreenStack(activity, screenParams, this);
         addView(stack, new LayoutParams(MATCH_PARENT, MATCH_PARENT));
     }
 
     @Override
     public boolean onBackPressed() {
         if (stack.canPop()) {
-            stack.pop(screenAnimator);
+            stack.pop(true);
             return true;
         } else {
             return false;
 
     @Override
     public void push(ScreenParams params) {
-        stack.push(screenAnimator, params);
+        stack.push(params);
     }
 
     @Override
     public void pop(ScreenParams params) {
-        stack.pop(screenAnimator);
+        stack.pop(params.animateScreenTransitions);
     }
 
     @Override
     public void popToRoot(ScreenParams params) {
-        stack.popToRoot(screenAnimator);
+        stack.popToRoot(params.animateScreenTransitions);
     }
 
     @Override

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

     public StyleParams styleParams;
     public List<TopTabParams> topTabParams;
     public String fragmentCreatorClassName;
+    public boolean animateScreenTransitions;
 
     //    public String tabLabel; TODO when tabs are supported move to TabParams
     //    public Drawable tabIcon;

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

         if (hasKey(params, "icon")) {
             result.tabIcon = ImageLoader.loadImage(params.getString("icon"));
         }
+        result.animateScreenTransitions = params.getBoolean("animated", true);
         return result;
     }
 

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

     protected TopBar topBar;
     private final TitleBarBackButtonListener titleBarBackButtonListener;
     private VisibilityAnimator topBarVisibilityAnimator;
+    private ScreenAnimator screenAnimator;
 
     public Screen(AppCompatActivity activity, ScreenParams screenParams, TitleBarBackButtonListener titleBarBackButtonListener) {
         super(activity);
         this.screenParams = screenParams;
         this.titleBarBackButtonListener = titleBarBackButtonListener;
 
+        screenAnimator = new ScreenAnimator(this);
         createViews();
         setStyle(screenParams.styleParams);
     }
             titleBarButtonParam.setColorFromScreenStyle(screenParams.styleParams.titleBarButtonColor);
         }
     }
+
+    public void show(boolean animated) {
+        screenAnimator.show(animated);
+    }
+
+    public void show(boolean animated, Runnable onAnimationEnd) {
+        screenAnimator.show(animated, onAnimationEnd);
+    }
+
+    public void hide(boolean animated, Runnable onAnimatedEnd) {
+        screenAnimator.hide(animated, onAnimatedEnd);
+    }
 }

android/app/src/main/java/com/reactnativenavigation/screens/ScreenAnimator.java

 import android.view.animation.DecelerateInterpolator;
 import android.view.animation.LinearInterpolator;
 
+import com.reactnativenavigation.NavigationApplication;
 import com.reactnativenavigation.utils.ViewUtils;
-import com.reactnativenavigation.views.BottomTabs;
 
-public class ScreenAnimator {
-    private static final String TAG = "ScreenAnimator";
-    private BottomTabs bottomTabs;
-
-    public ScreenAnimator() {
+import javax.annotation.Nullable;
 
-    }
+public class ScreenAnimator {
+    private final float translationY;
+    private Screen screen;
 
-    public ScreenAnimator(BottomTabs bottomTabs) {
-        this.bottomTabs = bottomTabs;
+    public ScreenAnimator(Screen screen) {
+        this.screen = screen;
+        translationY = 0.08f * ViewUtils.getScreenHeight();
     }
 
-    public void show(Screen screenToShow, Runnable onScreenRemoved) {
-        createPushAnimator(screenToShow, onScreenRemoved).start();
+    public void show(boolean animate, final Runnable onAnimationEnd) {
+        if (animate) {
+            createShowAnimator(onAnimationEnd).start();
+        } else {
+            screen.setVisibility(View.VISIBLE);
+            NavigationApplication.instance.runOnMainThread(onAnimationEnd, 200);
+        }
     }
 
-    public void show(Screen screenToShow) {
-        createPushAnimator(screenToShow).start();
+    public void show(boolean animate) {
+        if (animate) {
+            createShowAnimator(null).start();
+        } else {
+            screen.setVisibility(View.VISIBLE);
+        }
     }
 
-    public void hide(Screen screenToHide, Runnable onScreenRemoved) {
-        createPopAnimator(screenToHide, onScreenRemoved).start();
+    public void hide(boolean animate, Runnable onAnimationEnd) {
+        if (animate) {
+            createHideAnimator(onAnimationEnd).start();
+        } else {
+            screen.setVisibility(View.INVISIBLE);
+            onAnimationEnd.run();
+        }
     }
 
-    private Animator createPushAnimator(final Screen screen) {
-        ObjectAnimator alpha = ObjectAnimator.ofFloat(screen, View.ALPHA, 0.7f, 1);
-        alpha.setStartDelay(100);
-        alpha.setInterpolator(new LinearInterpolator());
-        alpha.setDuration(150);
-
-        final float delta = 0.08f * ViewUtils.getScreenHeight();
-        ObjectAnimator translationY = ObjectAnimator.ofFloat(screen, View.TRANSLATION_Y, delta, 0);
-        translationY.setInterpolator(new AccelerateInterpolator());
-        translationY.setDuration(250);
-
-        AnimatorSet set = new AnimatorSet();
-        set.playTogether(translationY, alpha);
-        set.addListener(new AnimatorListenerAdapter() {
-            @Override
-            public void onAnimationStart(Animator animation) {
-                screen.setVisibility(View.VISIBLE);
-            }
-        });
-        return set;
-    }
-
-    private Animator createPushAnimator(final Screen screenToShow, final Runnable onScreenRemoved) {
-        final float translationYValue = 0.08f * ViewUtils.getScreenHeight();
-
-        ObjectAnimator alpha = ObjectAnimator.ofFloat(screenToShow, View.ALPHA, 0, 1);
+    private Animator createShowAnimator(final @Nullable Runnable onAnimationEnd) {
+        ObjectAnimator alpha = ObjectAnimator.ofFloat(screen, View.ALPHA, 0, 1);
         alpha.setInterpolator(new DecelerateInterpolator());
         alpha.setDuration(200);
 
-        ObjectAnimator translationY = ObjectAnimator.ofFloat(screenToShow, View.TRANSLATION_Y, translationYValue, 0);
+        ObjectAnimator translationY = ObjectAnimator.ofFloat(screen, View.TRANSLATION_Y, this.translationY, 0);
         translationY.setInterpolator(new DecelerateInterpolator());
         translationY.setDuration(280);
 
         set.addListener(new AnimatorListenerAdapter() {
             @Override
             public void onAnimationStart(Animator animation) {
-                screenToShow.setVisibility(View.VISIBLE);
+                screen.setVisibility(View.VISIBLE);
             }
 
             @Override
             public void onAnimationEnd(Animator animation) {
-                onScreenRemoved.run();
+                if (onAnimationEnd != null) {
+                    onAnimationEnd.run();
+                }
             }
         });
         return set;
     }
 
-    private Animator createPopAnimator(final Screen screenToHide, final Runnable onScreenRemoved) {
-        final float translationYValue = 0.08f * ViewUtils.getScreenHeight();
-
-        ObjectAnimator alpha = ObjectAnimator.ofFloat(screenToHide, View.ALPHA, 0);
+    private Animator createHideAnimator(final Runnable onAnimationEnd) {
+        ObjectAnimator alpha = ObjectAnimator.ofFloat(screen, View.ALPHA, 0);
         alpha.setInterpolator(new LinearInterpolator());
         alpha.setStartDelay(100);
         alpha.setDuration(150);
 
-        ObjectAnimator translationY = ObjectAnimator.ofFloat(screenToHide, View.TRANSLATION_Y, translationYValue);
+        ObjectAnimator translationY = ObjectAnimator.ofFloat(screen, View.TRANSLATION_Y, this.translationY);
         translationY.setInterpolator(new AccelerateInterpolator());
         translationY.setDuration(250);
 
         set.addListener(new AnimatorListenerAdapter() {
             @Override
             public void onAnimationEnd(Animator animation) {
-                onScreenRemoved.run();
+                onAnimationEnd.run();
             }
         });
         return set;

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

 
     public ScreenStack(AppCompatActivity activity,
                        ScreenParams initialScreenParams,
-                       TitleBarBackButtonListener titleBarBackButtonListener,
-                       ScreenAnimator screenAnimator) {
+                       TitleBarBackButtonListener titleBarBackButtonListener) {
         super(activity);
         this.activity = activity;
         this.titleBarBackButtonListener = titleBarBackButtonListener;
-//        setLayoutTransition(new LayoutTransition());
-        pushInitialScreen(screenAnimator, initialScreenParams);
+        pushInitialScreen(initialScreenParams);
     }
 
-    private void pushInitialScreen(ScreenAnimator screenAnimator, ScreenParams initialScreenParams) {
+    private void pushInitialScreen(ScreenParams initialScreenParams) {
         Screen initialScreen = ScreenFactory.create(activity, initialScreenParams, titleBarBackButtonListener);
         addScreen(initialScreen);
-        screenAnimator.show(initialScreen);
+        initialScreen.show(initialScreenParams.animateScreenTransitions);
     }
 
-    public void push(ScreenAnimator screenAnimator, ScreenParams params) {
+    public void push(final ScreenParams params) {
         Screen nextScreen = ScreenFactory.create(activity, params, titleBarBackButtonListener);
         final Screen previousScreen = stack.peek();
         addScreen(nextScreen);
-        screenAnimator.show(nextScreen, new Runnable() {
+        nextScreen.show(params.animateScreenTransitions, new Runnable() {
             @Override
             public void run() {
                 removePreviousWithoutUnmount(previousScreen);
         removeView(previous);
     }
 
-    public void pop(ScreenAnimator screenAnimator) {
+    public void pop(boolean animated) {
         if (!canPop()) {
             return;
         }
         Screen previous = stack.peek();
 
         readdPrevious(previous);
-        screenAnimator.hide(toRemove, new Runnable() {
+        toRemove.hide(animated, new Runnable() {
             @Override
             public void run() {
                 toRemove.ensureUnmountOnDetachedFromWindow();
         previous.preventMountAfterReattachedToWindow();
     }
 
-    public void popToRoot(ScreenAnimator screenAnimator) {
+    public void popToRoot(boolean animated) {
         while (canPop()) {
-            pop(screenAnimator);
+            pop(animated);
         }
     }