Android的事件分发和处理方式

　　对android开发有一定了解的同学一定或多或少知道android的触摸事件分发，整个事件的分发消耗流程都可以通过看源码理解，下面通过讲解demo帮助加深事件分发的理解和在实战中的应用。首先直接上demo截图：

结合支付宝和微信首页巩固Android事件分发机制

　　demo布局

　　整个首页布局是这样的，最外层是ViewPager，里面包含四个子功能，每个子功能的视图都是一个Fragment。“功能1”里的列表项是一个GridView，此gridview外层是带有LinearLayout的ScrollView。

　　布局如下

结合支付宝和微信首页巩固Android事件分发机制

　　难点分析和讲解

　　一、GridView高度问题

　　二、长按GridView某一项可以替换位置，最后一项“更多”不参与滑动与替换位置

　　三、GridView长按并滑动某一项时，滑动过程中与ScrollView和ViewPager冲突问题

　　四、滑动GridView中某一项时，当滑动到顶部时ScrollView要能向下滚动；手指滑动到底部时要能项上滚动

　　解决问题

　　解决问题一

　　为了解决这一系列问题，我需要重写DragGridView继承GridView，第一步需要让DragGridView的每一项item占满整个视图，而gridview默认是限定高度的，解决办法是重写onMeasure，修改测量高度方法，如下

Java代码
  1. @Override  
  2. protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  
  3.     int expandSpec = View.MeasureSpec.makeMeasureSpec(  
  4.             Integer.MAX_VALUE >> 2, View.MeasureSpec.AT_MOST);//1.精确模式（MeasureSpec.EXACTLY） 2.最大模式（MeasureSpec.AT_MOST） 3.未指定模式（MeasureSpec.UNSPECIFIED）  
  5.     super.onMeasure(widthMeasureSpec, expandSpec);  
  6. }  

　　解决问题二

　　现在我们需要长按GridView某一项可以替换位置，思路是首先需要捕捉到长按事件，那么怎么算长按事件呢？手指快速的从item上划是不算的，手指按下然后很快离开这是点击事件也不能算长按。只有手指在item上按下并且停留在item上一定时间才能算长按。有了思路，下面看关键的几处代码：

Java代码
  1. private Handler mHandler = new Handler();  
  2. //用来处理是否为长按的Runnable  
  3. private Runnable mLongClickRunnable = new Runnable() {  
  4.   
  5.     @Override  
  6.     public void run() {  
  7.     //todo  
  8.     }  
  9. };  
  10.   
  11. @Override  
  12. public boolean dispatchTouchEvent(MotionEvent ev) {  
  13.     switch(ev.getAction()){  
  14.         case MotionEvent.ACTION_DOWN:  
  15.             //使用Handler延迟dragResponseMS执行mLongClickRunnable  
  16.             mHandler.postDelayed(mLongClickRunnable, dragResponseMS);  
  17.             break;  
  18.         case MotionEvent.ACTION_MOVE:  
  19.             //如果我们在按下的item上面移动，只要不超过item的边界我们就不移除mRunnable  
  20.             if(!isTouchInItem(mStartDragItemView, moveX, moveY)){  
  21.                 mHandler.removeCallbacks(mLongClickRunnable);  
  22.                 mHandler.removeCallbacks(mScrollRunnable);  
  23.             }  
  24.   
  25.             break;  
  26.         case MotionEvent.ACTION_UP:  
  27.         case MotionEvent.ACTION_CANCEL:  
  28.             mHandler.removeCallbacks(mLongClickRunnable);  
  29.             break;  
  30.     }  
  31.     return super.dispatchTouchEvent(ev);  
  32. }  

　　解析： 定义一个Handler，重写ViewGroup(这里即DragGridView)分发事件方法dispatchTouchEvent()，在接受到ACTION DOWN事件时handler向消息队列会延迟发送一条消息，延迟时间就是长按时间的阀值，当接受到消息时说明长按事件已成立，如果手指在消息延迟期间滑走或移出则取消消息。

　　有了长按事件如何滑动某一条item呢？如何替换两个item位置呢？

