之前一片文章 初略的講了一些關於事件傳遞的基本內容,現在這片部落格, 主要是具體去運用事件傳遞攔截的相關內容, 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();
    }
}