Android View的事件分发机制与滑动冲突解决方案

在Android开发中,如果是一些简单的布局,都很容易搞定,但是一旦涉及到复杂的页面,特别是为了兼容小屏手机而使用了ScrollView以后,就会出现很多滑动事件的冲突,最经典的就是ScrollView中嵌套了ListView。今天主要总结一下这方面的知识点,也当作以后复习的笔记,本文主要讲述以下几点:

  • View的事件分发机制
  • 事件滑动冲突的思路及方法
  • ScrollView里面嵌套ViewPager滑动冲突问题
  • ViewPager里面嵌套ViewPager滑动冲突问题
  • Scrollview里面嵌套Listview滑动冲突问题

View的事件分发机制

关于View的事件分发机制讲解网上一搜一大堆,所以本文不细讲,而是让你理解主要的运行机制,当然也不是只是自己描述一下就结束了,会提供具体的博客参考,指引你去更详细的了解。
View的事件分发机制说白了就是点击事件的传递,也就是一个Down事件,若干个Move事件,一个Up事件构成的事件序列的传递。
下面讲述一下View事件分发机制涉及的几个方法

  • boolean dispatchTouchEcent(MotionEvent ev)
  • boolean onInterceptTouchEvent(MotionEvent event)
  • boolean onTouchEvent(MotionEvent event)
  • public void requestDisallowInterceptTouchEvent(boolean disallowIntercept)

前三个方法的关系用下面伪代码表示一下:

public boolean dispatchTouchEvent(MotionEvent ev){
    boolean consum = false;
    if(onInterceptTouchEvent(ev)){
        consum = onTouchEvent(ev);
    }else{
        consum = child.dispatchTouchEvent(ev);
    }

    return consum;
}

根据下面这幅图逐个简单介绍下上述的四个方法:

Paste_Image.png
  • dispatchTouchEcent:
    只要事件传递到了当前View,那么dispatchTouchEcent方法就一定会被调用,主要是用来分发事件的。返回结果表示是否消耗当前事件。
    ture:事件就此消费,不会继续往别的地方传了,事件终止。
    false:则回传给父View的onTouchEvent事件处理。
  • onInterceptTouchEvent:
    在dispatchTouchEcent方法内部调用此方法,用来判断是否拦截某个事件。如果当前View拦截了某个事件,那么在这同一个事件序列中,此方法不会再次被调用(需要注意的是ViewGroup才有这个方法,View没有onInterceptTouchEvent这个方法)。返回结果表示是否拦截当前事件。
    true:拦截事件,则交给它的 onTouchEvent 来处理。
    false:不拦截该事件,传递给子 view ,由子 view 的 dispatchTouchEvent 再来开始这个事件的分发。
  • onTouchEvent:
    在dispatchTouchEcent方法内调用此方法,用来处理事件。返回结果表示是否处理当前事件。
    true:表示消费该事件。
    false:表示不处理,那么在同一个事件序列里面,当前View无法再收到后续的事件。
  • requestDisallowInterceptTouchEvent:
    该方法中的参数disallowIntercept的意思就是childView告诉父容器要不要进行拦截。
    true :告诉所有父控件不要拦截,事件交由childrenView处理;
    false:告诉所有父控件拦截。在父控件的onInterceptTouchEvent()中可能类似这样的处理。

这里总结一下:(结合下图看)
事件总是从上往下进行分发,即先到达Activity,再到达ViewGroup,再到达子View,如果没有任何视图消耗事件的话,事件会顺着路径往回传递。

app1.png

  1. 事件从Activity.dispatchTouchEvent()开始传递,只要没有被停止或拦截,从最上层的View(ViewGroup)开始一直往下(子View)传递。子View 可以通过onTouchEvent()对事件进行处理。
  2. 事件由父View(ViewGroup)传递给子View,ViewGroup 可以通过onInterceptTouchEvent()对事件做拦截,停止其往下传递。
  3. 如果事件从上往下传递过程中一直没有被停止,且最底层子View 没有消费事件,事件会反向往上传递,这时父View(ViewGroup)可以进行消费,如果还是没有被消费的话,最后会到Activity 的onTouchEvent()函数。
  4. 如果View 没有对ACTION_DOWN 进行消费,之后的其他事件不会传递过来。
  5. OnTouchListener 优先于onTouchEvent()对事件进行消费。
    如果还不理解这几个方法的用处,请参考博文图解 Android 事件分发机制,一定要有耐心仔细看,相信看完之后你会相信事件并没有白白浪费的。

滑动冲突解决方案

滑动冲突的基本形式分为两种,其他复杂的滑动冲突都是由这两种基本形式演变而来:

  1. 外部滑动方向与内部方向不一致。
  2. 外部滑动方向与内部方向一致。

