Fling collapsing react view screens (#1213)

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

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

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

 
                     @Override
                     public void onFling(CollapseAmount amount) {
-                        topBar.collapse(amount);
-                        ((CollapsingView) viewPager).collapse(amount);
+                        topBar.fling(amount);
+                        ((CollapsingView) viewPager).fling(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;
     }
 
-    public boolean collapseToTop() {
+    boolean collapseToTop() {
         return direction == CollapseCalculator.Direction.Up;
     }
 
-    public boolean collapseToBottom() {
+    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 int scaledTouchSlop;
+    private final ViewConfiguration viewConfiguration;
 
     public CollapseCalculator(final CollapsingView collapsingView, CollapseBehaviour collapseBehaviour) {
         this.view = collapsingView;
         this.collapseBehaviour = collapseBehaviour;
-        scaledTouchSlop = ViewConfiguration.get(NavigationApplication.instance).getScaledTouchSlop();
+        viewConfiguration = ViewConfiguration.get(NavigationApplication.instance);
         setFlingDetector();
     }
 
             flingDetector =
                     new GestureDetector(NavigationApplication.instance, new GestureDetector.SimpleOnGestureListener() {
                         @Override
-                        public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
+                        public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, final 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);
-        CollapseAmount touchUpCollapse = shouldCollapseOnTouchUp(event);
+        final boolean isFling = flingDetector.onTouchEvent(event);
+        CollapseAmount touchUpCollapse = shouldCollapseOnTouchUp(event, isFling);
         if (touchUpCollapse != CollapseAmount.None) {
             previousTouchEvent = MotionEvent.obtain(event);
             return touchUpCollapse;
         }
     }
 
-    private CollapseAmount shouldCollapseOnTouchUp(MotionEvent event) {
-        if ((collapseBehaviour.shouldCollapseOnTouchUp())
-            && !flingDetector.onTouchEvent(event) && isTouchUp(event)) {
+    private CollapseAmount shouldCollapseOnTouchUp(MotionEvent event, boolean isFling) {
+        if (isTouchUp(event) && collapseBehaviour.shouldCollapseOnTouchUp() && !isFling) {
             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 < scaledTouchSlop ? CollapseAmount.None : new CollapseAmount(collapse);
+        return totalCollapseDeltaSinceTouchDown < viewConfiguration.getScaledTouchSlop() ? 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 false;
+        return true;
     }
 
     @Override