备案控制台
探索云世界
开发者社区 开发与运维 文章 正文

Android ViewGroup事件分发机制

2017-11-15 742
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

转载请标明出处：http://blog.csdn.net/lmj623565791/article/details/39102591，本文出自【张鸿洋的博客】

上一篇已经完整的解析了Android View的事件分发机制，今天给大家代码ViewGroup事件分发的源码解析~~凡是自定义ViewGroup实现各种滑动效果的，不可避免的会出现很多事件的冲突，对ViewGroup事件分发机制的了解，也有益于大家了解冲突产生的原因，以及对冲突进行处理~

1、案例

首先我们接着上一篇的代码，在代码中添加一个自定义的LinearLayout：

[java]  view plain  copy
  1. package com.example.zhy_event03;  
  2.   
  3. import android.content.Context;  
  4. import android.util.AttributeSet;  
  5. import android.util.Log;  
  6. import android.view.MotionEvent;  
  7. import android.widget.LinearLayout;  
  8.   
  9. public class MyLinearLayout extends LinearLayout  
  10. {  
  11.     private static final String TAG = MyLinearLayout.class.getSimpleName();  
  12.   
  13.     public MyLinearLayout(Context context, AttributeSet attrs)  
  14.     {  
  15.         super(context, attrs);  
  16.     }  
  17.   
  18.     @Override  
  19.     public boolean dispatchTouchEvent(MotionEvent ev)  
  20.     {  
  21.         int action = ev.getAction();  
  22.         switch (action)  
  23.         {  
  24.         case MotionEvent.ACTION_DOWN:  
  25.             Log.e(TAG, "dispatchTouchEvent ACTION_DOWN");  
  26.             break;  
  27.         case MotionEvent.ACTION_MOVE:  
  28.             Log.e(TAG, "dispatchTouchEvent ACTION_MOVE");  
  29.             break;  
  30.         case MotionEvent.ACTION_UP:  
  31.             Log.e(TAG, "dispatchTouchEvent ACTION_UP");  
  32.             break;  
  33.   
  34.         default:  
  35.             break;  
  36.         }  
  37.         return super.dispatchTouchEvent(ev);  
  38.     }  
  39.   
  40.     @Override  
  41.     public boolean onTouchEvent(MotionEvent event)  
  42.     {  
  43.   
  44.         int action = event.getAction();  
  45.   
  46.         switch (action)  
  47.         {  
  48.         case MotionEvent.ACTION_DOWN:  
  49.             Log.e(TAG, "onTouchEvent ACTION_DOWN");  
  50.             break;  
  51.         case MotionEvent.ACTION_MOVE:  
  52.             Log.e(TAG, "onTouchEvent ACTION_MOVE");  
  53.             break;  
  54.         case MotionEvent.ACTION_UP:  
  55.             Log.e(TAG, "onTouchEvent ACTION_UP");  
  56.             break;  
  57.   
  58.         default:  
  59.             break;  
  60.         }  
  61.   
  62.         return super.onTouchEvent(event);  
  63.     }  
  64.   
  65.     @Override  
  66.     public boolean onInterceptTouchEvent(MotionEvent ev)  
  67.     {  
  68.           
  69.         int action = ev.getAction();  
  70.         switch (action)  
  71.         {  
  72.         case MotionEvent.ACTION_DOWN:  
  73.             Log.e(TAG, "onInterceptTouchEvent ACTION_DOWN");  
  74.             break;  
  75.         case MotionEvent.ACTION_MOVE:  
  76.             Log.e(TAG, "onInterceptTouchEvent ACTION_MOVE");  
  77.             break;  
  78.         case MotionEvent.ACTION_UP:  
  79.             Log.e(TAG, "onInterceptTouchEvent ACTION_UP");  
  80.             break;  
  81.   
  82.         default:  
  83.             break;  
  84.         }  
  85.           
  86.         return super.onInterceptTouchEvent(ev);  
  87.     }  
  88.   
  89.     @Override  
  90.     public void requestDisallowInterceptTouchEvent(boolean disallowIntercept)  
  91.     {  
  92.         Log.e(TAG, "requestDisallowInterceptTouchEvent ");  
  93.         super.requestDisallowInterceptTouchEvent(disallowIntercept);  
  94.     }  
  95.   
  96. }  


继承LinearLayout，然后复写了与事件分发机制有关的代码，添加上了日志的打印~

