react-native-gesture-handler 1.10.3 → 2.1.2

package/android/lib/src/main/java/com/swmansion/gesturehandler/LongPressGestureHandler.java

@@ -1,81 +0,0 @@
-package com.swmansion.gesturehandler;
-
-import android.content.Context;
-import android.os.Handler;
-import android.view.MotionEvent;
-
-public class LongPressGestureHandler extends GestureHandler<LongPressGestureHandler> {
-
-  private static final long DEFAULT_MIN_DURATION_MS = 500; // 1 sec
-  private static float DEFAULT_MAX_DIST_DP = 10; // 20dp
-
-  private long mMinDurationMs = DEFAULT_MIN_DURATION_MS;
-  private float mMaxDistSq;
-  private float mStartX, mStartY;
-  private Handler mHandler;
-
-  public LongPressGestureHandler(Context context) {
-    setShouldCancelWhenOutside(true);
-    mMaxDistSq = DEFAULT_MAX_DIST_DP * context.getResources().getDisplayMetrics().density;
-  }
-
-  public void setMinDurationMs(long minDurationMs) {
-    mMinDurationMs = minDurationMs;
-  }
-
-  public LongPressGestureHandler setMaxDist(float maxDist) {
-    mMaxDistSq = maxDist * maxDist;
-    return this;
-  }
-
-  @Override
-  protected void onHandle(MotionEvent event) {
-    if (getState() == STATE_UNDETERMINED) {
-      begin();
-      mStartX = event.getRawX();
-      mStartY = event.getRawY();
-      mHandler = new Handler();
-      if (mMinDurationMs > 0) {
-        mHandler.postDelayed(new Runnable() {
-          @Override
-          public void run() {
-            activate();
-          }
-        }, mMinDurationMs);
-      } else if (mMinDurationMs == 0) {
-        activate();
-      }
-    }
-    if (event.getActionMasked() == MotionEvent.ACTION_UP) {
-      if (mHandler != null) {
-        mHandler.removeCallbacksAndMessages(null);
-        mHandler = null;
-      }
-      if (getState() == STATE_ACTIVE) {
-        end();
-      } else {
-        fail();
-      }
-    } else {
-      // calculate distance from start
-      float deltaX = event.getRawX() - mStartX;
-      float deltaY = event.getRawY() - mStartY;
-      float distSq = deltaX * deltaX + deltaY * deltaY;
-      if (distSq > mMaxDistSq) {
-        if (getState() == STATE_ACTIVE) {
-          cancel();
-        } else {
-          fail();
-        }
-      }
-    }
-  }
-
-  @Override
-  protected void onStateChange(int newState, int previousState) {
-    if (mHandler != null) {
-      mHandler.removeCallbacksAndMessages(null);
-      mHandler = null;
-    }
-  }
-}

package/android/lib/src/main/java/com/swmansion/gesturehandler/NativeViewGestureHandler.java

