An article to thoroughly understand the Android event distribution mechanism

Preface

In Android development, we often encounter sliding conflicts (such as the nesting of ScrollView or SliddingMenu and ListView), which require us to have a deep understanding of the Android event response mechanism to solve. The event response mechanism is already essential knowledge for Android developers. It is also a question that interviewers often ask when looking for a job.

Common methods involved in incident response

When the user's finger is in contact with the screen, a series of events are generated through the MotionEvent object, which has four states:

• MotionEvent.ACTION_DOWN: The moment your finger presses the screen (the beginning of all events)
• MotionEvent.ACTION_MOVE: The finger moves on the screen
• MotionEvent.ACTION_UP: The moment your finger leaves the screen
• MotionEvent.ACTION_CANCEL: Cancel gesture, usually generated by the program, not by the user

The events onClick, onLongClick, onScroll, onFling, etc. in Android are all composed of many Touch events (one ACTION_DOWN, n ACTION_MOVE, 1 ACTION_UP).

The Android event response mechanism is implemented in the form of distribution first (first received by the external View, and then passed to the smallest View in its inner layer in turn) and then processing (starting from the smallest View unit (event source) and passing to the outer layer in turn).

The complexity lies in: the ability to control whether events at each layer continue to be transmitted (distribution and interception are implemented in coordination), as well as the specific consumption of events (event distribution also has event consumption capabilities).

Three important functions involved in android event processing

Event dispatch: public boolean dispatchTouchEvent(MotionEvent ev)

When an event is detected, the Activity first captures it and enters the event dispatch process. (Because the activity does not intercept events, View and ViewGroup do) The event is passed to the dispatchTouchEvent(MotionEvent ev) method of the outermost View, which dispatches the event.

• return true: Indicates that all events have been digested internally by the View.
• return false: The event will no longer be distributed at this layer, and will be consumed by the onTouchEvent method of the upper layer control (if the control at this layer is already an Activity, the event will be consumed or processed by the system).
• If the event dispatch returns the system default super.dispatchTouchEvent(ev), the event will be dispatched to the event interception onInterceptTouchEvent method of this layer for processing.

Event interception: public boolean onInterceptTouchEvent(MotionEvent ev)

• return true: means intercepting the event and passing it to the onTouchEvent of the control at this layer for processing;
• return false: means that the event is not intercepted and is successfully distributed to the child View. It is then processed by the child View's dispatchTouchEvent.
• If super.onInterceptTouchEvent(ev) is returned, it means intercepting the event by default and passing the event to the onTouchEvent method of the current View, which is the same as return true.

Event response: public boolean onTouchEvent(MotionEvent ev)

