android滑動衝突的解決方案

阿新 • • 發佈：2019-01-15

一、前言
Android 中解決滑動的方案有2種：外部攔截法和內部攔截法。
滑動衝突也存在2種場景: 橫豎滑動衝突、同向滑動衝突。
所以我就寫了4個例子來學習如何解決滑動衝突的，這四個例子分別為: 外部攔截法解決橫豎衝突、外部攔截法解決同向衝突、內部攔截法解決橫豎衝突、內部攔截法解決同向衝突。
先上效果圖：
這裡寫圖片描述

二、實戰
1、外部攔截法，解決橫豎衝突
思路是，重寫父控制元件的onInterceptTouchEvent方法，然後根據具體的需求，來決定父控制元件是否攔截事件。如果攔截返回返回true，不攔截返回false。關於為什麼返回true就代表攔截事件。可以參考我的上一篇部落格：

http://blog.csdn.net/a992036795/article/details/51698023 。如果父控制元件攔截了事件，則在父控制元件的onTouchEvent進行相應的事件處理。
我的這個例子，是一個橫向滑動的ViewGroup裡面包含了3個豎向滑動的ListView。下面我附上程式碼：
HorizontalEx.java

/**
 * Created by blueberry on 2016/6/20.
 *
 * 解決交錯的滑動衝突
 *
 * 外部攔截法
 */
public class HorizontalEx extends ViewGroup {

    private static 
 final String TAG = "HorizontalEx";

    private boolean isFirstTouch = true;
    private int childIndex;
    private int childCount;
    private int lastXIntercept, lastYIntercept, lastX, lastY;

    private Scroller mScroller;
    private VelocityTracker mVelocityTracker;

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

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

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

    private void init() {
        mScroller = new Scroller(getContext());
        mVelocityTracker = VelocityTracker.obtain();
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        int width = MeasureSpec.getSize(widthMeasureSpec);
        int height = MeasureSpec.getSize(heightMeasureSpec);
        int widthMode = MeasureSpec.getMode(widthMeasureSpec);
        int heightMode = MeasureSpec.getMode(heightMeasureSpec);

        childCount = getChildCount();
        measureChildren(widthMeasureSpec, heightMeasureSpec);

        if (childCount == 0) {
            setMeasuredDimension(0, 0);
        } else if (widthMode == MeasureSpec.AT_MOST && heightMode == MeasureSpec.AT_MOST) {
            width = childCount * getChildAt(0).getMeasuredWidth();
            height = getChildAt(0).getMeasuredHeight();
            setMeasuredDimension(width, height);
        } else if (widthMode == MeasureSpec.AT_MOST) {
            width = childCount * getChildAt(0).getMeasuredWidth();
            setMeasuredDimension(width, height);
        } else {
            height = getChildAt(0).getMeasuredHeight();
            setMeasuredDimension(width, height);
        }
    }

    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        int left = 0;
        for (int i = 0; i < getChildCount(); i++) {
            final View child = getChildAt(i);
            child.layout(left + l, t, r + left, b);
            left += child.getMeasuredWidth();
        }
    }

    /**
     * 攔截事件
     * @param ev
     * @return
     */
    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        boolean intercepted = false;
        int x = (int) ev.getX();
        int y = (int) ev.getY();

        switch (ev.getAction()) {
            /*如果攔截了Down事件,則子類不會拿到這個事件序列*/
            case MotionEvent.ACTION_DOWN:
                lastXIntercept = x;
                lastYIntercept = y;
                intercepted = false;
                if (!mScroller.isFinished()) {
                    mScroller.abortAnimation();
                    intercepted = true;
                }
                break;
            case MotionEvent.ACTION_MOVE:
                final int deltaX = x - lastXIntercept;
                final int deltaY = y - lastYIntercept;
                /*根據條件判斷是否攔截該事件*/
                if (Math.abs(deltaX) > Math.abs(deltaY)) {
                    intercepted = true;
                } else {
                    intercepted = false;
                }
                break;
            case MotionEvent.ACTION_UP:
                intercepted = false;
                break;

        }
        lastXIntercept = x;
        lastYIntercept = y;
        return intercepted;
    }


    @Override
    public boolean onTouchEvent(MotionEvent event) {
        int x = (int) event.getX();
        int y = (int) event.getY();
        mVelocityTracker.addMovement(event);
        ViewConfiguration configuration = ViewConfiguration.get(getContext());
        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
                if (!mScroller.isFinished()) {
                    mScroller.abortAnimation();
                }
                break;
            case MotionEvent.ACTION_MOVE:
                /*因為這裡父控制元件拿不到Down事件，所以使用一個布林值，
                    當事件第一次來到父控制元件時，對lastX,lastY賦值*/
                if (isFirstTouch) {
                    lastX = x;
                    lastY = y;
                    isFirstTouch = false;
                }
                final int deltaX = x - lastX;
                scrollBy(-deltaX, 0);
                break;
            case MotionEvent.ACTION_UP:
                int scrollX = getScrollX();
                final int childWidth = getChildAt(0).getWidth();
                mVelocityTracker.computeCurrentVelocity(1000, configuration.getScaledMaximumFlingVelocity());
                float xVelocity = mVelocityTracker.getXVelocity();
                if (Math.abs(xVelocity) > configuration.getScaledMinimumFlingVelocity()) {
                    childIndex = xVelocity < 0 ? childIndex + 1 : childIndex - 1;
                } else {
                    childIndex = (scrollX + childWidth / 2) / childWidth;
                }
                childIndex = Math.min(getChildCount() - 1, Math.max(childIndex, 0));
                smoothScrollBy(childIndex * childWidth - scrollX, 0);
                mVelocityTracker.clear();
                isFirstTouch = true;
                break;
        }

        lastX = x;
        lastY = y;
        return true;
    }

    void smoothScrollBy(int dx, int dy) {
        mScroller.startScroll(getScrollX(), getScrollY(), dx, dy, 500);
        invalidate();
    }

    @Override
    public void computeScroll() {
        if (mScroller.computeScrollOffset()) {
            scrollTo(mScroller.getCurrX(), mScroller.getCurrY());
            invalidate();
        }
    }

    @Override
    protected void onDetachedFromWindow() {
        super.onDetachedFromWindow();
        mVelocityTracker.recycle();
    }
}