@@ -1,110 +0,0 @@
-package com.swmansion.gesturehandler;
-
-import android.os.SystemClock;
-import android.view.MotionEvent;
-import android.view.View;
-import android.view.ViewGroup;
-
-public class NativeViewGestureHandler extends GestureHandler<NativeViewGestureHandler> {
-
-  private boolean mShouldActivateOnStart;
-  private boolean mDisallowInterruption;
-
-  public NativeViewGestureHandler() {
-    setShouldCancelWhenOutside(true);
-  }
-
-  public NativeViewGestureHandler setShouldActivateOnStart(boolean shouldActivateOnStart) {
-    mShouldActivateOnStart = shouldActivateOnStart;
-    return this;
-  }
-
-  /**
-   * Set this to {@code true} when wrapping native components that are supposed to be an exclusive
-   * target for a touch stream. Like for example switch or slider component which when activated
-   * aren't supposed to be cancelled by scrollview or other container that may also handle touches.
-   */
-  public NativeViewGestureHandler setDisallowInterruption(boolean disallowInterruption) {
-    mDisallowInterruption = disallowInterruption;
-    return this;
-  }
-
-  @Override
-  public boolean shouldRequireToWaitForFailure(GestureHandler handler) {
-    return super.shouldRequireToWaitForFailure(handler);
-  }
-
-  @Override
-  public boolean shouldRecognizeSimultaneously(GestureHandler handler) {
-    if (handler instanceof NativeViewGestureHandler) {
-      // Special case when the peer handler is also an instance of NativeViewGestureHandler:
-      // For the `disallowInterruption` to work correctly we need to check the property when
-      // accessed as a peer, because simultaneous recognizers can be set on either side of the
-      // connection.
-      NativeViewGestureHandler nativeWrapper = (NativeViewGestureHandler) handler;
-      if (nativeWrapper.getState() == STATE_ACTIVE && nativeWrapper.mDisallowInterruption) {
-        // other handler is active and it disallows interruption, we don't want to get into its way
-        return false;
-      }
-    }
-
-    boolean canBeInterrupted = !mDisallowInterruption;
-    int state = getState();
-    int otherState = handler.getState();
-
-    if (state == STATE_ACTIVE && otherState == STATE_ACTIVE && canBeInterrupted) {
-      // if both handlers are active and the current handler can be interruped it we return `false`
-      // as it means the other handler has turned active and returning `true` would prevent it from
-      // interrupting the current handler
-      return false;
-    }
-    // otherwise we can only return `true` if already in an active state
-    return state == STATE_ACTIVE && canBeInterrupted;
-  }
-
-  @Override
-  public boolean shouldBeCancelledBy(GestureHandler handler) {
-    return !mDisallowInterruption;
-  }
-
-  @Override
-  protected void onHandle(MotionEvent event) {
-    View view = getView();
-    int state = getState();
-    if (event.getActionMasked() == MotionEvent.ACTION_UP) {
-      view.onTouchEvent(event);
-      if ((state == STATE_UNDETERMINED || state == STATE_BEGAN) && view.isPressed()) {
-        activate();
-      }
-      end();
-    } else if (state == STATE_UNDETERMINED || state == STATE_BEGAN) {
-      if (mShouldActivateOnStart) {
-        tryIntercept(view, event);
-        view.onTouchEvent(event);
-        activate();
-      } else if (tryIntercept(view, event)) {
-        view.onTouchEvent(event);
-        activate();
-      } else if (state != STATE_BEGAN) {
-        begin();
-      }
-    } else if (state == STATE_ACTIVE) {
-      view.onTouchEvent(event);
-    }
-  }
-
-  private static boolean tryIntercept(View view, MotionEvent event) {
-    if (view instanceof ViewGroup && ((ViewGroup) view).onInterceptTouchEvent(event)) {
-      return true;
-    }
-    return false;
-  }
-
-  @Override
-  protected void onCancel() {
-    long time = SystemClock.uptimeMillis();
-    MotionEvent event = MotionEvent.obtain(time, time, MotionEvent.ACTION_CANCEL, 0, 0, 0);
-    event.setAction(MotionEvent.ACTION_CANCEL);
-    getView().onTouchEvent(event);
-  }
-}

package/android/lib/src/main/java/com/swmansion/gesturehandler/OnTouchEventListener.java

@@ -1,8 +0,0 @@
-package com.swmansion.gesturehandler;
-
-import android.view.MotionEvent;
-
-public interface OnTouchEventListener<T extends GestureHandler> {
-  void onTouchEvent(T handler, MotionEvent event);
-  void onStateChange(T handler, int newState, int oldState);
-}

package/android/lib/src/main/java/com/swmansion/gesturehandler/PanGestureHandler.java