When dispatchTouchEvent (event dispatch) returns super.dispatchTouchEvent (ev) and onInterceptTouchEvent (event interception returns true or super.onInterceptTouchEvent (ev), the event will be passed to the onTouchEvent method, which responds to the event.

• If return true, it means that onTouchEvent consumes the event after processing it. At this point, the event ends;
• If return false, it means no response to the event, then the event will be continuously passed to the onTouchEvent method of the upper View until the onTouchEvent method of a View returns true. If it still returns false when it reaches the top View, then the event is considered not consumed. In the same event series, the current View cannot receive the event again, and the event will be handled by the onTouchEvent of the Activity.
• If you return super.dispatchTouchEvent(ev), it means that you do not respond to the event, and the result is the same as return false.

From the above process, we can see that no matter dispatchTouchEvent returns true or false, the event will not be distributed. Only when it returns super.dispatchTouchEvent(ev) does it indicate that it has the desire to distribute to the lower layer. However, whether the distribution can be successful needs to be reviewed by the event interception onInterceptTouchEvent. Whether the event is passed up for processing is determined by the return value of onTouchEvent.

View source code analysis

In Android, ImageView, textView, Button, etc. inherit from View but do not override the dispatchTouchEvent method, so they all use this method of View for event distribution.

Look at the source code of some important functions of View:

 public boolean dispatchTouchEvent(MotionEvent event) {
 //Return true , indicating that the View has digested all events. Return false , indicating that the View has only processed the ACTION_DOWN event, and the event continues to be passed to the parent View (ViewGroup).
    if (mOnTouchListener != null && (mViewFlags & ENABLED_MASK) == ENABLED &&
            mOnTouchListener.onTouch(this, event)) {
 //The onTouch method here is the callback onTouch() method we rewrite when registering OnTouchListener
 return   true ;
    } return onTouchEvent(event);
 }

First, three conditions are judged:

(1) Check whether the OnTouchListener() event is set for the button;

(2) Whether the control is enabled; (Controls are enabled by default)

(3) Whether the onTouch() method in the OnTouchListener listener implemented in the button returns true;

If all conditions are met, the event is consumed and no longer processed in onTouchEvent. Otherwise, the event will be handed over to the onTouchEvent method for processing.

 public boolean onTouchEvent(MotionEvent event) {
 ... 
 
 /＊ The current onTouch component must be clickable, such as Button, ImageButton, etc. Here, CLICKABLE is true , then it will enter the if method and finally return true .
 If it is an ImageView, TextView, or other View that is not clickable by default , CLICKABLE is false and *** returns false . Of course, there are special cases. If an onClick listener is set for these Views , CLICKABLE will also be true here . ＊／
    if (((viewFlags & CLICKABLE) == CLICKABLE ||
             (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)) {
         switch (event.getAction()) {
 case MotionEvent.ACTION_UP:
 ...
                   if (!post(mPerformClick)) {
 performClick(); // Actually, it calls back the onClick() method in the OnClickListener we registered
 }
 ...
 break;
 case MotionEvent.ACTION_DOWN:
 ...
 break;
 case MotionEvent.ACTION_CANCEL:
 ...
 break;
 case MotionEvent.ACTION_MOVE:
 ...
 break;
 }
 return   true ;
 }
 return   false ;
 }

 public boolean performClick() {
 ...
 // if (li != null && li.mOnClickListener != null ) {
 ...
        li.mOnClickListener.onClick(this);
 return   true ;
 }
 return   false ;
 }

 public void setOnClickListener(OnClickListener l) { if (!isClickable()) { 
 
 setClickable( true ); 
 
 } 
 
 getListenerInfo().mOnClickListener = l; 
 
 }

Only when we register OnTouchListener

In the onTouch() method

Return false —> execute onTouchEvent method —> cause onClick() callback method to execute

Return true —> onTouchEvent method is not executed —> causing onClick() callback method not to be executed

ViewGroup source code analysis

The five major layout controls in Android, such as LinearLayout, are all inherited from ViewGroup, and ViewGroup itself is inherited from View, so the event handling mechanism of ViewGroup is effective for these controls.

Part of the source code:

 public boolean dispatchTouchEvent(MotionEvent ev) {
 final int   action = ev.getAction();
       final float xf = ev.getX();
       final float yf = ev.getY();
       final float scrolledXFloat = xf + mScrollX;
       final float scrolledYFloat = yf + mScrollY;
       final Rect frame = mTempRect; 
   
 //This value is false by default , and then we can use the requestDisallowInterceptTouchEvent(boolean disallowIntercept) method
 //To change the value of disallowIntercept
       boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0; 
   
 //Here is the processing logic of ACTION_DOWN
       if ( action == MotionEvent.ACTION_DOWN) {
 // Clear mMotionTarget, set mMotionTarget to null every time ACTION_DOWN is called    
           if (mMotionTarget != null ) {
               mMotionTarget = null ;
 } 
   
 //disallowIntercept is false by default , just look at the onInterceptTouchEvent() method of ViewGroup
           if (disallowIntercept || !onInterceptTouchEvent(ev)) { //*** point
               ev.setAction(MotionEvent.ACTION_DOWN);
               final int scrolledXInt = ( int ) scrolledXFloat;
               final int scrolledYInt = ( int ) scrolledYFloat;
               final View [] children = mChildren;
 final int   count = mChildrenCount;
 //Traverse its child View    
 for ( int i = count - 1; i >= 0; i --) { //The second point  
                   final View child = children[i]; 
                      
 //If the child View is VISIBLE or the child View is executing animation, it means that the View is
 //Can receive Touch events
                   if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE
                           || child.getAnimation() != null ) {
 //Get the position range of the child View
                       child.getHitRect(frame); 
                          
 //If you touch the point on the screen, it is on the sub -View
                       if (frame. contains (scrolledXInt, scrolledYInt)) {
                           // offset the event to the view 's coordinate system
                           final float xc = scrolledXFloat - child.mLeft;
                           final float yc = scrolledYFloat - child.mTop;
                           ev.setLocation(xc, yc);
                           child.mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT; 
                              
 //Call the dispatchTouchEvent() method of the child View
                           if (child.dispatchTouchEvent(ev)) {
 // If child.dispatchTouchEvent(ev) returns true , it means
 //The event is consumed, set mMotionTarget to the child View    
                               mMotionTarget = child;
 //Return true directly    
 return   true ;
 }
                           // The event didn't get handled, try the next   view .
                           // Don 't reset the event's location, it's not    
                           // necessary here.
 }
 }
 }
 }
 } 
   
 //Judge whether it is ACTION_UP or ACTION_CANCEL
       boolean isUpOrCancel = ( action == MotionEvent.ACTION_UP) ||
               ( action == MotionEvent.ACTION_CANCEL); 
   
 if (isUpOrCancel) {
 //If it is ACTION_UP or ACTION_CANCEL, set disallowIntercept to the default false    
 //If we call the requestDisallowInterceptTouchEvent() method to set disallowIntercept to true    
 //When we lift our finger or cancel the Touch event, we need to reset disallowIntercept to false    
 //So the above disallowIntercept defaults to false every time we do ACTION_DOWN    
           mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT;
 } 
   
       // The event wasn't an ACTION_DOWN, dispatch it to our target if
 // we have one.
       final View target = mMotionTarget;
 //mMotionTarget is null , which means that no View consuming Touch events is found , so we need to call the ViewGroup parent class
 //dispatchTouchEvent() method, that is, View 's dispatchTouchEvent() method
 if (target == null ) {
           // We don 't have a target, this means we' re handling the
           // event as a regular view .
           ev.setLocation(xf, yf);
           if ((mPrivateFlags & CANCEL_NEXT_UP_EVENT) != 0) {
               ev.setAction(MotionEvent.ACTION_CANCEL);
               mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;
 }
 return super.dispatchTouchEvent(ev);
 } 
   
 //The code in this if will not execute ACTION_DOWN, only ACTION_MOVE
 // ACTION_UP will go here, if it is intercepted in ACTION_MOVE or ACTION_UP
 //Touch event, send ACTION_CANCEL to target, and then return true directly    
 //Indicates that this Touch event has been consumed
       if (!disallowIntercept && onInterceptTouchEvent(ev)) {
           final float xc = scrolledXFloat - ( float ) target.mLeft;
           final float yc = scrolledYFloat - ( float ) target.mTop;
           mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;
           ev.setAction(MotionEvent.ACTION_CANCEL);
           ev.setLocation(xc, yc); 
              
           if (!target.dispatchTouchEvent(ev)) {
 }
           // clear the target
           mMotionTarget = null ;
           // Don't dispatch this event to our own view , because we already
           // saw it when intercepting; we just want to give the following
           // event to the normal onTouchEvent().
 return   true ;
 } 
   
 if (isUpOrCancel) {
           mMotionTarget = null ;
 } 
   
       // finally offset the event to the target's coordinate system and    
 // dispatch the event.
       final float xc = scrolledXFloat - ( float ) target.mLeft;
       final float yc = scrolledYFloat - ( float ) target.mTop;
       ev.setLocation(xc, yc); 
   
       if ((target.mPrivateFlags & CANCEL_NEXT_UP_EVENT) != 0) {
           ev.setAction(MotionEvent.ACTION_CANCEL);
           target.mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;
           mMotionTarget = null ;
 } 
   
 //If ACTION_MOVE and ACTION_DOWN are not intercepted, the Touch event is dispatched directly to the target
 return target.dispatchTouchEvent(ev);
 }