呼叫程式碼：

 @Override
    public void showOutHVData(List<String> data1, List<String> data2, List<String> data3) {
        ListView listView1 = new ListView(getContext());
        ArrayAdapter<String> adapter1 = new ArrayAdapter<String>(getContext(), android.R.layout.simple_list_item_1, data1);
        listView1.setAdapter(adapter1);

        ListView listView2 = new ListView(getContext());
        ArrayAdapter<String> adapter2 = new ArrayAdapter<String>(getContext(), android.R.layout.simple_list_item_1, data2);
        listView2.setAdapter(adapter2);

        ListView listView3 = new ListView(getContext());
        ArrayAdapter<String> adapter3 = new ArrayAdapter<String>(getContext(), android.R.layout.simple_list_item_1, data3);
        listView3.setAdapter(adapter3);

        ViewGroup.LayoutParams params
                = new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
                ViewGroup.LayoutParams.MATCH_PARENT);

        mHorizontalEx.addView(listView1, params);
        mHorizontalEx.addView(listView2, params);
        mHorizontalEx.addView(listView3, params);
    }

其實外部攔截的主要思想都在於對onInterceptTouchEvent的重寫。

@Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        boolean intercepted = false;
        int x = (int) ev.getX();
        int y = (int) ev.getY();

        switch (ev.getAction()) {
            /*如果攔截了Down事件,則子類不會拿到這個事件序列*/
            case MotionEvent.ACTION_DOWN:
                lastXIntercept = x;
                lastYIntercept = y;
                intercepted = false;
                if (!mScroller.isFinished()) {
                    mScroller.abortAnimation();
                    intercepted = true;
                }
                break;
            case MotionEvent.ACTION_MOVE:
                final int deltaX = x - lastXIntercept;
                final int deltaY = y - lastYIntercept;
                /*根據條件判斷是否攔截該事件*/
                if (Math.abs(deltaX) > Math.abs(deltaY)) {
                    intercepted = true;
                } else {
                    intercepted = false;
                }
                break;
            case MotionEvent.ACTION_UP:
                intercepted = false;
                break;

        }
        lastXIntercept = x;
        lastYIntercept = y;
        return intercepted;
    }

這幾乎是一個實現外部攔截事件的模板，這裡一定不要在ACTION_DOWN 中返回 true,否則會讓子VIew沒有機會得到事件，因為如果在ACTION_DOWN的時候返回了 true,同一個事件序列ViewGroup的disPatchTouchEvent就不會在呼叫onInterceptTouchEvent方法了，如果不明白可以參考我的上一遍文章。
還有就是 在ACTION_UP中返回false，因為如果父控制元件攔截了ACTION_UP，那麼子View將得不到UP事件，那麼將會影響子View的 Onclick方法等。但這對父控制元件是沒有影響的，因為如果是父控制元件子ACITON_MOVE中就攔截了事件，他們UP事件必定也會交給它處理，因為有那麼一條定律叫做：父控制元件一但攔截了事件，那麼同一個事件序列的所有事件都將交給他處理。這條結論在我的上一篇文章中已經分析過。
最後就是在 ACTION_MOVE中根據需求決定是否攔截。