然后看我们的布局文件：

[html]  view plain  copy
  1. <com.example.zhy_event03.MyLinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
  2.     xmlns:tools="http://schemas.android.com/tools"  
  3.     android:layout_width="match_parent"  
  4.     android:layout_height="match_parent"  
  5.     tools:context=".MainActivity" >  
  6.   
  7.     <com.example.zhy_event03.MyButton  
  8.         android:id="@+id/id_btn"  
  9.         android:layout_width="wrap_content"  
  10.         android:layout_height="wrap_content"  
  11.         android:text="click me" />  
  12.   
  13. </com.example.zhy_event03.MyLinearLayout>  


MyLinearLayout中包含一个MyButton，MyButton都上篇博客中已经出现过，这里就不再贴代码了，不清楚可以去查看~

然后MainActivity就是直接加载布局，没有任何代码~~~

直接运行我们的代码，然后点击我们的Button，依然是有意的MOVE一下，不然不会触发MOVE事件，看一下日志的输出：

[html]  view plain  copy
  1. 09-06 09:57:27.287: E/MyLinearLayout(959): dispatchTouchEvent ACTION_DOWN  
  2. 09-06 09:57:27.287: E/MyLinearLayout(959): onInterceptTouchEvent ACTION_DOWN  
  3. 09-06 09:57:27.287: E/MyButton(959): dispatchTouchEvent ACTION_DOWN  
  4. 09-06 09:57:27.297: E/MyButton(959): onTouchEvent ACTION_DOWN  
  5. 09-06 09:57:27.297: E/MyButton(959): onTouchEvent ACTION_MOVE  
  6. 09-06 09:57:27.327: E/MyLinearLayout(959): dispatchTouchEvent ACTION_MOVE  
  7. 09-06 09:57:27.327: E/MyLinearLayout(959): onInterceptTouchEvent ACTION_MOVE  
  8. 09-06 09:57:27.337: E/MyButton(959): dispatchTouchEvent ACTION_MOVE  
  9. 09-06 09:57:27.337: E/MyButton(959): onTouchEvent ACTION_MOVE  
  10. 09-06 09:57:27.457: E/MyLinearLayout(959): dispatchTouchEvent ACTION_UP  
  11. 09-06 09:57:27.457: E/MyLinearLayout(959): onInterceptTouchEvent ACTION_UP  
  12. 09-06 09:57:27.457: E/MyButton(959): dispatchTouchEvent ACTION_UP  
  13. 09-06 09:57:27.457: E/MyButton(959): onTouchEvent ACTION_UP  


可以看到大体的事件流程为：

MyLinearLayout的dispatchTouchEvent -> MyLinearLayout的onInterceptTouchEvent -> MyButton的dispatchTouchEvent ->Mybutton的onTouchEvent 

可以看出，在View上触发事件，最先捕获到事件的为View所在的ViewGroup，然后才会到View自身~

下面我们按照日志的输出，进入源码~

2、源码分析

ViewGroup - dispatchTouchEvent

1、ViewGroup - dispatchTouchEvent - ACTION_DOWN

首先是ViewGroup的dispatchTouchEvent方法：