　　这里的解决思路是，当其中的某项假设是item1接收到长按事件后，先隐藏item1，在item1的位置上新建一个和item1长相位置都一样view假设叫它litem，手指滑动时对litem跟随滑动，接着重点来了，当手指滑动到item2区域后发出一个替换事件。这样我们就成功将两个item替换了位置并且用户体验比较好，代码片段如下：

Java代码
  1.  //用来处理是否为长按的Runnable  
  2. private Runnable mLongClickRunnable = new Runnable() {  
  3.   
  4.     @Override  
  5.     public void run() {  
  6.         if (onDragStartListener != null) {  
  7.             onDragStartListener.onDragStart();  
  8.         }  
  9.         isDrag = true; //设置可以拖拽  
  10.         mVibrator.vibrate(50); //震动一下  
  11.         mStartDragItemView.setVisibility(View.INVISIBLE);//隐藏该item  
  12.         //根据我们按下的点显示item镜像  
  13.         createDragImage(mDragBitmap, mDownX, mDownY);  
  14.   
  15.   
  16.     }  
  17. };  
  18. /** 
  19.  * 设置替换回调接口 
  20.  * @param onChangeListener 
  21.  */  
  22. public void setOnChangeListener(OnChangeListener onChangeListener){  
  23.     this.onChangeListener = onChangeListener;  
  24. }  
  25. /** 
  26.  * 创建拖动的镜像 
  27.  * @param bitmap 
  28.  * @param downX 
  29.  *          按下的点相对父控件的X坐标 
  30.  * @param downY 
  31.  *          按下的点相对父控件的X坐标 
  32.  */  
  33. private void createDragImage(Bitmap bitmap, int downX , int downY){  
  34.     mWindowLayoutParams = new WindowManager.LayoutParams();  
  35.     mWindowLayoutParams.format = PixelFormat.TRANSLUCENT; //图片之外的其他地方透明  
  36.     mWindowLayoutParams.gravity = Gravity.TOP | Gravity.LEFT;  
  37.     mWindowLayoutParams.x = downX - mPoint2ItemLeft + mOffset2Left;  
  38.     mWindowLayoutParams.y = downY - mPoint2ItemTop + mOffset2Top - mStatusHeight;  
  39.     mWindowLayoutParams.alpha = 0.55f; //透明度  
  40.     mWindowLayoutParams.width = WindowManager.LayoutParams.WRAP_CONTENT;  
  41.     mWindowLayoutParams.height = WindowManager.LayoutParams.WRAP_CONTENT;  
  42.     mWindowLayoutParams.flags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE  
  43.             | WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE ;  
  44.   
  45.     mDragImageView = new ImageView(getContext());  
  46.     mDragImageView.setImageBitmap(bitmap);  
  47.     mWindowManager.addView(mDragImageView, mWindowLayoutParams);  
  48. }  
  49. @Override  
  50. public boolean onTouchEvent(MotionEvent ev) {  
  51.     if(isDrag && mDragImageView != null){  
  52.         switch(ev.getAction()){  
  53.             case MotionEvent.ACTION_MOVE:  
  54.                 moveX = (int) ev.getX();  
  55.                 moveY = (int) ev.getY();  
  56.                 moveRawY = (int) ev.getRawY();  
  57.                 //拖动item  
  58.                 onDragItem(moveX, moveY);  
  59.                 break;  
  60.             case MotionEvent.ACTION_UP:  
  61.                 onStopDrag();  
  62.                 isDrag = false;  
  63.                 break;  
  64.         }  
  65.         return true;  
  66.     }  
  67.     return super.onTouchEvent(ev);  
  68. }  

　　解析：在接收到长按事件后会调用 createDragImage(mDragBitmap, mDownX, mDownY)方法，这是为了在item的位置上创建一个长相一样的view，当手指滑动时在onTouch()方法中监听move事件处理view的位置

　　解决问题三

　　为题三的解决比较简单，当gridview接收到长按事件后，处理ViewPager和ScrollView的方法一样requestDisallowInterceptTouchEvent(false); 这个方法是让ViewGroup本身不拦截触摸事件。当gridView滑动结束在requestDisallowInterceptTouchEvent(true);

　　解决问题四