2、內部攔截法，解決橫豎衝突
內部攔截主要依賴於父控制元件的 requestDisallowInterceptTouchEvent方法，關於這個方法我的上篇文章其實已經分析過。他設定父控制元件的一個標誌（FLAG_DISALLOW_INTERCEPT）
這個標誌可以決定父控制元件是否攔截事件，如果設定了這個標誌則不攔截，如果沒設這個標誌，它就會呼叫父控制元件的onInterceptTouchEvent（）來詢問父控制元件是否攔截。但這個標誌對Down事件無效。
可以參考一下原始碼：
ViewGroup#dispatchTouchEvent

   // Handle an initial down.
            if (actionMasked == MotionEvent.ACTION_DOWN) {
                // Throw away all previous state when starting a new touch gesture.
                // The framework may have dropped the up or cancel event for the previous gesture
                // due to an app switch, ANR, or some other state change.
                cancelAndClearTouchTargets(ev);
                //清楚標誌
                resetTouchState();
            }

            // Check for interception.
            final boolean intercepted;
            if (actionMasked == MotionEvent.ACTION_DOWN
                    || mFirstTouchTarget != null) {
                    //標誌
                final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
                if (!disallowIntercept) {
                    intercepted = onInterceptTouchEvent(ev);
                    ev.setAction(action); // restore action in case it was changed
                } else {
                    intercepted = false;
                }
            } else {
                // There are no touch targets and this action is not an initial down
                // so this view group continues to intercept touches.
                intercepted = true;
            }

那麼我們如果想使用內部攔截法攔截事件。
第一步：
a、我們要重寫父控制元件的onInterceptTouchEvent，在ACTION_DOWN的時候返回false,負責的話子View呼叫requestDisallowInterceptTouchEvent也將無能為力。
b、還有就是其他事件的話都返回true,這樣就把能否攔截事件的權利交給了子View。

第二步:
在子View的dispatchTouchEvent中來決定是否讓父控制元件攔截事件。
a. 先要在MotionEvent.ACTION_DOWN:的時候使用mHorizontalEx2.requestDisallowInterceptTouchEvent(true);，負責的話，下一個事件到來時，就交給父控制元件了。
b. 然後在MotionEvent.ACTION_MOVE: 根據業務邏輯決定是否呼叫mHorizontalEx2.requestDisallowInterceptTouchEvent(false);來決定父控制元件是否攔截事件。
上程式碼：
HorizontalEx2.java

/**
 * Created by blueberry on 2016/6/20.
 * <p/>
 * 內部攔截
 * 和 ListViewEx配合使用
 */
public class HorizontalEx2 extends ViewGroup {

    private int lastX, lastY;
    private int childIndex;
    private Scroller mScroller;
    private VelocityTracker mVelocityTracker;

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

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

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

    private void init() {
        mScroller = new Scroller(getContext());
        mVelocityTracker = VelocityTracker.obtain();
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        int width = MeasureSpec.getSize(widthMeasureSpec);
        int widthMode = MeasureSpec.getMode(widthMeasureSpec);
        int height = MeasureSpec.getSize(heightMeasureSpec);
        int heightMode = MeasureSpec.getMode(heightMeasureSpec);

        int childCount = getChildCount();
        measureChildren(widthMeasureSpec, heightMeasureSpec);

        if (childCount == 0) {
            setMeasuredDimension(0, 0);
        } else if (widthMode == MeasureSpec.AT_MOST && heightMode == MeasureSpec.AT_MOST) {
            height = getChildAt(0).getMeasuredHeight();
            width = childCount * getChildAt(0).getMeasuredWidth();
            setMeasuredDimension(width, height);
        } else if (widthMode == MeasureSpec.AT_MOST) {
            width = childCount * getChildAt(0).getMeasuredWidth();
            setMeasuredDimension(width, height);
        } else {
            height = getChildAt(0).getMeasuredHeight();
            setMeasuredDimension(width, height);
        }
    }

    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        int leftOffset = 0;
        for (int i = 0; i < getChildCount(); i++) {
            View child = getChildAt(i);
            child.layout(l + leftOffset, t, r + leftOffset, b);
            leftOffset += child.getMeasuredWidth();
        }
    }

    /**
     * 不攔截Down事件，其他一律攔截
     * @param ev
     * @return
     */
    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        if (ev.getAction() == MotionEvent.ACTION_DOWN) {
            if (!mScroller.isFinished()) {
                mScroller.abortAnimation();
                return true;
            }
            return false;
        } else {
            return true;
        }
    }

    private boolean isFirstTouch = true;

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        int x = (int) event.getX();
        int y = (int) event.getY();
        mVelocityTracker.addMovement(event);
        ViewConfiguration configuration = ViewConfiguration.get(getContext());
        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
                if (!mScroller.isFinished()) {
                    mScroller.abortAnimation();
                }
                break;
            case MotionEvent.ACTION_MOVE:
                if (isFirstTouch) {
                    isFirstTouch = false;
                    lastY = y;
                    lastX = x;
                }
                final int deltaX = x - lastX;
                scrollBy(-deltaX, 0);
                break;
            case MotionEvent.ACTION_UP:
                isFirstTouch = true;
                int scrollX = getScrollX();
                mVelocityTracker.computeCurrentVelocity(1000, configuration.getScaledMaximumFlingVelocity());
                float mVelocityX = mVelocityTracker.getXVelocity();
                if (Math.abs(mVelocityX) > configuration.getScaledMinimumFlingVelocity()) {
                    childIndex = mVelocityX < 0 ? childIndex + 1 : childIndex - 1;
                } else {
                    childIndex = (scrollX + getChildAt(0).getWidth() / 2) / getChildAt(0).getWidth();
                }
                childIndex = Math.min(getChildCount() - 1, Math.max(0, childIndex));
                smoothScrollBy(childIndex*getChildAt(0).getWidth()-scrollX,0);
                mVelocityTracker.clear();
                break;
        }

        lastX = x;
        lastY = y;
        return true;
    }

    private void smoothScrollBy(int dx, int dy) {
        mScroller.startScroll(getScrollX(), getScrollY(), dx, dy,500);
        invalidate();
    }

    @Override
    public void computeScroll() {
        if(mScroller.computeScrollOffset()){
            scrollTo(mScroller.getCurrX(),mScroller.getCurrY());
            postInvalidate();
        }
    }

    @Override
    protected void onDetachedFromWindow() {
        super.onDetachedFromWindow();
        mVelocityTracker.recycle();
    }
}