第一种可以理解为ScrollView 嵌套ViewPager,第二种可以理解为ViewPager嵌套ViewPager,稍后提供具体解决方案。
根据《Android开发艺术探索》讲述滑动冲突的拦截方法有两种:

外部拦截法

从父View着手,重写onInterceptTouchEvent方法,在父View需要拦截的时候拦截,不需要则不拦截返回false。其伪代码如下:

public boolean onInterceptTouchEvent(MotionEvent event) {
    boolean intercepted = false;
    int x = (int)event.getX();
    int y = (int)event.getY();
    switch (event.getAction()) {
        case MotionEvent.ACTION_DOWN: {
            intercepted = false;
           break;
       }
       case MotionEvent.ACTION_MOVE: {
           if (满足父容器的拦截要求) {
                intercepted = true;
           } else {
                intercepted = false;
           }
           break;
       }
       case MotionEvent.ACTION_UP: {
           intercepted = false;
           break;
       }
       default:
           break;
       }
            mLastXIntercept = x;
            mLastYIntercept = y;
            return intercepted;
}

在这里,首先down事件父容器必须返回false ,因为若是返回true,也就是拦截了down事件,那么后续的move和up事件就都会传递给父容器,子元素就没有机会处理事件了。其次是up事件也返回了false,一是因为up事件对父容器没什么意义,其次是因为若事件是子元素处理的,却没有收到up事件会让子元素的onClick事件无法触发。

内部拦截法

从子View入手,重写子元素的dispatchTouchEvent方法,父View先不要拦截任何事件,所有的 事件传递给 子View,如果子View需要此事件就消费掉,不需要此事件的话就通过requestDisallowInterceptTouchEvent方法交给父View处理。伪代码如下:

@Override
 public boolean dispatchTouchEvent(MotionEvent event) {
     int x = (int) event.getX();
     int y = (int) event.getY();

     switch (event.getAction()) {
     case MotionEvent.ACTION_DOWN: {
         parent.requestDisallowInterceptTouchEvent(true);
         break;
     }
     case MotionEvent.ACTION_MOVE: {
         int deltaX = x - mLastX;
         int deltaY = y - mLastY;
         if (父容器需要此类点击事件) {
             parent.requestDisallowInterceptTouchEvent(false);
         }
         break;
     }
     case MotionEvent.ACTION_UP: {
         break;
     }
     default:
         break;
     }

     mLastX = x;
     mLastY = y;
     return super.dispatchTouchEvent(event);
 }

然后修改父容器的onInterceptTouchEvent方法:

@Override
 public boolean onInterceptTouchEvent(MotionEvent event) {

     int action = event.getAction();
     if (action == MotionEvent.ACTION_DOWN) {
         return false;
     } else {
         return true;
     }
 }

ScrollView里面嵌套ViewPager滑动冲突问题

  • 外部拦截法
    如上面所述,从 父ViewScrollView着手,重写 OnInterceptTouchEvent方法,在上下滑动的时候拦截事件,在左右滑动的时候不拦截事件,返回 false,这样确保子View 的dispatchTouchEvent方法会被调用,代码如下:
public class VerticalScrollView extends ScrollView {

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

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

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

    @TargetApi(21)
    public VerticalScrollView(Context context, AttributeSet attrs, int defStyleAttr, int
            defStyleRes) {
        super(context, attrs, defStyleAttr, defStyleRes);
    }

    private float mDownPosX = 0;
    private float mDownPosY = 0;

    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        final float x = ev.getX();
        final float y = ev.getY();

        final int action = ev.getAction();
        switch (action) {
            case MotionEvent.ACTION_DOWN:
                mDownPosX = x;
                mDownPosY = y;

                break;
            case MotionEvent.ACTION_MOVE:
                final float deltaX = Math.abs(x - mDownPosX);
                final float deltaY = Math.abs(y - mDownPosY);
                // 这里是够拦截的判断依据是左右滑动,读者可根据自己的逻辑进行是否拦截
                if (deltaX > deltaY) {
                    return false;
                }
        }

        return super.onInterceptTouchEvent(ev);
    }
}
  • 内部拦截法
    如上面上述,通过requestDisallowInterceptTouchEvent(true)方法来影响父View是否拦截事件,我们通过重写ViewPager的 dispatchTouchEvent()方法,在左右滑动的时候请求父View ScrollView不要拦截事件,其他的时候拦截事件,代码如下:
public class MyViewPager extends ViewPager {

    private static final String TAG = "MyViewPager ";

    int lastX = -1;
    int lastY = -1;

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

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

    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        int x = (int) ev.getRawX();
        int y = (int) ev.getRawY();
        int dealtX = 0;
        int dealtY = 0;