1. Function of dispatchTouchEvent: Determines whether the event is intercepted and processed by onInterceptTouchEvent.

When super.dispatchTouchEvent is returned, onInterceptTouchEvent determines the direction of the event.

When false is returned, the event will continue to be distributed, and only ACTION_DOWN will be processed internally.

When true is returned, events will not be distributed any more, and all events (ACTION_DOWN, ACTION_MOVE, ACTION_UP) will be processed internally.

2. onInterceptTouchEvent function: intercept events to determine whether the event is passed to the child View

When true is returned, the onTouchEvent is intercepted and handled by itself

When false is returned, the interception is handed over to the child View for processing

3. onTouchEvent function: the event finally reaches this method

When true is returned, all events are processed internally. In other words, subsequent events will continue to be passed to the onTouchEvent() of the view for processing.

When it returns false, the event will be passed upward and accepted by onTouchEvent. If onTouchEvent in the topmost View also returns false, the event will disappear.

Summarize

• If the ViewGroup finds a View that can handle the event, it will directly hand it over to the child View for processing, and its own onTouchEvent will not be triggered;
• You can intercept the event of the child View (that is, return true) by overriding the onInterceptTouchEvent(ev) method, and hand the event over to yourself for processing, and your corresponding onTouchEvent method will be executed.
• The child View can prevent the ViewGroup from intercepting its MOVE or UP events by calling getParent().requestDisallowInterceptTouchEvent(true);
• After a click event occurs, its transmission process is as follows:
• Activity->Window->View. ***After View receives the event, it will distribute the event according to the corresponding rules. If a View's onTouchEvent method returns false, it will be handed over to the onTouchEvent method of the parent container for processing, and so on. If all Views do not handle the event, it will be handed over to the onTouchEvent of the Activity for processing.
• If a View starts processing an event, if it does not consume the ACTION_DOWN event (that is, onTouchEvent returns false), the same event sequence, such as the next ACTION_MOVE, will not be handed over to the View for processing.
• ViewGroup does not intercept any events by default.
• Views that are not containers, such as TextView and ImageView, call the onTouchEvent method once they receive an event. They do not have an onInterceptTouchEvent method. Normally, they consume events (return true), unless they are not clickable (both clickable and longClickable are false), in which case they are handled by the onTouchEvent of the parent container.
• The click event dispatch process is as follows: dispatchTouchEvent—->OnTouchListener's onTouch method—->onTouchEvent-->OnClickListener's onClick method. In other words, the setOnClickListener we usually call has the highest priority, so if onTouchEvent or OnTouchListener's onTouch method returns true, it will not respond to the onClick method.