ListViewEx.java


/**
 * Created by blueberry on 2016/6/20.
 * 內部攔截事件
 */
public class ListViewEx extends ListView {

    private int lastXIntercepted, lastYIntercepted;

    private HorizontalEx2 mHorizontalEx2;

    public ListViewEx(Context context) {
        super(context);
    }

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

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

    public HorizontalEx2 getmHorizontalEx2() {
        return mHorizontalEx2;
    }

    public void setmHorizontalEx2(HorizontalEx2 mHorizontalEx2) {
        this.mHorizontalEx2 = mHorizontalEx2;
    }

    /**
     * 使用 outter.requestDisallowInterceptTouchEvent();
     * 來決定父控制元件是否對事件進行攔截
     * @param ev
     * @return
     */
    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        int x = (int) ev.getX();
        int y = (int) ev.getY();
        switch (ev.getAction()) {
            case MotionEvent.ACTION_DOWN:
                mHorizontalEx2.requestDisallowInterceptTouchEvent(true);
                break;
            case MotionEvent.ACTION_MOVE:
                final int deltaX = x-lastYIntercepted;
                final int deltaY = y-lastYIntercepted;
                if(Math.abs(deltaX)>Math.abs(deltaY)){
                    mHorizontalEx2.requestDisallowInterceptTouchEvent(false);
                }
                break;
            case MotionEvent.ACTION_UP:
                break;
        }
        lastXIntercepted = x;
        lastYIntercepted = y;
        return super.dispatchTouchEvent(ev);
    }
}

呼叫程式碼：

 @Override
    public void showInnerHVData(List<String> data1, List<String> data2, List<String> data3) {

        ListViewEx listView1 = new ListViewEx(getContext());
        ArrayAdapter<String> adapter1 = new ArrayAdapter<String>(getContext(), android.R.layout.simple_list_item_1, data1);
        listView1.setAdapter(adapter1);
        listView1.setmHorizontalEx2(mHorizontalEx2);

        ListViewEx listView2 = new ListViewEx(getContext());
        ArrayAdapter<String> adapter2 = new ArrayAdapter<String>(getContext(), android.R.layout.simple_list_item_1, data2);
        listView2.setAdapter(adapter2);
        listView2.setmHorizontalEx2(mHorizontalEx2);

        ListViewEx listView3 = new ListViewEx(getContext());
        ArrayAdapter<String> adapter3 = new ArrayAdapter<String>(getContext(), android.R.layout.simple_list_item_1, data3);
        listView3.setAdapter(adapter3);
        listView3.setmHorizontalEx2(mHorizontalEx2);

        ViewGroup.LayoutParams params
                = new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
                ViewGroup.LayoutParams.MATCH_PARENT);

        mHorizontalEx2.addView(listView1, params);
        mHorizontalEx2.addView(listView2, params);
        mHorizontalEx2.addView(listView3, params);
    }

至此，2種攔截方法已經學習完畢，下面我們來學習如何解決同向滑動衝突。
其實和上面的2個例子思路是一樣的，只是用來判斷是否攔截的那塊邏輯不同而已。

下面的例子，是一個下拉重新整理的一個控制元件。

3、外部攔截解決同向滑動衝突
RefreshLayoutBase.java

