Android 滑动,拦截事件处理

最新推荐文章于 2024-01-29 07:00:00 发布
最新推荐文章于 2024-01-29 07:00:00 发布
阅读量5.8k 收藏
点赞数
分类专栏： Android 文章标签： Android 事件处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chen930724/article/details/49593971
版权
之前一片文章 初略的讲了一些关于事件传递的基本内容,现在这片博客,
主要是具体去运用事件传递拦截的相关内容,

ok 具体要实现的目标就是, 
view 能够正常的吃掉点击事件, 但是如果是滑动事件时, 则是父View 来处理来滑动另一个View

基本原理就是 
在View group中得onInterceptTouchEvent 方法中判断是否是滑动,
如果是滑动,那么就返回true 自身去消费滑动事件,

还需要注意的是, 在处理滑动事件的时候需要注意 两个手指滑动的情况
即 另一个手指按下也能够继续滑动,

不多说了上代码: 

/**
 * 只处理 纵向滑动事件, 其他事件不做 处理
 */
public class CustomScrollViewGroup extends RelativeLayout {

    public static final String TAG = "CustomScrollViewGroup";

    public CustomScrollViewGroup(Context context) {
        super(context);
        init();
    }

    public CustomScrollViewGroup(Context context, AttributeSet attrs) {
        super(context, attrs);
        init();
    }

    public CustomScrollViewGroup(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init();
    }

    private static final int MIN_DISTANCE_FOR_FLING = 25; // dips

    private OnScrollListener mOnScrollListener;

    private int mTouchSlop;
    protected VelocityTracker mVelocityTracker;
    private int mMinimumVelocity;
    private int mMaximumVelocity;

    /**
     * Position of the last motion event.
     */
    private float mLastMotionX;
    private float mLastMotionY;

    private float mInitialMotionY, mInitialMotionX;

    protected int mActivePointerId = INVALID_POINTER;
    private static final int INVALID_POINTER = -1;

    private boolean mIsUnableToDrag = false;

    private int mFlingDistance;

    private boolean mIsBeingDragged = false;
    boolean mScrollToEnd = false;//标记View是否已经完全消失，OvershootInterpolator回弹时间忽略
    private boolean mQuickReturn = false;

    boolean isTouchOnRecycleView = false;

    private void init() {

        final ViewConfiguration configuration = ViewConfiguration.get(getContext());
        mTouchSlop = configuration.getScaledTouchSlop();
        mMinimumVelocity = configuration.getScaledMinimumFlingVelocity();
        mMaximumVelocity = configuration.getScaledMaximumFlingVelocity();

        final float density = getContext().getResources().getDisplayMetrics().density;
        mFlingDistance = (int) (MIN_DISTANCE_FOR_FLING * density);
    }

    @Override
    protected void onAttachedToWindow() {
        super.onAttachedToWindow();

        int childCount = getChildCount();
        for (int i = 0; i < childCount; i++) {
            View child = getChildAt(i);
        }
    }

    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        LogUtil.d(TAG, "onInterceptTouchEvent ev = " + ev.getAction());
        final int action = ev.getAction();

        if (action == MotionEvent.ACTION_CANCEL
                || action == MotionEvent.ACTION_UP
                || (action != MotionEvent.ACTION_DOWN && mIsUnableToDrag)) {
            endDrag();
            return false;
        }

        switch (action & MotionEventCompat.ACTION_MASK) {
            case MotionEvent.ACTION_DOWN:
                // Remember where the motion event started
                int index = MotionEventCompat.getActionIndex(ev);
                mActivePointerId = MotionEventCompat.getPointerId(ev, index);
                if (mActivePointerId == INVALID_POINTER)
                    break;
                mLastMotionX = mInitialMotionX = MotionEventCompat.getX(ev, index);
                mInitialMotionY = mLastMotionY = MotionEventCompat.getY(ev, index);

                mIsBeingDragged = false;
                mIsUnableToDrag = false;
                break;

            case MotionEvent.ACTION_MOVE:
                final int activePointerIndex = getPointerIndex(ev, mActivePointerId);
                if (mActivePointerId == INVALID_POINTER) {
                    break;
                }
                final float currentY = MotionEventCompat.getY(ev, activePointerIndex);
                final float deltaY = mLastMotionY - currentY;
                determineDrag(ev);
                break;
        }