        switch (ev.getAction()) {
            case MotionEvent.ACTION_DOWN:
                dealtX = 0;
                dealtY = 0;
                // 保证子View能够接收到Action_move事件
                getParent().requestDisallowInterceptTouchEvent(true);
                break;
            case MotionEvent.ACTION_MOVE:
                dealtX += Math.abs(x - lastX);
                dealtY += Math.abs(y - lastY);
                Log.i(TAG, "dealtX:=" + dealtX);
                Log.i(TAG, "dealtY:=" + dealtY);
                // 这里是够拦截的判断依据是左右滑动,读者可根据自己的逻辑进行是否拦截
                if (dealtX >= dealtY) {
                    getParent().requestDisallowInterceptTouchEvent(true);
                } else {
                    getParent().requestDisallowInterceptTouchEvent(false);
                }
                lastX = x;
                lastY = y;
                break;
            case MotionEvent.ACTION_CANCEL:
                break;
            case MotionEvent.ACTION_UP:
                break;

        }
        return super.dispatchTouchEvent(ev);
    }
}

ViewPager里面嵌套ViewPager滑动冲突问题

内部拦截法:
从子View ViewPager着手,重写 子View的 dispatchTouchEvent方法,在子 View需要拦截的时候进行拦截,否则交给父View处理,代码如下:

public class ChildViewPager extends ViewPager {

    private static final String TAG = "ChildViewPager ";
    public ChildViewPager(Context context) {
        super(context);
    }

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

    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        int curPosition;

        switch (ev.getAction()) {
            case MotionEvent.ACTION_DOWN:
                getParent().requestDisallowInterceptTouchEvent(true);
                break;
            case MotionEvent.ACTION_MOVE:
                curPosition = this.getCurrentItem();
                int count = this.getAdapter().getCount();
                Log.i(TAG, "curPosition:=" +curPosition);
                // 当当前页面在最后一页和第0页的时候,由父亲拦截触摸事件
                if (curPosition == count - 1|| curPosition==0) {
                    getParent().requestDisallowInterceptTouchEvent(false);
                } else {//其他情况,由孩子拦截触摸事件
                    getParent().requestDisallowInterceptTouchEvent(true);
                }

        }
        return super.dispatchTouchEvent(ev);
    }
}

Scrollview里面嵌套Listview滑动冲突问题

ScrollView里面嵌套ListView,通常会出现以下两个问题:

  • ListView的高度显示问题,常见的问题就是只显示一行;
  • ScrollView和ListView都有上下滑动事件,放在一起会存在滑动冲突。

常用方案有如下三种:

  1. 自定义ListView
public class ListViewForScroll extends ListView
{
    public ListViewForScroll(Context context)
    {
        super(context);
    }
    public ListViewForScroll(Context context, AttributeSet attrs)
    {
        super(context, attrs);
    }
    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec)
    {
        intexpandSpec = MeasureSpec.makeMeasureSpec(Integer.MAX_VALUE >> 2,    
                  MeasureSpec.AT_MOST);
        super.onMeasure(widthMeasureSpec, expandSpec);
    }
}

主要就是重载了onMeasure方法,改变了heightMeasureSpec。这里widthMeasureSpec和heightMeasureSpec用了32位的int作为参数,高2位代表模式,有三种UNSPECIFIED、EXACTLY、AT_MOST,这是自定义View的基础知识。低30位代表数值。
MeasureSpec.makeMeasureSpec函数中第一个参数是高度的值,第二个参数是模式,makeMeasureSpec则是把模式和值合成为一个int值,这里赋给了高度。
Integer.MAX_VALUE >> 2是int类型取30位时的最大整数,即Integer.MAX_VALUE是int的最大32位值,再右移2位,就是30位,同样是最大值,只不过是30位的最大值,所以在模式上也只能选择MeasureSpec.AT_MOST。最终这个ListView的显示高度会是其能显示出来的最大值,所有的条目都会显示出来。
优点:写法简单,不影响ListView使用。
缺点:
i. 由于高度设置成最大值,所有条目都会进行绘制,只是有些条目会在屏幕之外。举个例子,我传递的数据有20条,但是屏幕只够显示10条,此时用自定义的ListView会调用20次getView把所有条目都绘制出来,完全放弃了ListView的复用机制,跟直接写布局没有什么区别了,会造成页面加载速度缓慢的问题。
ii. ListView高度必须设置成match_parent。

  1. 动态测量ListView高度
public static void setListViewHeightBasedOnChildren(ListView listView) {
    ListAdapter listAdapter = listView.getAdapter();
    if (listAdapter == null) {
        return;
    }
    int totalHeight = 0;
    for (int i = 0; i < listAdapter.getCount(); i++) {
        View listItem = listAdapter.getView(i, null, listView);
        listItem.measure(0, 0);
        totalHeight += listItem.getMeasuredHeight();
    }
    ViewGroup.LayoutParams params = listView.getLayoutParams();
    params.height = totalHeight
            + (listView.getDividerHeight() * (listAdapter.getCount() - 1));
    listView.setLayoutParams(params);
}

