Revert "Fling collapsing react view screens (#1213)" (#1214)

This reverts commit a2a9324b1e.

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

                     @Override
                     public void onFling(CollapseAmount amount) {
                         if (screenParams.styleParams.drawScreenBelowTopBar) {
-                            ((CollapsingView) contentView).fling(amount);
+                            ((CollapsingView) contentView).collapse(amount);
                         }
-                        topBar.fling(amount);
+                        topBar.collapse(amount);
                     }
                 },
                 getCollapseBehaviour()

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

 
                     @Override
                     public void onFling(CollapseAmount amount) {
-                        topBar.fling(amount);
-                        ((CollapsingView) viewPager).fling(amount);
+                        topBar.collapse(amount);
+                        ((CollapsingView) viewPager).collapse(amount);
                     }
                 },
                 getCollapseBehaviour()

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

         viewCollapser.collapse(amount);
     }
 
-    @Override
-    public void fling(CollapseAmount amount) {
-        viewCollapser.fling(amount);
-    }
-
     public void destroy() {
         if (scrollViewDetector != null) {
             scrollViewDetector.destroy();

android/app/src/main/java/com/reactnativenavigation/views/collapsingToolbar/CollapseAmount.java

         return amount != null;
     }
 
-    boolean collapseToTop() {
+    public boolean collapseToTop() {
         return direction == CollapseCalculator.Direction.Up;
     }
 
-    boolean collapseToBottom() {
+    public boolean collapseToBottom() {
         return direction == CollapseCalculator.Direction.Down;
     }
 

android/app/src/main/java/com/reactnativenavigation/views/collapsingToolbar/CollapseCalculator.java

 
 import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
-import android.util.Log;
 import android.view.GestureDetector;
 import android.view.MotionEvent;
 import android.view.ViewConfiguration;
 import com.reactnativenavigation.views.collapsingToolbar.behaviours.TitleBarHideOnScrollBehaviour;
 
 public class CollapseCalculator {
-    private static final int FLING_DISTANCE_PIXELS_THRESHOLD = 100;
-    private static final int FLING_VELOCITY = 7000;
-
     public enum Direction {
         Up, Down, None
     }
     private int scrollY = 0;
     private float totalCollapse = 0;
     private float totalCollapseDeltaSinceTouchDown = 0;
-    private final ViewConfiguration viewConfiguration;
+    private final int scaledTouchSlop;
 
     public CollapseCalculator(final CollapsingView collapsingView, CollapseBehaviour collapseBehaviour) {
         this.view = collapsingView;
         this.collapseBehaviour = collapseBehaviour;
-        viewConfiguration = ViewConfiguration.get(NavigationApplication.instance);
+        scaledTouchSlop = ViewConfiguration.get(NavigationApplication.instance).getScaledTouchSlop();
         setFlingDetector();
     }
 
             flingDetector =
                     new GestureDetector(NavigationApplication.instance, new GestureDetector.SimpleOnGestureListener() {
                         @Override
-                        public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, final float velocityY) {
+                        public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
                             final Direction direction = getScrollDirection(e1, e2);
-                            final float diff = Math.abs(e2.getRawY() - e1.getRawY());
-                            if (Math.abs(velocityY) < viewConfiguration.getScaledMinimumFlingVelocity() ||
-                                diff < FLING_DISTANCE_PIXELS_THRESHOLD) {
-                                Log.w("FLING", "Consuming fling v: [" + velocityY + "] dy: [" + diff + "]");
-                                return false;
-                            }
-
                             if (canCollapse(direction) && totalCollapse != 0) {
                                 flingListener.onFling(new CollapseAmount(direction));
-                                if (direction == Direction.Up) {
-                                    scrollView.postDelayed(new Runnable() {
-                                        @Override
-                                        public void run() {
-                                            int max = (int) Math.max(Math.abs(velocityY), FLING_VELOCITY);
-                                            scrollView.fling(max);
-                                        }
-                                    }, ViewCollapser.FLING_DURATION);
-                                }
-
                                 return true;
                             }
                             return false;
     @NonNull
     CollapseAmount calculate(MotionEvent event) {
         updateInitialTouchY(event);
-        final boolean isFling = flingDetector.onTouchEvent(event);
-        CollapseAmount touchUpCollapse = shouldCollapseOnTouchUp(event, isFling);
+        CollapseAmount touchUpCollapse = shouldCollapseOnTouchUp(event);
         if (touchUpCollapse != CollapseAmount.None) {
             previousTouchEvent = MotionEvent.obtain(event);
             return touchUpCollapse;
         }
     }
 
-    private CollapseAmount shouldCollapseOnTouchUp(MotionEvent event, boolean isFling) {
-        if (isTouchUp(event) && collapseBehaviour.shouldCollapseOnTouchUp() && !isFling) {
+    private CollapseAmount shouldCollapseOnTouchUp(MotionEvent event) {
+        if ((collapseBehaviour.shouldCollapseOnTouchUp())
+            && !flingDetector.onTouchEvent(event) && isTouchUp(event)) {
             final float visibilityPercentage = view.getCurrentCollapseValue() / view.getFinalCollapseValue();
             Direction direction = visibilityPercentage >= 0.5f ? Direction.Up : Direction.Down;
             if (canCollapse(direction) && totalCollapse != 0) {
         totalCollapseDeltaSinceTouchDown += Math.abs(y - previousCollapseY);
         previousCollapseY = y;
         previousTouchEvent = MotionEvent.obtain(event);
-        return totalCollapseDeltaSinceTouchDown < viewConfiguration.getScaledTouchSlop() ? CollapseAmount.None : new CollapseAmount(collapse);
+        return totalCollapseDeltaSinceTouchDown < scaledTouchSlop ? CollapseAmount.None : new CollapseAmount(collapse);
     }
 
     private float calculateCollapse(float y) {

android/app/src/main/java/com/reactnativenavigation/views/collapsingToolbar/CollapsingTopBar.java

         }
     }
 
-    @Override
-    public void fling(CollapseAmount amount) {
-        viewCollapser.fling(amount, (CollapsingTitleBar) titleBar, header);
-    }
-
     public void onScrollViewAdded(ScrollView scrollView) {
         scrollListener.onScrollViewAdded(scrollView);
     }

android/app/src/main/java/com/reactnativenavigation/views/collapsingToolbar/CollapsingTopBarReactHeader.java

     }
 
     private void onTouchDown(MotionEvent ev) {
-        listener.onTouch(ev);
         if (touchDown == -1) {
             touchDown = (int) ev.getRawY();
         }

android/app/src/main/java/com/reactnativenavigation/views/collapsingToolbar/CollapsingView.java

     View asView();
 
     void collapse(CollapseAmount amount);
-
-    void fling(CollapseAmount amount);
 }

android/app/src/main/java/com/reactnativenavigation/views/collapsingToolbar/CollapsingViewPager.java

     public void collapse(CollapseAmount amount) {
         viewCollapser.collapse(amount);
     }
-
-    @Override
-    public void fling(CollapseAmount amount) {
-        viewCollapser.fling(amount);
-    }
 }

android/app/src/main/java/com/reactnativenavigation/views/collapsingToolbar/ViewCollapser.java

 
 import android.animation.Animator;
 import android.animation.AnimatorListenerAdapter;
-import android.animation.ObjectAnimator;
-import android.animation.ValueAnimator;
-import android.support.annotation.NonNull;
-import android.view.View;
 import android.view.ViewPropertyAnimator;
-import android.view.animation.DecelerateInterpolator;
 
 public class ViewCollapser {
     private static final int DURATION = 160;
-    public static final int FLING_DURATION = 40;
     private CollapsingView view;
     private ViewPropertyAnimator animator;
-    private final ValueAnimator.AnimatorUpdateListener LISTENER =
-            new ValueAnimator.AnimatorUpdateListener() {
-                @Override
-                public void onAnimationUpdate(ValueAnimator animation) {
-                }
-            };
 
     public ViewCollapser(CollapsingView view) {
         this.view = view;
                 });
         animator.start();
     }
-
-    void fling(final CollapseAmount amount, final CollapsingTitleBar titleBar, final CollapsingTopBarReactHeader header) {
-        fling(amount, new ValueAnimator.AnimatorUpdateListener() {
-            @Override
-            public void onAnimationUpdate(ValueAnimator animation) {
-                titleBar.collapse(new CollapseAmount((Float) animation.getAnimatedValue()));
-                header.collapse((Float) animation.getAnimatedValue());
-            }
-        });
-    }
-
-    public void fling(CollapseAmount amount) {
-        fling(amount, LISTENER);
-    }
-
-    private void fling(final CollapseAmount amount, @NonNull final ValueAnimator.AnimatorUpdateListener updateListener) {
-        final float translation = amount.collapseToTop() ? view.getFinalCollapseValue() : 0;
-        ObjectAnimator animator = ObjectAnimator.ofFloat(view.asView(), View.TRANSLATION_Y, translation);
-        animator.setDuration(FLING_DURATION);
-        animator.setInterpolator(new DecelerateInterpolator());
-        animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
-            @Override
-            public void onAnimationUpdate(ValueAnimator animation) {
-                updateListener.onAnimationUpdate(animation);
-            }
-        });
-        animator.start();
-    }
 }

android/app/src/main/java/com/reactnativenavigation/views/collapsingToolbar/behaviours/CollapseTopBarBehaviour.java

 public class CollapseTopBarBehaviour implements CollapseBehaviour {
     @Override
     public boolean shouldCollapseOnFling() {
-        return true;
+        return false;
     }
 
     @Override