[java]  view plain  copy
  1. @Override  
  2.    public boolean dispatchTouchEvent(MotionEvent ev) {  
  3.        if (!onFilterTouchEventForSecurity(ev)) {  
  4.            return false;  
  5.        }  
  6.   
  7.        final int action = ev.getAction();  
  8.        final float xf = ev.getX();  
  9.        final float yf = ev.getY();  
  10.        final float scrolledXFloat = xf + mScrollX;  
  11.        final float scrolledYFloat = yf + mScrollY;  
  12.        final Rect frame = mTempRect;  
  13.   
  14.        boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;  
  15.   
  16.        if (action == MotionEvent.ACTION_DOWN) {  
  17.            if (mMotionTarget != null) {  
  18.                // this is weird, we got a pen down, but we thought it was  
  19.                // already down!  
  20.                // XXX: We should probably send an ACTION_UP to the current  
  21.                // target.  
  22.                mMotionTarget = null;  
  23.            }  
  24.            // If we're disallowing intercept or if we're allowing and we didn't  
  25.            // intercept  
  26.            if (disallowIntercept || !onInterceptTouchEvent(ev)) {  
  27.                // reset this event's action (just to protect ourselves)  
  28.                ev.setAction(MotionEvent.ACTION_DOWN);  
  29.                // We know we want to dispatch the event down, find a child  
  30.                // who can handle it, start with the front-most child.  
  31.                final int scrolledXInt = (int) scrolledXFloat;  
  32.                final int scrolledYInt = (int) scrolledYFloat;  
  33.                final View[] children = mChildren;  
  34.                final int count = mChildrenCount;  
  35.   
  36.                for (int i = count - 1; i >= 0; i--) {  
  37.                    final View child = children[i];  
  38.                    if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE  
  39.                            || child.getAnimation() != null) {  
  40.                        child.getHitRect(frame);  
  41.                        if (frame.contains(scrolledXInt, scrolledYInt)) {  
  42.                            // offset the event to the view's coordinate system  
  43.                            final float xc = scrolledXFloat - child.mLeft;  
  44.                            final float yc = scrolledYFloat - child.mTop;  
  45.                            ev.setLocation(xc, yc);  
  46.                            child.mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;  
  47.                            if (child.dispatchTouchEvent(ev))  {  
  48.                                // Event handled, we have a target now.  
  49.                                mMotionTarget = child;  
  50.                                return true;  
  51.                            }  
  52.                            // The event didn't get handled, try the next view.  
  53.                            // Don't reset the event's location, it's not  
  54.                            // necessary here.  
  55.                        }  
  56.                    }  
  57.                }  
  58.            }  
  59.        }                                                                                                                                                  ....//other code omitted  

代码比较长，决定分段贴出，首先贴出的是ACTION_DOWN事件相关的代码。

16行：进入ACTION_DOWN的处理

17-23行：将mMotionTarget置为null

26行：进行判断：if(disallowIntercept || !onInterceptTouchEvent(ev))

两种可能会进入IF代码段

1、当前不允许拦截，即disallowIntercept =true，

2、当前允许拦截但是不拦截，即disallowIntercept =false,但是onInterceptTouchEvent(ev)返回false ;

注：disallowIntercept 可以通过viewGroup.requestDisallowInterceptTouchEvent(boolean);进行设置，后面会详细说；而onInterceptTouchEvent(ev)可以进行复写。

36-57行：开始遍历所有的子View

41行：进行判断当前的x,y坐标是否落在子View身上，如果在，47行，执行child.dispatchTouchEvent(ev)，就进入了View的dispatchTouchEvent代码中了，如果不了解请参考：Android View的事件分发机制，当child.dispatchTouchEvent(ev)返回true，则为mMotionTarget=child;然后return true;

ViewGroup的ACTION_DOWN分析结束，总结一下：

ViewGroup实现捕获到DOWN事件，如果代码中不做TOUCH事件拦截，则开始查找当前x,y是否在某个子View的区域内，如果在，则把事件分发下去。

 

按照日志，接下来到达ACTION_MOVE

2、ViewGroup - dispatchTouchEvent - ACTION_MOVE

首先我们源码进行删减，只留下MOVE相关的代码：

 

[java]  view plain  copy
  1. @Override  
  2.    public boolean dispatchTouchEvent(MotionEvent ev) {  
  3.        final int action = ev.getAction();  
  4.        final float xf = ev.getX();  
  5.        final float yf = ev.getY();  
  6.        final float scrolledXFloat = xf + mScrollX;  
  7.        final float scrolledYFloat = yf + mScrollY;  
  8.        final Rect frame = mTempRect;  
  9.   
  10.        boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;  
  11.   
  12.       //...ACTION_DOWN  
  13.   
  14.       //...ACTIN_UP or ACTION_CANCEL  
  15.   
  16.        // The event wasn't an ACTION_DOWN, dispatch it to our target if  
  17.        // we have one.  
  18. final View target = mMotionTarget;  
  19.        
  20.   
  21.        // if have a target, see if we're allowed to and want to intercept its  
  22.        // events  
  23.        if (!disallowIntercept && onInterceptTouchEvent(ev)) {  
  24.            //....  
  25.        }  
  26.        // finally offset the event to the target's coordinate system and  
  27.        // dispatch the event.  
  28.        final float xc = scrolledXFloat - (float) target.mLeft;  
  29.        final float yc = scrolledYFloat - (float) target.mTop;  
  30.        ev.setLocation(xc, yc);  
  31.   
  32.        return target.dispatchTouchEvent(ev);  
  33.    }  

