Android 滑动,拦截事件处理

小咪咪 2022-08-09 17:45 374阅读 0赞

之前一片文章 初略的讲了一些关于事件传递的基本内容,现在这片博客,

主要是具体去运用事件传递拦截的相关内容,

ok 具体要实现的目标就是,

view 能够正常的吃掉点击事件, 但是如果是滑动事件时, 则是父View 来处理来滑动另一个View

基本原理就是

在View group中得onInterceptTouchEvent 方法中判断是否是滑动,

如果是滑动,那么就返回true 自身去消费滑动事件,

还需要注意的是, 在处理滑动事件的时候需要注意 两个手指滑动的情况

即 另一个手指按下也能够继续滑动,

不多说了上代码: 

  1. /**
  2.  * 只处理 纵向滑动事件, 其他事件不做 处理
  3.  */
  4. public class CustomScrollViewGroup extends RelativeLayout {
  6.     public static final String TAG = "CustomScrollViewGroup";
  8.     public CustomScrollViewGroup(Context context) {
  9.         super(context);
  10.         init();
  11.     }
  13.     public CustomScrollViewGroup(Context context, AttributeSet attrs) {
  14.         super(context, attrs);
  15.         init();
  16.     }
  18.     public CustomScrollViewGroup(Context context, AttributeSet attrs, int defStyleAttr) {
  19.         super(context, attrs, defStyleAttr);
  20.         init();
  21.     }
  23.     private static final int MIN_DISTANCE_FOR_FLING = 25; // dips
  25.     private OnScrollListener mOnScrollListener;
  27.     private int mTouchSlop;
  28.     protected VelocityTracker mVelocityTracker;
  29.     private int mMinimumVelocity;
  30.     private int mMaximumVelocity;
  32.     /**
  33.      * Position of the last motion event.
  34.      */
  35.     private float mLastMotionX;
  36.     private float mLastMotionY;
  38.     private float mInitialMotionY, mInitialMotionX;
  40.     protected int mActivePointerId = INVALID_POINTER;
  41.     private static final int INVALID_POINTER = -1;
  43.     private boolean mIsUnableToDrag = false;
  45.     private int mFlingDistance;
  47.     private boolean mIsBeingDragged = false;
  48.     boolean mScrollToEnd = false;//标记View是否已经完全消失，OvershootInterpolator回弹时间忽略
  49.     private boolean mQuickReturn = false;
  51.     boolean isTouchOnRecycleView = false;
  53.     private void init() {
  55.         final ViewConfiguration configuration = ViewConfiguration.get(getContext());
  56.         mTouchSlop = configuration.getScaledTouchSlop();
  57.         mMinimumVelocity = configuration.getScaledMinimumFlingVelocity();
  58.         mMaximumVelocity = configuration.getScaledMaximumFlingVelocity();
  60.         final float density = getContext().getResources().getDisplayMetrics().density;
  61.         mFlingDistance = (int) (MIN_DISTANCE_FOR_FLING * density);
  62.     }
  64.     @Override
  65.     protected void onAttachedToWindow() {
  66.         super.onAttachedToWindow();
  68.         int childCount = getChildCount();
  69.         for (int i = 0; i < childCount; i++) {
  70.             View child = getChildAt(i);
  71.         }
  72.     }
  74.     @Override
  75.     public boolean onInterceptTouchEvent(MotionEvent ev) {
  76.         LogUtil.d(TAG, "onInterceptTouchEvent ev = " + ev.getAction());
  77.         final int action = ev.getAction();
  79.         if (action == MotionEvent.ACTION_CANCEL
  80.                 || action == MotionEvent.ACTION_UP
  81.                 || (action != MotionEvent.ACTION_DOWN && mIsUnableToDrag)) {
  82.             endDrag();
  83.             return false;
  84.         }
  86.         switch (action & MotionEventCompat.ACTION_MASK) {
  87.             case MotionEvent.ACTION_DOWN:
  88.                 // Remember where the motion event started
  89.                 int index = MotionEventCompat.getActionIndex(ev);
  90.                 mActivePointerId = MotionEventCompat.getPointerId(ev, index);
  91.                 if (mActivePointerId == INVALID_POINTER)
  92.                     break;
  93.                 mLastMotionX = mInitialMotionX = MotionEventCompat.getX(ev, index);
  94.                 mInitialMotionY = mLastMotionY = MotionEventCompat.getY(ev, index);
  96.                 mIsBeingDragged = false;
  97.                 mIsUnableToDrag = false;
  98.                 break;
  100.             case MotionEvent.ACTION_MOVE:
  101.                 final int activePointerIndex = getPointerIndex(ev, mActivePointerId);
  102.                 if (mActivePointerId == INVALID_POINTER) {
  103.                     break;
  104.                 }
  105.                 final float currentY = MotionEventCompat.getY(ev, activePointerIndex);
  106.                 final float deltaY = mLastMotionY - currentY;
  107.                 determineDrag(ev);
  108.                 break;
  109.         }
  111.         if (!mIsBeingDragged) {
  112.             if (mVelocityTracker == null) {
  113.                 mVelocityTracker = VelocityTracker.obtain();
  114.             }
  115.             mVelocityTracker.addMovement(ev);
  116.         }
  117.         return mIsBeingDragged || mQuickReturn;
  118.     }
  120.     private int getPointerIndex(MotionEvent ev, int id) {
  121.         int activePointerIndex = MotionEventCompat.findPointerIndex(ev, id);
  122.         if (activePointerIndex == -1)
  123.             mActivePointerId = INVALID_POINTER;
  124.         return activePointerIndex;
  125.     }
  127.     private int mScrollY = 0;
  129.     @Override
  130.     public boolean onTouchEvent(MotionEvent ev) {
  131.         LogUtil.d(TAG, "onTouchEvent ev = " + ev.getAction());
  132.         if (mVelocityTracker == null) {
  133.             mVelocityTracker = VelocityTracker.obtain();
  134.         }
  135.         mVelocityTracker.addMovement(ev);
  136.         final int action = ev.getAction();
  138.         switch (action & MotionEventCompat.ACTION_MASK) {
  139.             case MotionEvent.ACTION_DOWN:
  140.                 // Remember where the motion event started
  141.                 int index = MotionEventCompat.getActionIndex(ev);
  142.                 mActivePointerId = MotionEventCompat.getPointerId(ev, index);
  143.                 mLastMotionY = mInitialMotionY = ev.getY();
  144.                 mLastMotionX = mInitialMotionX = ev.getX();
  145.                 break;
  146.             case MotionEvent.ACTION_MOVE:
  147.                 if (!mIsBeingDragged) {
  148.                     determineDrag(ev);
  150.                     if (mIsUnableToDrag)
  151.                         return false;
  152.                 }
  154.                 if (mIsBeingDragged) {
  155.                     final int activePointerIndex = getPointerIndex(ev, mActivePointerId);
  156.                     if (mActivePointerId == INVALID_POINTER)
  157.                         break;
  158.                     final float y = MotionEventCompat.getY(ev, activePointerIndex);
  159.                     final float deltaY = mLastMotionY - y;
  160.                     mLastMotionY = y;
  161.                     float oldScrollY = mScrollY;
  162.                     float scrollY = oldScrollY + deltaY;
  163.                     mLastMotionX += scrollY - (int) scrollY;
  164.                     mScrollY = (int) scrollY;
  166.                     if (mOnScrollListener != null) {
  167.                         mOnScrollListener.onScroll(0, deltaY);
  168.                     }
  169.                 }
  170.                 break;
  171.             case MotionEvent.ACTION_UP:
  172.             case MotionEvent.ACTION_CANCEL:
  173.                 if (mIsBeingDragged) {
  174.                     final VelocityTracker velocityTracker = mVelocityTracker;
  175.                     velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
  176.                     int initialVelocity = (int) VelocityTrackerCompat.getYVelocity(velocityTracker, mActivePointerId);
  177.                     final int activePointerIndex = getPointerIndex(ev, mActivePointerId);
  178.                     if (mActivePointerId != INVALID_POINTER) {
  179.                         final float y = MotionEventCompat.getY(ev, activePointerIndex);
  180.                         final int totalDelta = (int) (y - mInitialMotionY);// doww -> up detal
  181.                         if (Math.abs(totalDelta) > mFlingDistance && Math.abs(initialVelocity) > mMinimumVelocity) {
  182.                             if (initialVelocity > 0 && totalDelta > 0) {
  183.                                 // 向下滑
  184.                                 if (mOnScrollListener != null) {
  185.                                     mOnScrollListener.onFling(false);
  186.                                 }
  187.                             } else if (initialVelocity < 0 && totalDelta < 0) {
  188.                                 // 向上滑
  189.                                 if (mOnScrollListener != null) {
  190.                                     mOnScrollListener.onFling(true);
  191.                                 }
  192.                             } else {
  193.                                 if (mOnScrollListener != null) {
  194.                                     mOnScrollListener.onScrollOver();
  195.                                 }
  196.                             }
  197.                         } else {
  198.                             if (mOnScrollListener != null) {
  199.                                 mOnScrollListener.onScrollOver();
  200.                             }
  201.                             // 不是 fling 最后是 划上 还是划下  外面判断
  202.                         }
  204.                     }
  205.                     mActivePointerId = INVALID_POINTER;
  206.                     endDrag();
  207.                 }
  208.                 break;
  209.             case MotionEventCompat.ACTION_POINTER_DOWN: {
  210.                 final int indexx = MotionEventCompat.getActionIndex(ev);
  211.                 mLastMotionY = MotionEventCompat.getY(ev, indexx);
  212.                 mLastMotionX = MotionEventCompat.getX(ev, indexx);
  213.                 mActivePointerId = MotionEventCompat.getPointerId(ev, indexx);
  214.                 break;
  215.             }
  216.             case MotionEventCompat.ACTION_POINTER_UP:
  217.                 int pointerIndex = getPointerIndex(ev, mActivePointerId);
  218.                 if (mActivePointerId == INVALID_POINTER)
  219.                     break;
  220.                 mLastMotionY = MotionEventCompat.getY(ev, pointerIndex);
  221.                 mLastMotionX = MotionEventCompat.getX(ev, pointerIndex);
  222.                 break;
  223.         }
  225.         return true;
  226.     }
  228.     private void determineDrag(MotionEvent ev) {
  229.         final int activePointerId = mActivePointerId;
  230.         final int pointerIndex = getPointerIndex(ev, activePointerId);
  231.         if (activePointerId == INVALID_POINTER || pointerIndex == INVALID_POINTER)
  232.             return;
  233.         final float x = MotionEventCompat.getX(ev, pointerIndex);
  234.         final float dx = x - mLastMotionX;
  235.         final float xDiff = Math.abs(dx);
  236.         final float y = MotionEventCompat.getY(ev, pointerIndex);
  237.         final float dy = y - mLastMotionY;
  238.         final float yDiff = Math.abs(dy);
  239.         if (yDiff > mTouchSlop && yDiff > xDiff) {
  240.             startDrag();
  241.             mLastMotionX = x;
  242.             mLastMotionY = y;
  243.         } else if (xDiff > mTouchSlop) {
  244.             mIsUnableToDrag = true;
  245.         }
  246.     }
  248.     // 开始滑动
  249.     private void startDrag() {
  250.         mIsBeingDragged = true;
  251.         mQuickReturn = false;
  252.         mScrollToEnd = false;
  253.     }
  255.     private void endDrag() {
  256.         mQuickReturn = false;
  257.         mIsBeingDragged = false;
  258.         mIsUnableToDrag = false;
  259.         mActivePointerId = INVALID_POINTER;
  261.         if (mVelocityTracker != null) {
  262.             mVelocityTracker.recycle();
  263.             mVelocityTracker = null;
  264.         }
  265.     }
  267.     public void setOnScrollListener(OnScrollListener onScrollListener) {
  268.         mOnScrollListener = onScrollListener;
  269.     }
  271.     public interface OnScrollListener {
  272.         void onScroll(float distanceX, float distanceY);
  274.         void onFling(boolean isFlingUp);
  276.         void onScrollOver();
  278.     }
  279. }