package com.blueberry.sample.widget.refresh;

import android.content.Context;
import android.graphics.Color;
import android.util.AttributeSet;
import android.util.DisplayMetrics;
import android.util.Log;
import android.util.TypedValue;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.ViewGroup;
import android.view.WindowManager;
import android.widget.ProgressBar;
import android.widget.Scroller;
import android.widget.TextView;

import com.blueberry.sample.R;

/**
 * Created by blueberry on 2016/6/21.
 *
 *外部攔截(同向)
 *
 */
public abstract class RefreshLayoutBase<T extends View> extends ViewGroup {

    private static final String TAG = "RefreshLayoutBase";

    public static final int STATUS_LOADING = 1;
    public static final int STATUS_RELEASE_TO_REFRESH = 2;
    public static final int STATUS_PULL_TO_REFRESH = 3;
    public static final int STATUS_IDLE = 4;
    public static final int STATUS_LOAD_MORE =5;
    private static int SCROLL_DURATION =500;

    protected ViewGroup mHeadView;
    protected ViewGroup mFootView;
    private T contentView;
    private ProgressBar headProgressBar;
    private TextView headTv;
    private ProgressBar footProgressBar;
    private TextView footTv;

    private boolean isFistTouch = true;

    protected int currentStatus = STATUS_IDLE;
    private int mScreenWidth;
    private int mScreenHeight;
    private int mLastXIntercepted;
    private int mLastYIntercepted;
    private int mLastX;
    private int mLastY;
    protected int mInitScrollY = 0;
    private int mTouchSlop;

    protected Scroller mScoller;

    private OnRefreshListener mOnRefreshListener;

    public RefreshLayoutBase(Context context) {
        this(context, null);
    }

    public RefreshLayoutBase(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public RefreshLayoutBase(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        getScreenSize();
        initView();
        mScoller = new Scroller(context);
        mTouchSlop = ViewConfiguration.get(context).getScaledTouchSlop();
        setPadding(0, 0, 0, 0);
    }

    public void setContentView(T view) {
        addView(view, 1);
    }

    public OnRefreshListener getOnRefreshListener() {
        return mOnRefreshListener;
    }

    public void setOnRefreshListener(OnRefreshListener mOnRefreshListener) {
        this.mOnRefreshListener = mOnRefreshListener;
    }

    private void initView() {
        setupHeadView();
        setupFootView();
    }

    private void getScreenSize() {
        WindowManager wm = (WindowManager) getContext().getSystemService(Context.WINDOW_SERVICE);
        DisplayMetrics metrics = new DisplayMetrics();
        wm.getDefaultDisplay().getMetrics(metrics);
        mScreenWidth = metrics.widthPixels;
        mScreenHeight = metrics.heightPixels;
    }

    private int dp2px(int dp) {
        WindowManager wm = (WindowManager) getContext().getSystemService(Context.WINDOW_SERVICE);
        DisplayMetrics metrics = new DisplayMetrics();
        wm.getDefaultDisplay().getMetrics(metrics);
        return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, dp, metrics);
    }

    /**
     * 設定頭佈局
     */
    private void setupHeadView() {
        mHeadView = (ViewGroup) View.inflate(getContext(), R.layout.fresh_head_view, null);
        mHeadView.setBackgroundColor(Color.RED);
        headProgressBar = (ProgressBar) mHeadView.findViewById(R.id.head_progressbar);
        headTv = (TextView) mHeadView.findViewById(R.id.head_tv);
        /*設定 實際高度為 1/4 ，但內容區域只有 100dp*/
        ViewGroup.LayoutParams layoutParams = new ViewGroup.LayoutParams(LayoutParams.MATCH_PARENT, mScreenHeight / 4);
        mHeadView.setLayoutParams(layoutParams);
        mHeadView.setPadding(0, mScreenHeight / 4 - dp2px(100), 0, 0);
        addView(mHeadView);
    }