        if (!mIsBeingDragged) {
            if (mVelocityTracker == null) {
                mVelocityTracker = VelocityTracker.obtain();
            }
            mVelocityTracker.addMovement(ev);
        }
        return mIsBeingDragged || mQuickReturn;
    }

    private int getPointerIndex(MotionEvent ev, int id) {
        int activePointerIndex = MotionEventCompat.findPointerIndex(ev, id);
        if (activePointerIndex == -1)
            mActivePointerId = INVALID_POINTER;
        return activePointerIndex;
    }

    private int mScrollY = 0;

    @Override
    public boolean onTouchEvent(MotionEvent ev) {
        LogUtil.d(TAG, "onTouchEvent ev = " + ev.getAction());
        if (mVelocityTracker == null) {
            mVelocityTracker = VelocityTracker.obtain();
        }
        mVelocityTracker.addMovement(ev);
        final int action = ev.getAction();

        switch (action & MotionEventCompat.ACTION_MASK) {
            case MotionEvent.ACTION_DOWN:
                // Remember where the motion event started
                int index = MotionEventCompat.getActionIndex(ev);
                mActivePointerId = MotionEventCompat.getPointerId(ev, index);
                mLastMotionY = mInitialMotionY = ev.getY();
                mLastMotionX = mInitialMotionX = ev.getX();
                break;
            case MotionEvent.ACTION_MOVE:
                if (!mIsBeingDragged) {
                    determineDrag(ev);

                    if (mIsUnableToDrag)
                        return false;
                }

                if (mIsBeingDragged) {
                    final int activePointerIndex = getPointerIndex(ev, mActivePointerId);
                    if (mActivePointerId == INVALID_POINTER)
                        break;
                    final float y = MotionEventCompat.getY(ev, activePointerIndex);
                    final float deltaY = mLastMotionY - y;
                    mLastMotionY = y;
                    float oldScrollY = mScrollY;
                    float scrollY = oldScrollY + deltaY;
                    mLastMotionX += scrollY - (int) scrollY;
                    mScrollY = (int) scrollY;

                    if (mOnScrollListener != null) {
                        mOnScrollListener.onScroll(0, deltaY);
                    }
                }
                break;
            case MotionEvent.ACTION_UP:
            case MotionEvent.ACTION_CANCEL:
                if (mIsBeingDragged) {
                    final VelocityTracker velocityTracker = mVelocityTracker;
                    velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
                    int initialVelocity = (int) VelocityTrackerCompat.getYVelocity(velocityTracker, mActivePointerId);
                    final int activePointerIndex = getPointerIndex(ev, mActivePointerId);
                    if (mActivePointerId != INVALID_POINTER) {
                        final float y = MotionEventCompat.getY(ev, activePointerIndex);
                        final int totalDelta = (int) (y - mInitialMotionY);// doww -> up detal
                        if (Math.abs(totalDelta) > mFlingDistance && Math.abs(initialVelocity) > mMinimumVelocity) {
                            if (initialVelocity > 0 && totalDelta > 0) {
                                // 向下滑
                                if (mOnScrollListener != null) {
                                    mOnScrollListener.onFling(false);
                                }
                            } else if (initialVelocity < 0 && totalDelta < 0) {
                                // 向上滑
                                if (mOnScrollListener != null) {
                                    mOnScrollListener.onFling(true);
                                }
                            } else {
                                if (mOnScrollListener != null) {
                                    mOnScrollListener.onScrollOver();
                                }
                            }
                        } else {
                            if (mOnScrollListener != null) {
                                mOnScrollListener.onScrollOver();
                            }
                            // 不是 fling 最后是 划上 还是划下  外面判断
                        }

                    }
                    mActivePointerId = INVALID_POINTER;
                    endDrag();
                }
                break;
            case MotionEventCompat.ACTION_POINTER_DOWN: {
                final int indexx = MotionEventCompat.getActionIndex(ev);
                mLastMotionY = MotionEventCompat.getY(ev, indexx);
                mLastMotionX = MotionEventCompat.getX(ev, indexx);
                mActivePointerId = MotionEventCompat.getPointerId(ev, indexx);
                break;
            }
            case MotionEventCompat.ACTION_POINTER_UP:
                int pointerIndex = getPointerIndex(ev, mActivePointerId);
                if (mActivePointerId == INVALID_POINTER)
                    break;
                mLastMotionY = MotionEventCompat.getY(ev, pointerIndex);
                mLastMotionX = MotionEventCompat.getX(ev, pointerIndex);
                break;
        }

        return true;
    }

    private void determineDrag(MotionEvent ev) {
        final int activePointerId = mActivePointerId;
        final int pointerIndex = getPointerIndex(ev, activePointerId);
        if (activePointerId == INVALID_POINTER || pointerIndex == INVALID_POINTER)
            return;
        final float x = MotionEventCompat.getX(ev, pointerIndex);
        final float dx = x - mLastMotionX;
        final float xDiff = Math.abs(dx);
        final float y = MotionEventCompat.getY(ev, pointerIndex);
        final float dy = y - mLastMotionY;
        final float yDiff = Math.abs(dy);
        if (yDiff > mTouchSlop && yDiff > xDiff) {
            startDrag();
            mLastMotionX = x;
            mLastMotionY = y;
        } else if (xDiff > mTouchSlop) {
            mIsUnableToDrag = true;
        }
    }

    // 开始滑动
    private void startDrag() {
        mIsBeingDragged = true;
        mQuickReturn = false;
        mScrollToEnd = false;
    }

    private void endDrag() {
        mQuickReturn = false;
        mIsBeingDragged = false;
        mIsUnableToDrag = false;
        mActivePointerId = INVALID_POINTER;

        if (mVelocityTracker != null) {
            mVelocityTracker.recycle();
            mVelocityTracker = null;
        }
    }

    public void setOnScrollListener(OnScrollListener onScrollListener) {
        mOnScrollListener = onScrollListener;
    }

    public interface OnScrollListener {
        void onScroll(float distanceX, float distanceY);

        void onFling(boolean isFlingUp);

        void onScrollOver();

    }
}