这里就是去获取每个条目的View高度,然后所有子View高度相加得到总高度,并设置给ListView的LayoutParams。
优点:能够实现功能需求。
缺点:
i. 每个条目的布局只能用LinearLayout,而不能用RelativeLayout,因为LinearLayout重写了onMeasure方法,才能调用listItem.measure(0, 0)这句,而其他布局没有。
ii. ListView高度必须设置成match_parent。
iii. 在ListView设置Adaper和调用notifyDataSetChanged时候都要调用该方法。
iv. 由于高度设置成最大值,所有条目都会进行绘制,跟第一个方法“自定义ListView”存在同样的问题。

  1. 第三是自定义LinearLayout模拟ListView。
    public class LinearLayoutListView extends LinearLayout
    {
    private BaseAdapter adapter;
    private MyOnItemClickListener onItemClickListener;
    boolean footerViewAttached = false;
    private View footerview;
    public LinearLayoutListView(Context context)
    {
    super(context);
    initAttr(null);
    }

         public LinearLayoutListView(Context context, AttributeSet attrs)
         {
             super(context, attrs);
             initAttr(attrs);
         }
    
         public void initAttr(AttributeSet attrs)
         {
             setOrientation(VERTICAL);
         }
    
         /**
          * 初始化footerview
          *
          * @param footerView
          */
         public void initFooterView(final View footerView)
         {
             this.footerview = footerView;
         }
    
         /**
          * 设置footerView监听事件
          *
          * @param onClickListener
          */
         public void setFooterViewListener(OnClickListener onClickListener)
         {
             this.footerview.setOnClickListener(onClickListener);
         }
    
         public BaseAdapter getAdapter()
         {
             return adapter;
         }
    
         /**
          * 设置adapter并模拟listview添加????数据
          *
          * @param adpater
          */
         public void setAdapter(BaseAdapter adpater)
         {
             this.adapter = adpater;
             removeAllViews();
             if (footerViewAttached)
                 addView(footerview);
             notifyChange();
         }
    
         /**
          * 设置条目监听事件
          *
          * @param onClickListener
          */
         public void setOnItemClickListener(MyOnItemClickListener onClickListener)
         {
             this.onItemClickListener = onClickListener;
         }
    
         /**
          * 没有下一页了
          */
         public void noMorePages()
         {
             if (footerview != null && footerViewAttached)
             {
                 removeView(footerview);
                 footerViewAttached = false;
             }
         }
    
         /**
          * 可能还有下一??
          */
         public void mayHaveMorePages()
         {
             if (!footerViewAttached && footerview != null)
             {
                 addView(footerview);
                 footerViewAttached = true;
             }
         }
    
         /**
          * 通知更新listview
          */
         public void notifyChange()
         {
             int count = getChildCount();
             if (footerViewAttached)
             {
                 count--;
             }
             LayoutParams params = new LayoutParams(LayoutParams.FILL_PARENT, LayoutParams.WRAP_CONTENT);
             for (int i = count; i < adapter.getCount(); i++)
             {
                 final int index = i;
                 final LinearLayout layout = new LinearLayout(getContext());
                 layout.setLayoutParams(params);
                 layout.setOrientation(VERTICAL);
                 View v = adapter.getView(i, null, null);
                 v.setOnClickListener(new OnClickListener()
                 {
                     @Override
                     public void onClick(View v)
                     {
                         if (onItemClickListener != null)
                         {
                             onItemClickListener.onItemClick(LinearLayoutListView.this, layout, index,
                                     adapter.getItem(index));
                         }
                     }
                 });
                 ImageView imageView = new ImageView(getContext());
                 imageView.setBackgroundResource(R.color.background);
                 imageView.setLayoutParams(params);
                 layout.addView(v);
                 layout.addView(imageView);
                 addView(layout, index);
             }
         }
         public static interface MyOnItemClickListener
         {
             public void onItemClick(ViewGroup parent, View view, int position, Object o);
         }
     }
    

生硬的实现了ListView的基础功能,但是ListView的复用机制完全没有,跟直接写布局有何区别。
优点:能够实现功能需求。
缺点:
i. ListView高度要设置成match_parent
ii. 由于高度设置成最大值,所有条目都会进行绘制,跟“自定义ListView”存在同样的问题。

另外推荐解决滑动冲突方案的博文:
【Android】ListView、RecyclerView、ScrollView里嵌套ListView 相对优雅的解决方案:NestFullListView

推荐阅读更多精彩内容