    /**
     * 設定尾佈局
     */
    private void setupFootView() {
        mFootView = (ViewGroup) View.inflate(getContext(), R.layout.fresh_foot_view, null);
        mFootView.setBackgroundColor(Color.BLUE);
        footProgressBar = (ProgressBar) mFootView.findViewById(R.id.fresh_foot_progressbar);
        footTv = (TextView) mFootView.findViewById(R.id.fresh_foot_tv);
        addView(mFootView);
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        int widthSize = MeasureSpec.getSize(widthMeasureSpec);
        int widthMode = MeasureSpec.getMode(widthMeasureSpec);
        int height = MeasureSpec.getSize(heightMeasureSpec);
        int heightMode = MeasureSpec.getMode(heightMeasureSpec);

        int finalHeight = 0;
        for (int i = 0; i < getChildCount(); i++) {
            View child = getChildAt(i);
            measureChild(child, widthMeasureSpec, heightMeasureSpec);
            finalHeight += child.getMeasuredHeight();
        }

        if (widthMode == MeasureSpec.AT_MOST && heightMode == MeasureSpec.AT_MOST) {
            widthSize = getChildAt(0).getMeasuredWidth();
            setMeasuredDimension(widthSize, finalHeight);
        } else if (widthMode == MeasureSpec.AT_MOST) {
            widthSize = getChildAt(0).getMeasuredWidth();
            setMeasuredDimension(widthSize, height);
        } else {
            setMeasuredDimension(widthSize, finalHeight);
        }

    }


    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        int topOffset = 0;
        for (int i = 0; i < getChildCount(); i++) {
            View child = getChildAt(i);
            child.layout(getPaddingLeft(), getPaddingTop() + topOffset, r, getPaddingTop() + child.getMeasuredHeight() + topOffset);
            topOffset += child.getMeasuredHeight();
        }
        mInitScrollY = mHeadView.getMeasuredHeight() + getPaddingTop();
        scrollTo(0, mInitScrollY);

    }

    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        boolean intercepted = false;
        int x = (int) ev.getX();
        int y = (int) ev.getY();
        switch (ev.getAction()) {
            case MotionEvent.ACTION_DOWN:
                mLastXIntercepted = x;
                mLastYIntercepted = y;
                break;
            case MotionEvent.ACTION_MOVE:
                final int deltaY = x - mLastYIntercepted;
                if (isTop() && deltaY > 0 && Math.abs(deltaY) > mTouchSlop) {
                    /*下拉*/
                    intercepted = true;
                }
                break;
            case MotionEvent.ACTION_UP:
                break;
        }
        mLastXIntercepted = x;
        mLastYIntercepted = y;
        return intercepted;
    }

    private void doRefresh() {
        Log.i(TAG, "doRefresh: ");
        if (currentStatus == STATUS_RELEASE_TO_REFRESH) {
            mScoller.startScroll(0, getScrollY(), 0, mInitScrollY - getScrollY(), SCROLL_DURATION);
            currentStatus = STATUS_IDLE;
        } else if (currentStatus == STATUS_PULL_TO_REFRESH) {
            mScoller.startScroll(0,getScrollY(),0,0-getScrollY(),SCROLL_DURATION);
            if (null != mOnRefreshListener) {
                currentStatus = STATUS_LOADING;
                mOnRefreshListener.refresh();
            }
        }
        invalidate();
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        int x = (int) event.getX();
        int y = (int) event.getY();
        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
                if (!mScoller.isFinished()) {
                    mScoller.abortAnimation();
                }
                mLastX = x;
                mLastY = y;
                break;
            case MotionEvent.ACTION_MOVE:
                if (isFistTouch) {
                    isFistTouch = false;
                    mLastX = x;
                    mLastY = y;
                }
                final int deltaY = y - mLastY;
                if (currentStatus != STATUS_LOADING) {
                    changeScrollY(deltaY);
                }
                break;
            case MotionEvent.ACTION_UP:
                isFistTouch = true;
                doRefresh();
                break;
        }

        mLastX = x;
        mLastY = y;
        return true;
    }

    private void changeScrollY(int deltaY) {
        Log.i(TAG, "changeScrollY: ");
        int curY = getScrollY();
        if (deltaY > 0) {
            /*下拉*/
            if (curY - deltaY > getPaddingTop()) {
                scrollBy(0, -deltaY);
            }
        } else {
            /*上拉*/
            if (curY - deltaY <= mInitScrollY) {
                scrollBy(0, -deltaY);
            }
        }

        curY = getScrollY();
        int slop = mInitScrollY / 2;
        if (curY > 0 && curY <=slop) {
            currentStatus = STATUS_PULL_TO_REFRESH;
        } else if (curY > 0 && curY >= slop) {
            currentStatus = STATUS_RELEASE_TO_REFRESH;
        }
    }

    @Override
    public void computeScroll() {
        if (mScoller.computeScrollOffset()) {
            scrollTo(mScoller.getCurrX(), mScoller.getCurrY());
            postInvalidate();
        }
    }

    /**
     * 載入完成呼叫這個方法
     */
    public void refreshComplete() {
        mScoller.startScroll(0, getScrollY(), 0, mInitScrollY - getScrollY(), SCROLL_DURATION);
        currentStatus = STATUS_IDLE;
        invalidate();
    }

    /**
     * 顯示 Footer
     */
    public void showFooter() {
        if(currentStatus==STATUS_LOAD_MORE) return ;
        currentStatus = STATUS_LOAD_MORE ;
        mScoller.startScroll(0, getScrollY(), 0, mFootView.getMeasuredHeight()
                , SCROLL_DURATION);
        invalidate();

    }


    /**
     * loadMore完成之後呼叫
     */
    public void footerComplete() {
        mScoller.startScroll(0, getScrollY(), 0, mInitScrollY - getScrollY(), SCROLL_DURATION);
        invalidate();
        currentStatus = STATUS_IDLE;
    }

    public interface OnRefreshListener {
        void refresh();
    }

    abstract boolean isTop();

    abstract boolean isBottom();

}