上面的是最主要的ViewGroup 
下面在来看看 activity 中得代码  

public class MainActivity extends AppCompatActivity {
    public static final String TAG = "MainActivity";

    Button mButton;
    View mView;
    CustomScrollViewGroup mCustomScrollViewGroup;

    int maxTranY;

    float currentTransY = 0;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mButton = (Button) findViewById(R.id.btn);
        mView = findViewById(R.id.scrolledView);
        mCustomScrollViewGroup = (CustomScrollViewGroup) findViewById(R.id.customscrollviewgroup);

        maxTranY = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 300, getResources().getDisplayMetrics());

        mButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Toast.makeText(MainActivity.this, "click btn", Toast.LENGTH_SHORT).show();
            }
        });

        mCustomScrollViewGroup.setOnScrollListener(new CustomScrollViewGroup.OnScrollListener() {
            /**
             * 滑动 的箭头
             * @param distanceX 向左滑动 为正
             * @param distanceY 向上滑动 为正
             */
            @Override
            public void onScroll(float distanceX, float distanceY) {
                if (isAnimating) {
                    return;
                }
                currentTransY = currentTransY - distanceY;
                if (currentTransY < -maxTranY) {
                    currentTransY = -maxTranY;
                }

                if (currentTransY > 0) {
                    currentTransY = 0;
                }
                mView.setTranslationY(currentTransY);
                LogUtil.d(TAG, "onScroll distanceX = " + distanceX + " , distanceY = " + distanceY + ", currentTransY = " + currentTransY);
            }

            /**
             * 快速滑动的回调
             * @param isFlingUp 是否是向上快速滑动
             */
            @Override
            public void onFling(boolean isFlingUp) {
                if (isAnimating) {
                    return;
                }
                LogUtil.d(TAG, "onFling isFlingUp = " + isFlingUp);
                if (isFlingUp) {
                    animatorScrollUp();
                } else {
                    animatorScrollDowm();
                }
            }

            /**
             * 滑动结束的监听
             */
            @Override
            public void onScrollOver() {
                if (isAnimating) {
                    return;
                }
                LogUtil.d(TAG, "onScrollOver");
                if (currentTransY < -maxTranY / 2) {// 向上滑超过了 1/2
                    animatorScrollUp();
                } else {
                    animatorScrollDowm();
                }
            }
        });

    }

    boolean isAnimating = false;

    private void animatorScrollUp() {
        ObjectAnimator objectAnimator = ObjectAnimator.ofFloat(mView, "TranslationY", mView.getTranslationY(), -maxTranY);
        objectAnimator.setDuration(300);
        isAnimating = true;
        objectAnimator.addListener(new AnimatorListenerAdapter() {
            @Override
            public void onAnimationEnd(Animator animation) {
                super.onAnimationEnd(animation);
                currentTransY = -maxTranY;
                isAnimating = false;
            }
        });
        objectAnimator.start();
    }

    private void animatorScrollDowm() {
        ObjectAnimator objectAnimator = ObjectAnimator.ofFloat(mView, "TranslationY", mView.getTranslationY(), 0);
        objectAnimator.setDuration(300);
        isAnimating = true;
        objectAnimator.addListener(new AnimatorListenerAdapter() {
            @Override
            public void onAnimationEnd(Animator animation) {
                super.onAnimationEnd(animation);
                currentTransY = 0;
                isAnimating = false;
            }
        });
        objectAnimator.start();
    }
}