@@ -1,312 +0,0 @@
-package com.swmansion.gesturehandler;
-
-import android.content.Context;
-import android.view.MotionEvent;
-import android.view.VelocityTracker;
-import android.view.ViewConfiguration;
-
-public class PanGestureHandler extends GestureHandler<PanGestureHandler> {
-
-  private static float MIN_VALUE_IGNORE = Float.MAX_VALUE;
-  private static float MAX_VALUE_IGNORE = Float.MIN_VALUE;
-
-  private static int DEFAULT_MIN_POINTERS = 1;
-  private static int DEFAULT_MAX_POINTERS = 10;
-
-  private float mMinDistSq = MAX_VALUE_IGNORE;
-
-  private float mActiveOffsetXStart = MIN_VALUE_IGNORE;
-  private float mActiveOffsetXEnd = MAX_VALUE_IGNORE;
-
-  private float mFailOffsetXStart = MAX_VALUE_IGNORE;
-  private float mFailOffsetXEnd = MIN_VALUE_IGNORE;
-
-  private float mActiveOffsetYStart = MIN_VALUE_IGNORE;
-  private float mActiveOffsetYEnd = MAX_VALUE_IGNORE;
-
-  private float mFailOffsetYStart = MAX_VALUE_IGNORE;
-  private float mFailOffsetYEnd = MIN_VALUE_IGNORE;
-
-  private float mMinVelocityX = MIN_VALUE_IGNORE;
-  private float mMinVelocityY = MIN_VALUE_IGNORE;
-  private float mMinVelocitySq = MIN_VALUE_IGNORE;
-  private int mMinPointers = DEFAULT_MIN_POINTERS;
-  private int mMaxPointers = DEFAULT_MAX_POINTERS;
-
-  private float mStartX, mStartY;
-  private float mOffsetX, mOffsetY;
-  private float mLastX, mLastY;
-  private float mLastVelocityX, mLastVelocityY;
-  private VelocityTracker mVelocityTracker;
-
-  private boolean mAverageTouches;
-
-  /**
-   * On Android when there are multiple pointers on the screen pan gestures most often just consider
-   * the last placed pointer. The behaviour on iOS is quite different where the x and y component
-   * of the pan pointer is calculated as an average out of all the pointers placed on the screen.
-   *
-   * This behaviour can be customized on android by setting averageTouches property of the handler
-   * object. This could be useful in particular for the usecases when we attach other handlers that
-   * recognizes multi-finger gestures such as rotation. In that case when we only rely on the last
-   * placed finger it is easier for the gesture handler to trigger when we do a rotation gesture
-   * because each finger when treated separately will travel some distance, whereas the average
-   * position of all the fingers will remain still while doing a rotation gesture.
-   */
-  public PanGestureHandler(Context context) {
-    ViewConfiguration vc = ViewConfiguration.get(context);
-    int touchSlop = vc.getScaledTouchSlop();
-    mMinDistSq = touchSlop * touchSlop;
-  }
-
-  public PanGestureHandler setActiveOffsetXStart(float activeOffsetXStart) {
-    mActiveOffsetXStart = activeOffsetXStart;
-    return this;
-  }
-
-  public PanGestureHandler setActiveOffsetXEnd(float activeOffsetXEnd) {
-    mActiveOffsetXEnd = activeOffsetXEnd;
-    return this;
-  }
-
-  public PanGestureHandler setFailOffsetXStart(float failOffsetXStart) {
-    mFailOffsetXStart = failOffsetXStart;
-    return this;
-  }
-
-  public PanGestureHandler setFailOffsetXEnd(float failOffsetXEnd) {
-    mFailOffsetXEnd = failOffsetXEnd;
-    return this;
-  }
-
-  public PanGestureHandler setActiveOffsetYStart(float activeOffsetYStart) {
-    mActiveOffsetYStart = activeOffsetYStart;
-    return this;
-  }
-
-  public PanGestureHandler setActiveOffsetYEnd(float activeOffsetYEnd) {
-    mActiveOffsetYEnd = activeOffsetYEnd;
-    return this;
-  }
-
-  public PanGestureHandler setFailOffsetYStart(float failOffsetYStart) {
-    mFailOffsetYStart = failOffsetYStart;
-    return this;
-  }
-
-  public PanGestureHandler setFailOffsetYEnd(float failOffsetYEnd) {
-    mFailOffsetYEnd = failOffsetYEnd;
-    return this;
-  }
-
-  public PanGestureHandler setMinDist(float minDist) {
-    mMinDistSq = minDist * minDist;
-    return this;
-  }
-
-  public PanGestureHandler setMinPointers(int minPointers) {
-    mMinPointers = minPointers;
-    return this;
-  }
-
-  public PanGestureHandler setMaxPointers(int maxPointers) {
-    mMaxPointers = maxPointers;
-    return this;
-  }
-
-  public PanGestureHandler setAverageTouches(boolean averageTouches) {
-    mAverageTouches = averageTouches;
-    return this;
-  }
-
-  /**
-   * @param minVelocity in pixels per second
-   */
-  public PanGestureHandler setMinVelocity(float minVelocity) {
-    mMinVelocitySq = minVelocity * minVelocity;
-    return this;
-  }
-
-  public PanGestureHandler setMinVelocityX(float minVelocityX) {
-    mMinVelocityX = minVelocityX;
-    return this;
-  }
-
-  public PanGestureHandler setMinVelocityY(float minVelocityY) {
-    mMinVelocityY = minVelocityY;
-    return this;
-  }
-
-  private boolean shouldActivate() {
-    float dx = mLastX - mStartX + mOffsetX;
-    if (mActiveOffsetXStart != MIN_VALUE_IGNORE && dx < mActiveOffsetXStart) {
-      return true;
-    }
-
-    if (mActiveOffsetXEnd != MAX_VALUE_IGNORE && dx > mActiveOffsetXEnd) {
-      return true;
-    }
-
-    float dy = mLastY - mStartY + mOffsetY;
-    if (mActiveOffsetYStart != MIN_VALUE_IGNORE && dy < mActiveOffsetYStart) {
-      return true;
-    }
-
-    if (mActiveOffsetYEnd != MAX_VALUE_IGNORE && dy > mActiveOffsetYEnd) {
-      return true;
-    }
-
-    float distSq = dx * dx + dy * dy;
-    if (mMinDistSq != MIN_VALUE_IGNORE && distSq >= mMinDistSq) {
-      return true;
-    }
-
-    float vx = mLastVelocityX;
-    if (mMinVelocityX != MIN_VALUE_IGNORE &&
-            ((mMinVelocityX < 0 && vx <= mMinVelocityX) || (mMinVelocityX >= 0 && vx >= mMinVelocityX))) {
-      return true;
-    }
-
-    float vy = mLastVelocityY;
-    if (mMinVelocityY != MIN_VALUE_IGNORE &&
-            ((mMinVelocityY < 0 && vx <= mMinVelocityY) || (mMinVelocityY >= 0 && vx >= mMinVelocityY))) {
-      return true;
-    }
-
-    float velocitySq = vx * vx + vy * vy;
-    if (mMinVelocitySq != MIN_VALUE_IGNORE && velocitySq >= mMinVelocitySq) {
-      return true;
-    }
-
-    return false;
-  }
-
-  private boolean shouldFail() {
-    float dx = mLastX - mStartX + mOffsetX;
-
-    if (mFailOffsetXStart != MAX_VALUE_IGNORE && dx < mFailOffsetXStart) {
-      return true;
-    }
-
-    if (mFailOffsetXEnd != MIN_VALUE_IGNORE && dx > mFailOffsetXEnd) {
-      return true;
-    }
-
-
-    float dy = mLastY - mStartY + mOffsetY;
-    if (mFailOffsetYStart != MAX_VALUE_IGNORE && dy < mFailOffsetYStart) {
-      return true;
-    }
-
-    if (mFailOffsetYEnd != MIN_VALUE_IGNORE && dy > mFailOffsetYEnd) {
-      return true;
-    }
-
-    return false;
-  }
-
-  @Override
-  protected void onHandle(MotionEvent event) {
-    int state = getState();
-    int action = event.getActionMasked();
-
-    if (action == MotionEvent.ACTION_POINTER_UP || action == MotionEvent.ACTION_POINTER_DOWN) {
-      // update offset if new pointer gets added or removed
-      mOffsetX += mLastX - mStartX;
-      mOffsetY += mLastY - mStartY;
-
-      // reset starting point
-      mLastX = GestureUtils.getLastPointerX(event, mAverageTouches);
-      mLastY = GestureUtils.getLastPointerY(event, mAverageTouches);
-      mStartX = mLastX;
-      mStartY = mLastY;
-    } else {
-      mLastX = GestureUtils.getLastPointerX(event, mAverageTouches);
-      mLastY = GestureUtils.getLastPointerY(event, mAverageTouches);
-    }
-
-    if (state == STATE_UNDETERMINED && event.getPointerCount() >= mMinPointers) {
-      mStartX = mLastX;
-      mStartY = mLastY;
-      mOffsetX = 0;
-      mOffsetY = 0;
-      mVelocityTracker = VelocityTracker.obtain();
-      addVelocityMovement(mVelocityTracker, event);
-      begin();
-    } else if (mVelocityTracker != null) {
-      addVelocityMovement(mVelocityTracker, event);
-      mVelocityTracker.computeCurrentVelocity(1000);
-      mLastVelocityX = mVelocityTracker.getXVelocity();
-      mLastVelocityY = mVelocityTracker.getYVelocity();
-    }
-
-    if (action == MotionEvent.ACTION_UP) {
-      if (state == STATE_ACTIVE || state == STATE_BEGAN) {
-        end();
-      } else {
-        fail();
-      }
-    } else if (action == MotionEvent.ACTION_POINTER_DOWN && event.getPointerCount() > mMaxPointers) {
-      // When new finger is placed down (POINTER_DOWN) we check if MAX_POINTERS is not exceeded
-      if (state == STATE_ACTIVE) {
-        cancel();
-      } else {
-        fail();
-      }
-    } else if (action == MotionEvent.ACTION_POINTER_UP && state == STATE_ACTIVE
-            && event.getPointerCount() < mMinPointers) {
-      // When finger is lifted up (POINTER_UP) and the number of pointers falls below MIN_POINTERS
-      // threshold, we only want to take an action when the handler has already activated. Otherwise
-      // we can still expect more fingers to be placed on screen and fulfill MIN_POINTERS criteria.
-      fail();
-    } else if (state == STATE_BEGAN) {
-      if (shouldFail()) {
-        fail();
-      } else if (shouldActivate()) {
-        // reset starting point
-        mStartX = mLastX;
-        mStartY = mLastY;
-        activate();
-      }
-    }
-  }
-
-  @Override
-  protected void onReset() {
-    if (mVelocityTracker != null) {
-      mVelocityTracker.recycle();
-      mVelocityTracker = null;
-    }
-  }
-
-  public float getTranslationX() {
-    return mLastX - mStartX + mOffsetX;
-  }
-
-  public float getTranslationY() {
-    return mLastY - mStartY + mOffsetY;
-  }
-
-  public float getVelocityX() {
-    return mLastVelocityX;
-  }
-
-  public float getVelocityY() {
-    return mLastVelocityY;
-  }
-
-
-  /**
-   * This method adds movement to {@class VelocityTracker} first resetting offset of the event so
-   * that the velocity is calculated based on the absolute position of touch pointers. This is
-   * because if the underlying view moves along with the finger using relative x/y coords yields
-   * incorrect results.
-   */
-  private static void addVelocityMovement(VelocityTracker tracker, MotionEvent event) {
-    float offsetX = event.getRawX() - event.getX();
-    float offsetY = event.getRawY() - event.getY();
-    event.offsetLocation(offsetX, offsetY);
-    tracker.addMovement(event);
-    event.offsetLocation(-offsetX, -offsetY);
-  }
-}