18行：把ACTION_DOWN时赋值的mMotionTarget，付给target ; 

23行：if (!disallowIntercept && onInterceptTouchEvent(ev)) 当前允许拦截且拦截了，才进入IF体，当然了默认是不会拦截的~这里执行了onInterceptTouchEvent(ev)

28-30行：把坐标系统转化为子View的坐标系统

32行：直接return target.dispatchTouchEvent(ev); 

可以看到，正常流程下，ACTION_MOVE在检测完是否拦截以后，直接调用了子View.dispatchTouchEvent，事件分发下去；

最后就是ACTION_UP了

3、ViewGroup - dispatchTouchEvent - ACTION_UP

 

[java]  view plain  copy
  1. public boolean dispatchTouchEvent(MotionEvent ev) {  
  2.        if (!onFilterTouchEventForSecurity(ev)) {  
  3.            return false;  
  4.        }  
  5.   
  6.        final int action = ev.getAction();  
  7.        final float xf = ev.getX();  
  8.        final float yf = ev.getY();  
  9.        final float scrolledXFloat = xf + mScrollX;  
  10.        final float scrolledYFloat = yf + mScrollY;  
  11.        final Rect frame = mTempRect;  
  12.   
  13.        boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;  
  14.   
  15.        if (action == MotionEvent.ACTION_DOWN) {...}  
  16.   
  17. boolean isUpOrCancel = (action == MotionEvent.ACTION_UP) ||  
  18.                (action == MotionEvent.ACTION_CANCEL);  
  19.   
  20. if (isUpOrCancel) {  
  21.            mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT;  
  22.        }  
  23. final View target = mMotionTarget;  
  24. if(target ==null ){...}  
  25. if (!disallowIntercept && onInterceptTouchEvent(ev)) {...}  
  26.   
  27.        if (isUpOrCancel) {  
  28.            mMotionTarget = null;  
  29.        }  
  30.   
  31.        // finally offset the event to the target's coordinate system and  
  32.        // dispatch the event.  
  33.        final float xc = scrolledXFloat - (float) target.mLeft;  
  34.        final float yc = scrolledYFloat - (float) target.mTop;  
  35.        ev.setLocation(xc, yc);  
  36.   
  37.        return target.dispatchTouchEvent(ev);  
  38.    }  

 

17行：判断当前是否是ACTION_UP

21，28行：分别重置拦截标志位以及将DOWN赋值的mMotionTarget置为null，都UP了，当然置为null，下一次DOWN还会再赋值的~

最后，修改坐标系统，然后调用target.dispatchTouchEvent(ev);

 

正常情况下，即我们上例整个代码的流程我们已经走完了：

1、ACTION_DOWN中，ViewGroup捕获到事件，然后判断是否拦截，如果没有拦截，则找到包含当前x,y坐标的子View，赋值给mMotionTarget，然后调用 mMotionTarget.dispatchTouchEvent

2、ACTION_MOVE中，ViewGroup捕获到事件，然后判断是否拦截，如果没有拦截，则直接调用mMotionTarget.dispatchTouchEvent(ev)

3、ACTION_UP中，ViewGroup捕获到事件，然后判断是否拦截，如果没有拦截，则直接调用mMotionTarget.dispatchTouchEvent(ev)

当然了在分发之前都会修改下坐标系统，把当前的x，y分别减去child.left 和 child.top ，然后传给child;

 

3、关于拦截

1、如何拦截

上面的总结都是基于：如果没有拦截；那么如何拦截呢？

复写ViewGroup的onInterceptTouchEvent方法：

[java]  view plain  copy
  1. @Override  
  2.     public boolean onInterceptTouchEvent(MotionEvent ev)  
  3.     {  
  4.         int action = ev.getAction();  
  5.         switch (action)  
  6.         {  
  7.         case MotionEvent.ACTION_DOWN:  
  8.             //如果你觉得需要拦截  
  9.             return true ;   
  10.         case MotionEvent.ACTION_MOVE:  
  11.             //如果你觉得需要拦截  
  12.             return true ;   
  13.         case MotionEvent.ACTION_UP:  
  14.             //如果你觉得需要拦截  
  15.             return true ;   
  16.         }  
  17.           
  18.         return false;  
  19.     }  


默认是不拦截的，即返回false；如果你需要拦截，只要return true就行了，这要该事件就不会往子View传递了，并且如果你在DOWN retrun true ，则DOWN,MOVE,UP子View都不会捕获事件；如果你在MOVE return true , 则子View在MOVE和UP都不会捕获事件。