crianzy
关注
专栏目录
Android 滑动冲突拦截法★
zenmela2011的专栏
03-24 2534
分别使用外部拦截、内部拦截方法解决SwipeRefreshLayout+ViewPager事件冲突问题，主要冲突为SwipeRefreshLayout是纵向滑动，而ViewPager是横向滑动。虽然本身源码已经做好了相应的处理，为了巩固事件分发的原理，我们通过自定义代码的方法解决。 期望效果：横向滑动ViewPager，纵向滑动SwipeRefreshLayout 1.内部拦截法 内部拦截法是指父容器不拦截任何触摸事件，所有的触摸事件都传递给子元素，如果子元素需要此触摸事件就直接消耗掉，否者就交由.
Android中级——事件拦截机制和滑动冲突
松仔Log的博客
01-31 980
若MyViewGroupA的onInterceptTouchEvent()方法返回True，打印如下。若MyViewGroupB的onInterceptTouchEvent()方法返回True，打印如下。若MyViewGroupB的onTouchEvent()方法返回True，打印如下。布局如下，MyViewGroupA包裹MyViewGroupB再包裹MyView。若MyView的onTouchEvent()方法返回True，打印如下。点击最内层蓝色的MyView，打印如下。
Android 的内外部拦截滑动事件的冲突
weixin_30596165的博客
05-12 194
https://blog.csdn.net/u014316462/article/details/52014462 https://blog.csdn.net/sheng2459704496/article/details/81740922 转载于:https://www.cnblogs.com/liunx1109/p/10852845.html
android 解决滑动冲突-内部拦截法
G_taos的博客
07-08 924
内部拦截法：内部拦截法是指父容器不拦截任何触摸事件，所有的触摸事件都传递给子元素，如果子元素需要此触摸事件就直接消耗掉，否则就交由父容器进行处理，这种方法和Android中的事件传递、处理机制不一致，需要配合requestDisallowInterceptTouchEvent方法才能正常工作，使用起来比外部拦截法稍显复杂。这种方法需要重写子元素的dispatchTouchEvent方法和父容器的onInterceptTouchEvent方法。内部拦截主要依赖于requestDisallowIntercept
android滑动事件冲突の内部拦截法
08-24
android滑动事件冲突の内部拦截法
Android 滑动拦截实例代码解析
09-01
在Android开发中，滑动拦截（Touch Event Interception）是一项重要的功能，允许开发者自定义触摸事件的处理方式，特别是对于有多个嵌套视图的布局。在这个实例中，我们将深入理解如何实现一个自定义的父布局，以...
android滑动事件冲突の外部拦截法
08-23
本文将深入探讨“android滑动事件冲突の外部拦截法”，并提供解决方案。 滑动事件冲突通常发生在父视图和子视图都需要响应滑动操作的情况下。例如，一个滚动列表（RecyclerView或ScrollView）嵌套在一个可滑动的...
自己写的android事件分发拦截处理的代码可以清楚知道事件分发拦截和处理的过程.rar
07-30
4. ViewGroup的`onInterceptTouchEvent()`：此方法是ViewGroup独有的，用于决定是否拦截事件流。如果返回true，事件将不再传递给该ViewGroup的子视图，而是由ViewGroup自己处理。默认情况下，此方法返回false，表示...
android 解决滑动冲突的外部拦截法
嘎啦嘎啦
08-29 1423
解决滑动冲突的思路就是基于andoird的view消息分发机制, 根据情况拦截父布局的消息, 从而控制父布局和子布局的滑动.
android 滑动拦截,处理fragment的左右滑动事件意外拦截问题
weixin_34404599的博客
05-27 609
请看load_data_waiting_layout.xml内容，RelativeLayout, ProgressBar, TextView等控件设置clickable为true之后就不再支持ProgramListFragment的左右滑动事件。如果不设置clickable属性或者设置为false之后就支持ProgramListFragment的左右滑动事件。programListFragment...
Android滑动冲突解决
aaadaaaada的专栏
06-18 213
Android事件冲突处理方案无非两种：内部拦截法和外部拦截法内部拦截法伪代码：主要通过requestDisallowInterceptTouchEvent（），该方法可以让父 view的事件拦截生效，那么如果父View的拦截失效，则子View即可获得事件。
Android中滑动事件冲突的处理方法
lzy的博客
09-06 4937
滑动是Android中不可缺少的一部分，多个滑动必然会产生冲突，比如我们最常见的是ScrollView中嵌套了ListView，一般做法是计算出ListView的总高度，这样就不用去滑动ListView了。又比如一个ViewPager嵌套Fragment，Fragment里面又有ListView，这原本是有滑动冲突的，但是ViewPager内部去帮我们解决了这种冲突。那如果我们要自己解决冲突又该怎
Android-滑动冲突问题与解决
CHNE_TAO_EMSM的博客
10-29 967
Android-滑动冲突问题与解决
Android 处理滑动冲突的拦截方法（事件分发）
weixin_43901866的博客
04-02 1277
一.外部拦截 属于事件分发的正常套路，需要拦截就拦截，不需要就不拦截 @Override public boolean onInterceptTouchEvent(MotionEvent event){ boolean intercepted = false; int x = (int) event.getX(); int y = (int) event.getY()...
android 触摸事件 取消,android-防止recyclerview停止在触摸事件上滚动
weixin_39627481的博客
05-26 815
我有一个简单的recyclerview,带有一个显示数字列表的字符串适配器,我想避免recyclerview在滚动并被用户触摸时停止.我已经取消了在用户拖动时手动滚动recyclerview的操作,但是我需要以编程方式自行管理滚动(开始和停止滚动)我不想让用户与recyclerview进行交互.这是一个小数字video,显示了用户在滚动(停止)滚动时触摸recyclerview时发生的情况.我想取...
滑动事件分发和拦截的一点记录
sinat_29177073的博客
12-12 493
对于listView,如果它的item可以左右滑动，此时的事件分发分析： listView继承自AbsListView,它的onInterceptTouchEvent默认返回true，所以在move事件时可以滑动 当它的item可以左右滑动时，根据事件分发的流程，若item的根布局的onInterceptTouchEvent，在move事件时，判断左右有位移时返回true，那么就会拦截
android view禁止右滑,屏蔽左右Touch手势事件，禁止滑动的ViewPager | KaelLi的博客
weixin_29932039的博客
05-27 1811
ViewPager的主要作用，就是用来展示一组可以通过手势滑动的视图，用户可以随意向左或向右滑动。但总有些时候，我们会有一些比较奇怪的场景，这些场景下我们依然需要使用ViewPager，却需要它不能跟随手势进行切换。比如，我们做了一个模拟人机考试的App，也就是模拟的学生在电脑上考试的场景，只能用鼠标点击上一题或下一题来切换，而不可能通过触摸电脑显示器去切换。产品定位就是无限仿真人机考试，于是在手...
3分钟搞定，学会Android滑动冲突解决技巧
最新发布
大模型学习路线
01-29 2163
滑动冲突的解决方式主要有外部拦截法和内部拦截法两种。希望本文能帮助读者解决滑动冲突问题，提高。方法中，我们可以根据事件的类型和位置来判断是否需要拦截事件。如果需要拦截事件，则返回。方法中，我们可以根据事件的类型和位置来判断是否需要拦截事件。如果需要拦截事件，则调用。滑动方向一致，则会导致滑动冲突。同时收到滑动事件，导致无法正常滑动。会根据自己的滑动方向和滑动能力来决定是否拦截事件。滑动冲突的主要解决思想有两种：外部拦截法和内部拦截法。当用户在屏幕上触摸时，事件会首先传递给最顶层的。默认的滑动冲突解决方式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值