它是一個抽象類，需要編寫子類繼承isTop()和 isBottom()方法、
下面給出它的一個實現類：

package com.blueberry.sample.widget.refresh;

import android.content.Context;
import android.util.AttributeSet;
import android.widget.AbsListView;
import android.widget.ListView;

/**
 * Created by blueberry on 2016/6/21.
 *
 * RefreshLayoutBase 的一個實現類
 */
public class RefreshListView extends RefreshLayoutBase<ListView> {

    private static final String TAG = "RefreshListView";

    private ListView listView;
    private OnLoadListener loadListener;

    public RefreshListView(Context context) {
        super(context);
    }

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

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

    public ListView getListView() {
        return listView;
    }

    public void setListView(final ListView listView) {
        this.listView = listView;
        setContentView(listView);

        this.listView.setOnScrollListener(new AbsListView.OnScrollListener() {
            @Override
            public void onScrollStateChanged(AbsListView view, int scrollState) {
            }

            @Override
            public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {

                /*這裡存在一個bug: 當listView滑動到底部的時候，如果下拉也會出現footer
                * 這是因為，暫時還沒有想到如何判斷是下拉還是上拉。
                * 如果要解決此問題，我覺得應該重寫listView 的onTouchEvent來判斷手勢方向
                * 次模組主要解決豎向滑動衝突，故現將此問題放下。
                * */
                if (currentStatus == STATUS_IDLE
                        && getScrollY() <= mInitScrollY && isBottom()
                        ) {
                    showFooter();
                    if (null != loadListener) {
                        loadListener.onLoadMore();
                    }
                }

            }
        });
    }

    public OnLoadListener getLoadListener() {
        return loadListener;
    }

    public void setLoadListener(OnLoadListener loadListener) {
        this.loadListener = loadListener;
    }

    @Override
    boolean isTop() {
        return listView.getFirstVisiblePosition() == 0
                && getScrollY() <= mHeadView.getMeasuredHeight();
    }

