Cherrypick 53a93d6e4c (#1220)

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 = 200;
+
     public enum Direction {
         Up, Down, None
     }
     private float totalCollapse = 0;
     private float totalCollapseDeltaSinceTouchDown = 0;
     private final int scaledTouchSlop;
+    private final int minimumFlingVelocity;
 
     public CollapseCalculator(final CollapsingView collapsingView, CollapseBehaviour collapseBehaviour) {
         this.view = collapsingView;
         this.collapseBehaviour = collapseBehaviour;
-        scaledTouchSlop = ViewConfiguration.get(NavigationApplication.instance).getScaledTouchSlop();
+        ViewConfiguration vc = ViewConfiguration.get(NavigationApplication.instance);
+        scaledTouchSlop = vc.getScaledTouchSlop();
+        minimumFlingVelocity = vc.getScaledMinimumFlingVelocity();
         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);
-                            if (canCollapse(direction) && totalCollapse != 0) {
+                            final float diff = Math.abs(e2.getRawY() - e1.getRawY());
+
+                            if (Math.abs(velocityY) <  minimumFlingVelocity || diff < FLING_DISTANCE_PIXELS_THRESHOLD) {
+                                Log.w("FLING", "Consuming fling v: [" + velocityY + "] dy: [" + diff + "]");
+                                return true;
+                            }
+
+                            if (canCollapse && totalCollapse != 0) {
                                 flingListener.onFling(new CollapseAmount(direction));
+                                if (direction == Direction.Up) {
+                                    view.asView().postOnAnimation(new Runnable() {
+                                        @Override
+                                        public void run() {
+                                            Log.v("FLING", "v: [" + velocityY + "] dy: [" + diff + "]");
+                                            scrollView.fling((int) Math.abs(velocityY));
+                                        }
+                                    });
+                                }
                                 return true;
                             }
-                            return false;
+
+                            return true;
                         }
 
                         private Direction getScrollDirection(MotionEvent e1, MotionEvent e2) {
     @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) {

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

         }
     }
 
+    @Override
+    public void fling(CollapseAmount amount) {
+        if (titleBar instanceof CollapsingTitleBar) {
+            viewCollapser.fling(amount, (CollapsingTitleBar) titleBar, header);
+        } else {
+            viewCollapser.collapse(amount);
+        }
+    }
+
     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;
+    private static final int FLING_DURATION = 160;
     private CollapsingView view;
+
+    private final ValueAnimator.AnimatorUpdateListener LISTENER =
+            new ValueAnimator.AnimatorUpdateListener() {
+                @Override
+                public void onAnimationUpdate(ValueAnimator animation) {
+                }
+            };
     private ViewPropertyAnimator animator;
+    private ObjectAnimator flingAnimator;
 
     public ViewCollapser(CollapsingView view) {
         this.view = view;
     }
 
     public void collapse(float amount) {
-        if (animator != null) {
-            animator.cancel();
-        }
+        cancelAnimator();
         view.asView().setTranslationY(amount);
     }
 
                 });
         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) {
+        cancelAnimator();
+        final float translation = amount.collapseToTop() ? view.getFinalCollapseValue() : 0;
+        flingAnimator = ObjectAnimator.ofFloat(view.asView(), View.TRANSLATION_Y, translation);
+        flingAnimator.setDuration(FLING_DURATION);
+        flingAnimator.setInterpolator(new DecelerateInterpolator());
+        flingAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
+            @Override
+            public void onAnimationUpdate(ValueAnimator animation) {
+                updateListener.onAnimationUpdate(animation);
+            }
+        });
+        flingAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
+            @Override
+            public void onAnimationUpdate(ValueAnimator animation) {
+                updateListener.onAnimationUpdate(animation);
+            }
+        });
+        flingAnimator.addListener(new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationCancel(Animator animation) {
+                flingAnimator = null;
+            }
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                flingAnimator = null;
+            }
+        });
+        flingAnimator.start();
+
+    }
+
+    private void cancelAnimator() {
+        if (animator != null) {
+            animator.cancel();
+        }
+    }
 }

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