Java代码
  1. public class ControlScrollView extends ScrollView {  
  2.   
  3. private boolean isInControl = true;  
  4. private int moveSpeed = 5;  
  5. private final int msgWhat = 1;  
  6. private final int time = 20;  
  7. private ScrollState scrollState;  
  8.   
  9. public ControlScrollView(Context context) {  
  10.     super(context);  
  11.     init();  
  12. }  
  13.   
  14. public ControlScrollView(Context context, AttributeSet attrs) {  
  15.     super(context, attrs);  
  16.     init();  
  17. }  
  18.   
  19. @Override  
  20. public boolean dispatchTouchEvent(MotionEvent ev) {  
  21.     switch (ev.getAction()) {  
  22.         case MotionEvent.ACTION_MOVE:/**/  
  23.             if (!isInControl) {  
  24.                 if (ev.getY() < 0) {  
  25.                     if (!myHandler.hasMessages(msgWhat)) {  
  26.                         Message msg = new Message();  
  27.                         msg.arg1 = -1;  
  28.                         msg.what = msgWhat;  
  29.                         myHandler.sendMessageDelayed(msg, time);  
  30.                     }  
  31.                     return super.dispatchTouchEvent(ev);  
  32.                 } else if (ev.getY() > getHeight()) {  
  33.                     if (!myHandler.hasMessages(msgWhat)) {  
  34.                         Message msg = new Message();  
  35.                         msg.arg1 = 1;  
  36.                         msg.what = msgWhat;  
  37.                         myHandler.sendMessageDelayed(msg, time);  
  38.                     }  
  39.                     return super.dispatchTouchEvent(ev);  
  40.                 } else {  
  41.                     myHandler.removeMessages(msgWhat);  
  42.                 }  
  43.             } else {  
  44.                 myHandler.removeMessages(msgWhat);  
  45.             }  
  46.             break;  
  47.         case MotionEvent.ACTION_UP:  
  48.         case MotionEvent.ACTION_CANCEL:  
  49.             if (scrollState != null) {  
  50.                 scrollState.stopTouch();  
  51.             }  
  52.             myHandler.removeMessages(msgWhat);  
  53.             requestDisallowInterceptTouchEvent(false);  
  54.             break;  
  55.     }  
  56.     return super.dispatchTouchEvent(ev);  
  57. }  
  58.   
  59.   
  60. @Override  
  61. protected void onDetachedFromWindow() {  
  62.     super.onDetachedFromWindow();  
  63.     myHandler.removeMessages(msgWhat);  
  64. }  
  65.   
  66.   
  67. private void init() {  
  68.     moveSpeed = ScreenUtils.dip2px(getContext(), moveSpeed);  
  69. }  
  70.   
  71. public boolean isInControl() {  
  72.     return isInControl;  
  73. }  
  74.   
  75. public ScrollState getScrollState() {  
  76.     return scrollState;  
  77. }  
  78.   
  79. public void setScrollState(ScrollState scrollState) {  
  80.     this.scrollState = scrollState;  
  81. }  
  82.   
  83. public void setInControl(boolean inControl) {  
  84.     isInControl = inControl;  
  85. }  
  86.   
  87. private Handler myHandler = new Handler() {  
  88.     @Override  
  89.     public void dispatchMessage(Message msg) {  
  90.         super.dispatchMessage(msg);  
  91.         smoothScrollBy(0, moveSpeed * (msg.arg1 > 0 ? 1 : -1));  
  92.         Message msg1 = new Message();  
  93.         msg1.what = msg.what;  
  94.         msg1.arg1 = msg.arg1;  
  95.         myHandler.sendMessageDelayed(msg1, time);  
  96.     }  
  97. };  
  98.   
  99. public interface ScrollState {  
  100.     void stopTouch();  
  101. }  

　　解析：大致逻辑就是判断手指位置，超出边界发送消息对scrollview进行滚动

　　结束

　　源码地址 https://github.com/halibobo/TouchListenerConflict

本文发布：Android开发网
本文地址：http://www.jizhuomi.com/android/example/590.html
2016年6月27日
发布:鸡啄米 分类:Android开发实例 浏览: 评论:1