原因很简单，当onInterceptTouchEvent(ev) return true的时候，会把mMotionTarget 置为null ; 

2、如何不被拦截

如果ViewGroup的onInterceptTouchEvent(ev) 当ACTION_MOVE时return true ，即拦截了子View的MOVE以及UP事件；

此时子View希望依然能够响应MOVE和UP时该咋办呢？

Android给我们提供了一个方法：requestDisallowInterceptTouchEvent(boolean) 用于设置是否允许拦截，我们在子View的dispatchTouchEvent中直接这么写：

[java]  view plain  copy
  1. @Override  
  2.     public boolean dispatchTouchEvent(MotionEvent event)  
  3.     {  
  4.         getParent().requestDisallowInterceptTouchEvent(true);    
  5.         int action = event.getAction();  
  6.   
  7.         switch (action)  
  8.         {  
  9.         case MotionEvent.ACTION_DOWN:  
  10.             Log.e(TAG, "dispatchTouchEvent ACTION_DOWN");  
  11.             break;  
  12.         case MotionEvent.ACTION_MOVE:  
  13.             Log.e(TAG, "dispatchTouchEvent ACTION_MOVE");  
  14.             break;  
  15.         case MotionEvent.ACTION_UP:  
  16.             Log.e(TAG, "dispatchTouchEvent ACTION_UP");  
  17.             break;  
  18.   
  19.         default:  
  20.             break;  
  21.         }  
  22.         return super.dispatchTouchEvent(event);  
  23.     }  


getParent().requestDisallowInterceptTouchEvent(true);  这样即使ViewGroup在MOVE的时候return true，子View依然可以捕获到MOVE以及UP事件。

 

从源码也可以解释：

ViewGroup MOVE和UP拦截的源码是这样的：

[java]  view plain  copy
  1. if (!disallowIntercept && onInterceptTouchEvent(ev)) {  
  2.             final float xc = scrolledXFloat - (float) target.mLeft;  
  3.             final float yc = scrolledYFloat - (float) target.mTop;  
  4.             mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;  
  5.             ev.setAction(MotionEvent.ACTION_CANCEL);  
  6.             ev.setLocation(xc, yc);  
  7.             if (!target.dispatchTouchEvent(ev)) {  
  8.                 // target didn't handle ACTION_CANCEL. not much we can do  
  9.                 // but they should have.  
  10.             }  
  11.             // clear the target  
  12.             mMotionTarget = null;  
  13.             // Don't dispatch this event to our own view, because we already  
  14.             // saw it when intercepting; we just want to give the following  
  15.             // event to the normal onTouchEvent().  
  16.             return true;  
  17.         }  


当我们把disallowIntercept设置为true时，!disallowIntercept直接为false，于是拦截的方法体就被跳过了~

注：如果ViewGroup在onInterceptTouchEvent(ev)  ACTION_DOWN里面直接return true了，那么子View是木有办法的捕获事件的~~~

 

4、如果没有找到合适的子View

我们的实例，直接点击ViewGroup内的按钮，当然直接很顺利的走完整个流程；

但是有两种特殊情况

1、ACTION_DOWN的时候，子View.dispatchTouchEvent(ev)返回的为false ; 

如果你仔细看了，你会注意到ViewGroup的dispatchTouchEvent(ev)的ACTION_DOWN代码是这样的

[java]  view plain  copy
  1. if (child.dispatchTouchEvent(ev))  {  
  2.                               // Event handled, we have a target now.  
  3.                               mMotionTarget = child;  
  4.                               return true;  
  5.                           }  


只有在child.dispatchTouchEvent(ev)返回true了，才会认为找到了能够处理当前事件的View，即mMotionTarget = child;

但是如果返回false,那么mMotionTarget 依然是null

mMotionTarget 为null会咋样呢？

其实ViewGroup也是View的子类，如果没有找到能够处理该事件的子View，或者干脆就没有子View；

那么，它作为一个View，就相当于View的事件转发了~~直接super.dispatchTouchEvent(ev);

源码是这样的：

 