    @Override
    boolean isBottom() {
        return listView.

 
 
              
           
              
              
            
            相關推薦
			   
            
            
            
 

    

    
    android-Ultra-Pull-To-Refresh重新整理框架與viewpager滑動衝突解決方案
      
							
							
							文章概述：



問題描述：

liaohuqiu 開源的 android-Ultra-Pull-To-Refresh 下拉重新整理框架，在使用時,會經常遇到巢狀banner的使用場景，即：子ViewGroup巢狀ViewPager使用，例如：



<c 

  
 

    

    
    【朝花夕拾】Android自定義View篇之（七）Android事件分發機制（下）滑動衝突解決方案總結
      前言
       轉載請宣告，轉自【https://www.cnblogs.com/andy-songwei/p/11072989.html】，謝謝！
       前面兩篇文章，花了很大篇幅講解了Android的事件分發機制的 

  
 

    

    
    Android滑動衝突解決方法
      
                敘述

滑動衝突可以說是日常開發中比較常見的一類問題，也是比較讓人頭疼的一類問題，尤其是在使用第三方框架的時候，兩個原本完美的控制元件，組合在一起之後，忽然發現整個世界都不好了。

關於滑動衝突

滑動衝突分類###

滑動衝突，總的來說就是兩類。


	同方向滑動衝突
	比 

  
 

    

    
    android-----滑動衝突解決案例
      
                
        之前的幾篇部落格，我測試了View事件分發機制中的一些知識點，我們理解事件分發機制的目的就是為了能夠更好了知道View中事件的傳遞過程進而能夠對於滑動衝突有針對性的解決措施，今天我們通過一個翻頁例項來學習下滑動處理的方式之一-----外部攔截法；
      

  
 

    

    
    Android滑動衝突解決方式(下拉重新整理上拉載入更多,適配RecyclerView/ListView/ScrollView)
      

    @Override
    public boolean judgeIntercept(float curInterceptY, float lastInterceptY, boolean isHeaderShow, boolean isFooterShow, boolean allowLoadM 

  
 

    

    
    ScrollView ViewPager巢狀導致滑動衝突解決方案
      
								
								            
						
                
開發是遇到類似淘寶產品介紹的介面

存在srollView也ViewPager滑動衝突的問題，使用者體驗不好。
於是對srollView做了自定義控制元件，解決了該問題，處理思想：如果滑動左右滑動大於 

  
 

    

    
    android滑動衝突的解決方案
      
							
							
							

一、前言 
Android 中解決滑動的方案有2種：外部攔截法 和內部攔截法。 
滑動衝突也存在2種場景: 橫豎滑動衝突、同向滑動衝突。 
所以我就寫了4個例子來學習如何解決滑動衝突的，這四個例子分別為: 外部攔截法解決橫豎衝突、外部攔截法解決同向衝突、內部 

  
 

    

    
    Android PtrFrameLayout 與RecyclerView滑動衝突解決方法
       
 
 原文地址：https://blog.csdn.net/Simon_Crystin/article/details/80926795 
   
 1.背景 2.主要程式碼邏輯 2.1 父View程式碼（PtrFrameLayout） 2.2 子View關鍵程式碼（RecyclerView）  

  
 

    

    
    ScrollView與viewpager滑動事件衝突,與點選事情衝突解決方案
       
 
 在產品適配的時候我加了ScrollView,但是產品提出了一個向上輪播需求 首先把豎直向上的viewpager粘出來: 
  
  
 package com.cfiigroup.zhehui.hepaidai.view;

import android.view.MotionEvent;
impo 

  
 

    

    
    Android ScrollView巢狀Banner於RecyclerView滑動衝突解決
       
 
 首先是佈局 
 <?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http:/ 

  
 

    

    
    Android 滑動衝突的解決方法
      
                一、常見的滑動衝突場景

場景1——外部滑動方向和內部滑動方向不一致，如：ViewPager中有多個fragment，而fragment中有ListView，這時ViewPager可以左右滑動，而ListView可以上下滑動，這就造成了滑動衝突。注意：這只是舉個例子說明一下場 

  
 

    

    
    webview輪播圖與Android滑動衝突的解決辦法
      
                在Android中我們經常需要左右滑動，其中內嵌的web頁面也有滑動動作。輪播圖舉例：需要左右翻頁時，會觸發Android中的ViewPager導致翻頁到另一個頁面輪播圖翻頁翻不動，或失效。但是由於安卓是父，而Web是子。在Web中不論你做什麼處理，都管不了父視窗的事情，所以 

  
 

    

    
    【安卓】android第三方庫導致support版本衝突解決方案
      
							
							
							問題

升級compileSdk版本到26，同時修改了support包的版本，報錯


  all com.android.support libraries must use the exact same version specification(mixin 

  
 

    

    
    Android控制元件-ScrollView 和WebView之見滑動衝突解決
      
                
   需求：
              最近在做一個webView載入網頁的頁面，最外層是一個scrollView，因為還有標題等其他資料是需要單獨獲取載入，所以scrollview中是包含一個其他資訊的頭部佈局和一個載入網頁資訊的WebView，當滑動的時候，頭部和We 

  
 

    

    
    android 架包衝突解決方案
      
								
								            
						
                
作為一名剛學android五個月的小白，之前無論學習基礎，還是看一些培訓機構的教學專案，裡面都是用listView來展示資料。
下午心血來潮，便想學習一下recycleView，則需要匯入一些其他人的 

  
 

    

    
    【轉載】Android外掛化常見衝突解決方案
      
                文章轉自：https://blog.csdn.net/xiangzhihong8/article/details/80278068在Android元件化和外掛化的過程中，經常會遇到狠多的問題，如常見的包依賴衝突，資原始檔依賴衝突等問題，當然，在資原始檔上面，一些元件化框架已為 

  
 

    

    
    android tv跑馬燈效果與HorizontalScrollView焦點衝突解決方案
      
								
								            
						
                
我整個移動的view是繼承了HorizontalScrollView,但是發現我遙控器向右移動的時候,view沒焦點了,我view裡面有一個跑馬燈效果,就是在有焦點的時候才出現跑馬燈,沒焦點的時候隱藏 

  
 

    

    
    Android ScrollView與ListView,GridView共存衝突解決方案
      
                

我們在真實專案中通常會遇到ListView或者GridView巢狀在ScrollView中問題。但是做的時候會發現，一旦兩者進行巢狀，即會發生衝突。得不到我們希望的效果。由於ListView和GridView本身都繼承於ScrollView，一旦在ScrollView中巢 

  
 

    

    
    android下拉重新整理和listview衝突解決方案
      
								
								            
						
                


相關文章：


常見的下拉重新整理都是帶有一些自定義的listview、gridview和webview，我們導包直接用就行了，但是為什麼他們要自定義一些常用的控制元件呢？直接在外邊套用不行嗎？類 

  
 

    

    
    android ListView/GridView與ScrollView巢狀的滑動衝突解決
      
							
							
							首先說一下思路，主要就是去掉子ListView/GridView的內容全部顯示出來，使其不需要滑動。然後用ScrollView將其包裹在其中，接管滑動事件，達到整個佈局的滑動效果。

實際做法需要將ListView/GridView 與 ScrollView 覆