上面的是最主要的ViewGroup

下面在来看看 activity 中得代码 

  1. public class MainActivity extends AppCompatActivity {
  2.     public static final String TAG = "MainActivity";
  4.     Button mButton;
  5.     View mView;
  6.     CustomScrollViewGroup mCustomScrollViewGroup;
  8.     int maxTranY;
  10.     float currentTransY = 0;
  12.     @Override
  13.     protected void onCreate(Bundle savedInstanceState) {
  14.         super.onCreate(savedInstanceState);
  15.         setContentView(R.layout.activity_main);
  16.         mButton = (Button) findViewById(R.id.btn);
  17.         mView = findViewById(R.id.scrolledView);
  18.         mCustomScrollViewGroup = (CustomScrollViewGroup) findViewById(R.id.customscrollviewgroup);
  20.         maxTranY = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 300, getResources().getDisplayMetrics());
  22.         mButton.setOnClickListener(new View.OnClickListener() {
  23.             @Override
  24.             public void onClick(View v) {
  25.                 Toast.makeText(MainActivity.this, "click btn", Toast.LENGTH_SHORT).show();
  26.             }
  27.         });
  29.         mCustomScrollViewGroup.setOnScrollListener(new CustomScrollViewGroup.OnScrollListener() {
  30.             /**
  31.              * 滑动 的箭头
  32.              * @param distanceX 向左滑动 为正
  33.              * @param distanceY 向上滑动 为正
  34.              */
  35.             @Override
  36.             public void onScroll(float distanceX, float distanceY) {
  37.                 if (isAnimating) {
  38.                     return;
  39.                 }
  40.                 currentTransY = currentTransY - distanceY;
  41.                 if (currentTransY < -maxTranY) {
  42.                     currentTransY = -maxTranY;
  43.                 }
  45.                 if (currentTransY > 0) {
  46.                     currentTransY = 0;
  47.                 }
  48.                 mView.setTranslationY(currentTransY);
  49.                 LogUtil.d(TAG, "onScroll distanceX = " + distanceX + " , distanceY = " + distanceY + ", currentTransY = " + currentTransY);
  50.             }
  52.             /**
  53.              * 快速滑动的回调
  54.              * @param isFlingUp 是否是向上快速滑动
  55.              */
  56.             @Override
  57.             public void onFling(boolean isFlingUp) {
  58.                 if (isAnimating) {
  59.                     return;
  60.                 }
  61.                 LogUtil.d(TAG, "onFling isFlingUp = " + isFlingUp);
  62.                 if (isFlingUp) {
  63.                     animatorScrollUp();
  64.                 } else {
  65.                     animatorScrollDowm();
  66.                 }
  67.             }
  69.             /**
  70.              * 滑动结束的监听
  71.              */
  72.             @Override
  73.             public void onScrollOver() {
  74.                 if (isAnimating) {
  75.                     return;
  76.                 }
  77.                 LogUtil.d(TAG, "onScrollOver");
  78.                 if (currentTransY < -maxTranY / 2) {// 向上滑超过了 1/2
  79.                     animatorScrollUp();
  80.                 } else {
  81.                     animatorScrollDowm();
  82.                 }
  83.             }
  84.         });
  86.     }
  88.     boolean isAnimating = false;
  90.     private void animatorScrollUp() {
  91.         ObjectAnimator objectAnimator = ObjectAnimator.ofFloat(mView, "TranslationY", mView.getTranslationY(), -maxTranY);
  92.         objectAnimator.setDuration(300);
  93.         isAnimating = true;
  94.         objectAnimator.addListener(new AnimatorListenerAdapter() {
  95.             @Override
  96.             public void onAnimationEnd(Animator animation) {
  97.                 super.onAnimationEnd(animation);
  98.                 currentTransY = -maxTranY;
  99.                 isAnimating = false;
  100.             }
  101.         });
  102.         objectAnimator.start();
  103.     }
  105.     private void animatorScrollDowm() {
  106.         ObjectAnimator objectAnimator = ObjectAnimator.ofFloat(mView, "TranslationY", mView.getTranslationY(), 0);
  107.         objectAnimator.setDuration(300);
  108.         isAnimating = true;
  109.         objectAnimator.addListener(new AnimatorListenerAdapter() {
  110.             @Override
  111.             public void onAnimationEnd(Animator animation) {
  112.                 super.onAnimationEnd(animation);
  113.                 currentTransY = 0;
  114.                 isAnimating = false;
  115.             }
  116.         });
  117.         objectAnimator.start();
  118.     }
  119. }

源码地址 : https://github.com/crianzy/AndroidDemo/tree/master/TouchEventClickScrollDemo

发表评论

表情：
评论列表 （有 0 条评论，374人围观）

还没有评论，来说两句吧...

相关阅读

    相关 android滑动事件监听

    android中滑动事件是非常常用的，无论是游戏中还是普通的APP中应用都非常广泛，下面来看下他的代码是如何实现的，其代码如下 private void touchl

    亦凉亦凉/ 0 赞/ 348 阅读

    相关 Android拦截html链接事件

    在一个大的Android项目中，由于客户端来不及更新和实现，经常会内嵌一些网页(在一些大型的互联网公司，PC的产品总是跑在客户端的前面)，比如活动页面，通常可以内嵌用html5

    Dear 丶Dear 丶/ 0 赞/ 242 阅读

    相关 Android事件处理

      UI编程通常都会伴随事件处理，Android也不例外，它提供了两种方式的事件处理：基于回调的事件处理和基于监听器的事件处理。 对于基于监听器的事件处理而言，主要

    ゝ一纸荒年。ゝ一纸荒年。/ 0 赞/ 401 阅读