[java]  view plain  copy
  1. final View target = mMotionTarget;  
  2.        if (target == null) {  
  3.            // We don't have a target, this means we're handling the  
  4.            // event as a regular view.  
  5.            ev.setLocation(xf, yf);  
  6.            if ((mPrivateFlags & CANCEL_NEXT_UP_EVENT) != 0) {  
  7.                ev.setAction(MotionEvent.ACTION_CANCEL);  
  8.                mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;  
  9.            }  
  10.            return super.dispatchTouchEvent(ev);  
  11.        }  


我们没有一个能够处理该事件的目标元素，意味着我们需要自己处理~~~就相当于传统的View~

2、那么什么时候子View.dispatchTouchEvent(ev)返回的为true

如果你仔细看了上篇博客，你会发现只要子View支持点击或者长按事件一定返回true~~

源码是这样的：

 

[java]  view plain  copy
  1.    
  2. if (((viewFlags & CLICKABLE) == CLICKABLE ||  
  3.                 (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)) {     
  4.              return true ;                                                                                                                                                                                                                                                                                                   }  

 

5、总结

关于代码流程上面已经总结过了~

1、如果ViewGroup找到了能够处理该事件的View，则直接交给子View处理，自己的onTouchEvent不会被触发；

2、可以通过复写onInterceptTouchEvent(ev)方法，拦截子View的事件（即return true），把事件交给自己处理，则会执行自己对应的onTouchEvent方法

3、子View可以通过调用getParent().requestDisallowInterceptTouchEvent(true);  阻止ViewGroup对其MOVE或者UP事件进行拦截；

 

好了，那么实际应用中能解决哪些问题呢？

比如你需要写一个类似slidingmenu的左侧隐藏menu，主Activity上有个Button、ListView或者任何可以响应点击的View，你在当前View上死命的滑动，菜单栏也出不来；因为MOVE事件被子View处理了~ 你需要这么做：在ViewGroup的dispatchTouchEvent中判断用户是不是想显示菜单，如果是，则在onInterceptTouchEvent(ev)拦截子View的事件；自己进行处理，这样自己的onTouchEvent就可以顺利展现出菜单栏了~~



    本文转自 一点点征服   博客园博客，原文链接：http://www.cnblogs.com/ldq2016/p/6879428.html，如需转载请自行联系原作者




文章标签：
日志服务
Android开发
Java
关键词：
Android事件
Android事件分发机制
Android ViewGroup
Android ViewGroup事件分发机制
相关实践学习
日志服务之使用Nginx模式采集日志
本文介绍如何通过日志服务控制台创建Nginx模式的Logtail配置快速采集Nginx日志并进行多维度分析。
技术小胖子
目录
相关文章
热烈的马
|
4月前
|
XML Java Android开发
Android Studio App开发之捕获屏幕的变更事件实战（包括竖屏与横屏切换，回到桌面与切换到任务列表）
Android Studio App开发之捕获屏幕的变更事件实战（包括竖屏与横屏切换，回到桌面与切换到任务列表）
热烈的马
38 0
公众号：小余的自习室
|
Java Linux API
“framework必会”系列：Android Input系统（一）事件读取机制
曾经在开发的很长一段时间内，笔者对点击事件的认知只存在于自定义View中的`onTouchEvent`等方法的处理。 后来慢慢的接触到`Android的事件分发机制`，但也只是在**Activity->ViewGroup->View**层面的分发逻辑
公众号：小余的自习室
394 0
camellia。
|
4月前
|
小程序 JavaScript 前端开发
微信小程序（十七）小程序监听返回键跳转事件（安卓返回也适用）
onUnload:function(){ wx.redirectTo({ url: '../index/index' }) wx.navigateTo({ url: '../index/index' }) wx.switchTab({ url: '../../member/member' }) }
camellia。
297 0
Hdnw
|
4月前
|
Android开发 容器
[Android]View的事件分发机制（源码解析）
[Android]View的事件分发机制（源码解析）
Hdnw
36 0
热烈的马
|
4月前
|
XML Java Android开发
Android App事件交互Event之模仿京东App实现下拉刷新功能（附源码 可直接使用）
Android App事件交互Event之模仿京东App实现下拉刷新功能（附源码 可直接使用）
热烈的马
32 0
Android App事件交互Event之模仿京东App实现下拉刷新功能（附源码 可直接使用）
热烈的马
|
4月前
|
XML Java Android开发
Android App事件交互中辨别缩放与旋转手指的讲解与实战（附源码 可直接使用）
Android App事件交互中辨别缩放与旋转手指的讲解与实战（附源码 可直接使用）
热烈的马
36 0
热烈的马
|
4月前
|
XML Java Android开发
Android App事件交互中区分点击和长按动作以及识别手势滑动方向的讲解及实战（附源码 可直接使用）
Android App事件交互中区分点击和长按动作以及识别手势滑动方向的讲解及实战（附源码 可直接使用）
热烈的马
57 0
热烈的马
|
4月前
|
XML Java Android开发
Android App开发触摸事件中手势事件Event的分发流程讲解与实战（附源码 简单易懂）
Android App开发触摸事件中手势事件Event的分发流程讲解与实战（附源码 简单易懂）
热烈的马
43 0
热烈的马
|
4月前
|
XML 监控 Java
Android App开发之事件交互Event中检测软键盘和物理按键讲解及实战（附源码 演示简单易懂）
Android App开发之事件交互Event中检测软键盘和物理按键讲解及实战（附源码 演示简单易懂）
热烈的马
115 0
程序员徐师兄
|
7月前
|
Android开发 开发者
Android View 事件分发机制，看这一篇就够了（二）
Android View 事件分发机制，看这一篇就够了
程序员徐师兄
42 0

热门文章

最新文章

  • 1
    我的Android之路(持续更新总结~)
  • 2
    Android实现自定义进度条(源码+解析)
  • 3
    mPaaS常见问题之Android集成dexPatch热修复运行时候无法正常进行热更新如何解决
  • 4
    Android 面试题及答案整理，最新面试题
  • 5
    构建高效Android应用：探究Kotlin与Java的性能差异
  • 6
    构建高效Android应用：Kotlin协程的实践与优化
  • 7
    构建高效Android应用：探究Kotlin协程的优势
  • 8
    安卓适配性策略：确保应用在不同设备上的兼容性
  • 9
    安卓安全性指南：保护用户数据免受恶意攻击
  • 10
    mPaaS常见问题之pixel4 android 13 调用移动网关 报这个错如何解决
  • 1
    构建高效Android应用：Kotlin协程的实践指南
    15
  • 2
    构建高效Android应用：Kotlin与协程的完美融合
    27
  • 3
    【Android平板编程】远程Ubuntu服务器code-server编程写代码
    45
  • 4
    android 使用GSON 序列化对象出现字段被优化问题解决方案
    16
  • 5
    前端分析工具之 Charles 录制 Android/IOS 手机的 https 应用
    46
  • 6
    构建高效Android应用：Kotlin协程的实践指南
    48
  • 7
    构建高效Android应用：探究Kotlin多线程编程
    35
  • 8
    构建高效Android应用：Kotlin协程的实践指南
    25
  • 9
    构建高效Android应用：Kotlin与协程的完美融合
    15
  • 10
    Android 12 新特性深度解析
    20

    • 相关课程

    更多
  • 开源Android容器化框架Atlas开发者指南

    • 相关电子书

    更多
  • 58同城Android客户端Walle框架演进与实践之路
  • Android组件化实现
  • 蚂蚁聚宝Android秒级编译——Freeline

    • 推荐镜像

    更多
  • android.googlesource.com
    • 下一篇
    阿里云oss简介和使用流程
    为什么选择阿里云什么是云计算全球基础设施技术领先稳定可靠安全合规分析师报告
    产品和定价全部产品免费试用产品动态产品定价价格计算器云上成本管理
    解决方案技术解决方案
    文档与社区文档开发者社区天池大赛培训与认证
    权益中心免费试用高校计划企业扶持计划推荐返现计划
    支持与服务基础服务企业增值服务迁云服务官网公告健康看板信任中心
    关注阿里云
    关注阿里云公众号或下载阿里云APP，关注云资讯，随时随地运维管控云服务
    阿里云APP阿里云微信
    联系我们：4008013260
    法律声明Cookies政策廉正举报安全举报联系我们加入我们
    阿里巴巴集团淘宝网天猫全球速卖通阿里巴巴国际交易市场1688阿里妈妈飞猪阿里云计算AliOS万网高德UC友盟优酷钉钉支付宝达摩院淘宝海外阿里云盘饿了么
    © 2009-2024 Aliyun.com 版权所有 增值电信业务经营许可证： 浙B2-20080101 域名注册服务机构许可： 浙D3-20210002 京D3-20220015
    浙公网安备 33010602009975号浙B2-20080101-4