package/android/lib/src/main/java/com/swmansion/gesturehandler/PinchGestureHandler.java

@@ -1,109 +0,0 @@
-package com.swmansion.gesturehandler;
-
-import android.content.Context;
-import android.view.MotionEvent;
-import android.view.ScaleGestureDetector;
-import android.view.ViewConfiguration;
-
-public class PinchGestureHandler extends GestureHandler<PinchGestureHandler> {
-
-  private ScaleGestureDetector mScaleGestureDetector;
-  private double mLastScaleFactor;
-  private double mLastVelocity;
-
-  private float mStartingSpan;
-  private float mSpanSlop;
-
-  private ScaleGestureDetector.OnScaleGestureListener mGestureListener =
-          new ScaleGestureDetector.OnScaleGestureListener() {
-
-    @Override
-    public boolean onScale(ScaleGestureDetector detector) {
-      double prevScaleFactor = mLastScaleFactor;
-      mLastScaleFactor *= detector.getScaleFactor();
-      long delta = detector.getTimeDelta();
-      if (delta > 0) {
-        mLastVelocity = (mLastScaleFactor - prevScaleFactor) / delta;
-      }
-      if (Math.abs(mStartingSpan - detector.getCurrentSpan()) >= mSpanSlop
-              && getState() == STATE_BEGAN) {
-        activate();
-      }
-      return true;
-    }
-
-    @Override
-    public boolean onScaleBegin(ScaleGestureDetector detector) {
-      mStartingSpan = detector.getCurrentSpan();
-      return true;
-    }
-
-    @Override
-    public void onScaleEnd(ScaleGestureDetector detector) {
-      // ScaleGestureDetector thinks that when fingers are 27mm away that's a sufficiently good
-      // reason to trigger this method giving us no other choice but to ignore it completely.
-    }
-  };
-
-  public PinchGestureHandler() {
-    setShouldCancelWhenOutside(false);
-  }
-
-  @Override
-  protected void onHandle(MotionEvent event) {
-    if (getState() == STATE_UNDETERMINED) {
-      Context context = getView().getContext();
-      mLastVelocity = 0f;
-      mLastScaleFactor = 1f;
-      mScaleGestureDetector = new ScaleGestureDetector(context, mGestureListener);
-      ViewConfiguration configuration = ViewConfiguration.get(context);
-      mSpanSlop = configuration.getScaledTouchSlop();
-
-      begin();
-    }
-
-    if (mScaleGestureDetector != null) {
-      mScaleGestureDetector.onTouchEvent(event);
-    }
-
-    int activePointers = event.getPointerCount();
-    if (event.getActionMasked() == MotionEvent.ACTION_POINTER_UP) {
-      activePointers -= 1;
-    }
-
-    if (getState() == STATE_ACTIVE && activePointers < 2) {
-      end();
-    } else if (event.getActionMasked() == MotionEvent.ACTION_UP) {
-      fail();
-    }
-  }
-
-  @Override
-  protected void onReset() {
-    mScaleGestureDetector = null;
-    mLastVelocity = 0f;
-    mLastScaleFactor = 1f;
-  }
-
-  public double getScale() {
-    return mLastScaleFactor;
-  }
-
-  public double getVelocity() {
-    return mLastVelocity;
-  }
-
-  public float getFocalPointX() {
-    if (mScaleGestureDetector == null) {
-      return Float.NaN;
-    }
-    return mScaleGestureDetector.getFocusX();
-  }
-
-  public float getFocalPointY() {
-    if (mScaleGestureDetector == null) {
-      return Float.NaN;
-    }
-    return mScaleGestureDetector.getFocusY();
-  }
-}