Android advanced View event distribution mechanism and source code detailed explanation

[[418059]]

This article is reprinted from the WeChat public account "Android Development Programming", the author is Android Development Programming. Please contact the Android Development Programming public account for reprinting this article.

Preface

Event distribution is relatively important in Android development, but also relatively difficult to understand;

During development, we often encounter sliding conflicts (such as nesting of ScrollView or SliddingMenu with ListView).

We need to have a deep understanding of the Android event response mechanism to solve it.

The event response mechanism has become essential knowledge for Android developers.

So today we will explain event distribution in detail. Let's learn together.

1. Understanding of view event related knowledge

1. View position parameters

The position of a View is mainly determined by its four vertices, that is, its four attributes: top, left, right, and bottom, which represent the coordinate points of the upper left corner (top, left) and the lower right corner (right, bottom) of the View respectively.

At the same time, we can get the size of the View:

 width = right - left
 height = bottom - top

These four parameters can be obtained in the following ways:

 Left = getLeft();
 Right = getRight();
 Top = getTop();
 Bottom = getBottom();

After Android 3.0, View adds the parameters x, y, translationX and translationY. x and y are the coordinates of the upper left corner of the View, while translationX and translationY are the offsets of the upper left corner of the View relative to the container. The conversion relationship between them is as follows:

 x = left + translationX;
 y = top + translationY;

2. MotionEvent

Our actions of clicking, sliding, lifting, etc. on the screen are composed of a series of MotionEvent objects. According to different actions, there are mainly three types of events:

• ACTION_DOWN: This event is generated when your finger just touches the screen and presses down.
• ACTION_MOVE: This event is generated when the finger moves on the screen
• ACTION_UP: This event is generated when your finger is released from the screen.

From ACTION_DOWN to ACTION_UP, we call it an event sequence

Under normal circumstances, no matter how much you operate your fingers on the screen, the final result of MotionEvent is nothing more than the following two types;

• Click and then lift, that is, click operation: ACTION_DOWN -> ACTION_UP
• After clicking, slide for a distance and then lift up: ACTION_DOWN -> ACTION_MOVE -> ... -> ACTION_MOVE -> ACTION_UP;

 public class MotionEventActivity extends BaseActivity {
 private Button mButton;
 @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_motion_event);
        mButton = (Button) findViewById(R.id.button);
        mButton.setOnTouchListener(new View .OnTouchListener() {
 @Override
 public boolean onTouch( View v, MotionEvent event) {
                switch (event.getAction()) {
 case MotionEvent.ACTION_DOWN:
                        e( "MotionEvent: ACTION_DOWN" );
                        break;
 case MotionEvent.ACTION_MOVE:
                        e( "MotionEvent: ACTION_MOVE" );
                        break;
 case MotionEvent.ACTION_UP:
                        e( "MotionEvent: ACTION_UP" );
                        break;
 }
 return false ;
 }
 });
 }
 public void click( View v) {
 e( "button clicked" );
 }
 }

3. Scroller

The elastic sliding object is used to implement the elastic sliding of the View. It cannot make the View slide elastically by itself, and needs to be used in conjunction with the computeScroll method of the View to complete this function. Usage:

 Scroller scroller = new Scroller(mContext);
 //Slowly move to the specified position
 private void smoothScrollTo( int destX, int destY){
 int scrollX = getScrollX();
 int delta = destX - scrollX;
 //Slide to destX within 1000ms, the effect is to slide slowly
    mScroller.startScroll(scrollX,0,delta,0,1000);
 invalidate();
 }
 @Override
 public void computeScroll() {
    if(mScroller.computeScrollOffset()){
    scrollTo(mScroller.getCurrX,mScroller.getCurrY());
 postInvalidate();
 }
 }

4. Understanding the methods involved in event distribution

• dispatchTouchEvent(MotionEvent ev): used to dispatch events. If the event can be passed to the current View, this method will be called.
• onInterceptTouchEvent(MotionEvent ev): used to determine whether to intercept an event. If the current View intercepts an event, this method will not be called again in the same event sequence.
• onTouchEvent(MotionEvent ev): used to process touch events. The returned result indicates whether the current event is consumed. If not, the current View cannot receive events again in the same event sequence.
• onTouch(View view, MotionEvent motionEvent): used to handle touch events, set through setOnTouchListener, a very common method.
• onClick(View view): used to handle click events, set through setOnClickListener, a very common method.
• requestDisallowInterceptTouchEvent(boolean b): request not to intercept touch events. Generally used to handle sliding conflicts, the child control requests the parent control not to intercept;
• Other events except ACTION_DOWN, ACTION_DOWN event is not affected.

2. Event Distribution

When a MotionEvent is generated, that is, when your finger makes a series of movements on the screen, the system needs to distribute this series of MotionEvents to a specific View. We need to focus on understanding the distribution process, so how does the system determine which View to give this event to, that is, how is it distributed?

Event distribution requires three important methods of View to complete together:

1. public boolean dispatchTouchEvent(MotionEvent event)

From the method name, we can easily guess that it is an important method for event dispatching. So obviously, if a MotionEvent is passed to View, the dispatchTouchEvent method will definitely be called!

Return value: Indicates whether the current event is consumed. It may be consumed by the onTouchEvent method of the View itself, or consumed by the dispatchTouchEvent method of the child View. Returning true means that the event is consumed and this event is terminated. Returning false means that neither the View nor the child View consumes the event, and the onTouchEvent method of the parent View will be called;

2. public boolean onInterceptTouchEvent(MotionEvent ev)

Event interception, when a ViewGroup receives a MotionEvent event sequence, it will first call this method to determine whether it needs to be intercepted. Note that this is a method unique to ViewGroup, and View does not have an interception method;

Return value: whether to intercept the event transmission. Returning true means that the event is intercepted, and the event will no longer be distributed downwards but the onTouchEvent method of the View itself will be called. Returning false means that no interception is performed, and the event will be distributed downwards to the dispatchTouchEvent method of the child View.

3. public boolean onTouchEvent(MotionEvent ev)

The actual method for processing or consuming MotionEvent. Called in dispatchTouchEvent;

Return value: Returning true means the event is consumed and the event is terminated. Returning false means the event is not consumed and the onTouchEvent method of the parent View will be called.

The relationship between the above three methods can be expressed by the following pseudo code.

 public boolean dispatchTouchEvent(MotionEvent ev) {
 boolean consume = false ; //Whether the event is consumed
 if (onInterceptTouchEvent(ev)){//Call onInterceptTouchEvent to determine whether to intercept the event
 consume = onTouchEvent(ev); //If intercepted, call its own onTouchEvent method
 } else {
 consume = child.dispatchTouchEvent(ev); //Do not intercept the dispatchTouchEvent method of the child View
 }
 return consume; //The return value indicates whether the event is consumed, true terminates the event, false calls the onTouchEvent method of the parent View
 }

Next, let's take a look at the differences between View and ViewGroup when distributing events.

ViewGroup is a subclass of View, which means that ViewGroup itself is a View, but it can contain child Views (of course, a child View can also be a ViewGroup), so it is not difficult to understand that the pseudo code shown above represents the process of ViewGroup handling event distribution. View itself does not have distribution, so there is no interception method (onInterceptTouchEvent), it can only process consumption or not consumption in the onTouchEvent method.

The following flowchart will help us sort out the event distribution mechanism more clearly.

It can be seen that the event transmission process is from parent View to child View.

The child View can intervene in the event distribution process of the parent View (except ACTION_DOWN events) through the requestDisallowInterceptTouchEvent method, which is the key method we commonly use to deal with sliding conflicts;

For View (note! ViewGroup is also View), if onTouchListener is set, the onTouch method in the OnTouchListener method will be called back. If the onTouch method returns true, the onTouchEvent method will not be called (the onClick event is called in onTouchEvent), so the priority of the three is onTouch->onTouchEvent->onClick;

By default, the onTouchEvent method of View will consume the event (return true), unless it is not clickable (both clickable and longClickable are false). The longClickable of View defaults to false, and clickable needs to be differentiated. For example, the clickable of Button defaults to true, while the clickable of TextView defaults to false.

Here is a summary of the event delivery mechanism:

• An event sequence starts with a down event, contains an indefinite number of move events, and ends with an up event;
• Normally, an event sequence can only be intercepted and consumed by one View;
• After a View intercepts an event, the event sequence can only be handled by it, and its onInterceptTouchEvent will no longer be called;
• Once a View starts processing an event, if it does not consume the ACTION_DOWN event (onTouchEvnet returns false), then other events in the same event sequence will not be handed over to it for processing, and the event will be handed back to its parent element for processing, that is, the parent element's onTouchEvent is called;.
• If the View does not consume events other than ACTION_DOWN, then this event will disappear. At this time, the onTouchEvent of the parent element will not be called, and the current View can continue to receive subsequent events. The click event that disappears will eventually be passed to the Activity for processing.
• ViewGroup does not intercept any events by default;
• View does not have an onInterceptTouchEvent method. Once the event is passed to it, its onTouchEvent method will be called;
• By default, the onTouchEvent of a View consumes the event, unless it is not clickable (both clickable and longClickable are false). The longClickable property of a View defaults to false, and the clickable default property is different for different situations (e.g., TextView is false, and button is true);
• The enable property of View does not affect the default return value of onTouchEvent;
• The premise for onClick to occur is that the current View is clickable and has received down and up events;
• The event transmission process is always from outside to inside, that is, the event is always passed to the parent element first, and then distributed to the child View by the parent element. The requestDisallowInterceptTouchEvent method can be used to intervene in the parent element's distribution process in the child element, except for the ACTION_DOWN event;

3. Solutions to sliding conflicts

1. External interception method

The so-called external interception method means that the click event is first intercepted and processed by the parent container. If the parent container needs this event, it will be intercepted, otherwise it will not be intercepted. The following is pseudo code:

 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 (parent container needs current event) {
 intercepted = true ;
 } else {
 intercepted = false ;
 }
 break;
 case MotionEvent.ACTION_UP:
 intercepted = false ;
 break;
 default :
 break;
 }
 mLastXIntercept = x;
 mLastYIntercept = y;
 return intercepted;

For different conflicts, you only need to modify the conditions of the parent container that require the current event. Other conditions do not need to be modified and cannot be modified.

ACTION_DOWN: must return false. If true is returned, subsequent events will be intercepted and cannot be passed to the child View;

ACTION_MOVE: Decide whether to intercept based on the needs;

ACTION_UP: must return false. If intercepted, the child View cannot receive the up event and cannot complete the click operation. If the parent container needs the event, it has been intercepted during ACTION_MOVE. According to conclusion 3 in the previous section, ACTION_UP will not pass through the onInterceptTouchEvent method and will be directly handed over to the parent container for processing;

2. Internal interception method

Internal interception means that the parent container does not intercept any events, and all events are passed to the child element. If the child element needs the event, it will consume it directly, otherwise it will be handled by the parent container. This method is inconsistent with the Android event distribution mechanism and needs to be combined with the requestDisallowInterceptTouchEvent method to work properly. The following is pseudo code:

 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 container requires this type of click event) {
        parent.requestDisallowInterceptTouchEvent( false );
 }
 break;
 case MotionEvent.ACTION_UP:
 break;
 default :
 break;
 }
 mLastX = x;
 mLastY = y;
 return super.dispatchTouchEvent(event);
 }

In addition to the processing required by the child element, the parent element must also intercept other events except ACTION_DOWN by default, so that when the child element calls the parent.requestDisallowInterceptTouchEvent(false) method, the parent element can continue to intercept the required events. Therefore, the parent element needs to make the following changes:

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

4. Event Distribution Mechanism - Source Code Analysis

Understand the event distribution mechanism under Android from the perspective of source code

1. First, see the source code of the dispatchTouchEvent() method in Activity:

 public boolean dispatchTouchEvent(MotionEvent ev) {
 // If it is an ACTION_DOWN event, this statement will be executed. The onUserInteraction() method is empty in the system.
    if (ev.getAction() == MotionEvent.ACTION_DOWN) {
 onUserInteraction();
 }
 /**
 * Mainly look at this line of code
 * getWindow() means getting the PhoneWindow object which is a subclass of Window
 * That is to say, call the superDispatchTouchEvent(ev) method in PhoneWindow to determine whether there is a control processing the event
 */
    if (getWindow().superDispatchTouchEvent(ev)) {
 return true ;
 }
 // If no control can handle the event, follow this line of code and call the onTouchEvent() method of the Activity to handle the event
 return onTouchEvent(ev);
 }

2. Then enter PhoneWindow and check the superDispatchTouchEvent(ev) method:

 @Override
 public boolean superDispatchTouchEvent(MotionEvent event) {
 return mDecor.superDispatchTouchEvent(event);
 }

In the superDispatchTouchEvent(ev) method of the PhoneWindow class, the superDispatchTouchEvent(ev) method of the mDecor object is directly called. mDecor is actually an object that inherits from the DecorView of FrameLayout. The source code of the definition of the DecorView class is posted in the blog "Activity Composition".

Next, look at the superDispatchTouchEvent(ev) method in the class:

 public boolean superDispatchTouchEvent(MotionEvent event) {
 return super.dispatchTouchEvent(event);
 }

There is only one line of code, super.dispatchTouchEvent(event), which calls the parent class's dispatchTouchEvent(event) method, which is FrameLayout's dispatchTouchEvent(event) method. If you check the FrameLayout class, you will find that FrameLayout does not override the dispatchTouchEvent(event) method, so it uses the dispatchTouchEvent(event) method in ViewGroup.

This fully explains that when Activity distributes events, it calls the dispatchTouchEvent() method in ViewGroup.

3. Check the dispatchTouchEvent() method in ViewGroup:

 @Override
 public boolean dispatchTouchEvent(MotionEvent ev) {
 ...
 boolean handled = false ;
 // Filter touch safety policy. If it is false (when the window or control is covered), directly exit the touch event
 // Returns True if the event should be dispatched (calling onTouch() or onTouchEvdent() method); returns false if the event should be deleted
    if (onFilterTouchEventForSecurity(ev)) {
 ...
 /**
 * If it is a DOWN event, set mFirstTouchTarget to null first.
 * Then reset the state in the resetTouchState() method
 */
        if (actionMasked == MotionEvent.ACTION_DOWN) {
            cancelAndClearTouchTargets(ev);
            resetTouchState();
 }
 // Define the variable intercepted to mark whether ViewGroup intercepts the transmission of Touch events.
        final boolean intercepted;
 // The event is ACTION_DOWN or mFirstTouchTarget is not null (a control consumes touch events)
        if (actionMasked == MotionEvent.ACTION_DOWN || mFirstTouchTarget != null ) {
 //Judge the disallowIntercept flag
            final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
 //When interception is not prohibited
            if (!disallowIntercept) {
 //Call onInterceptTouchEvent(ev) method and assign the return value to intercepted
                intercepted = onInterceptTouchEvent(ev);
                ev.setAction( action );
 } else {
 //When interception is prohibited, specify intercepted = false to indicate that the event will not be intercepted
                intercepted = false ;
 }
 } else {
 //When the event is not ACTION_DOWN and mFirstTouchTarget is null (no control consumes touch events)
 //Set intercepted = true to indicate that ViewGroup performs Touch event interception operations.
            intercepted = true ;
 }
 ...
 // Event distribution
        final boolean split = (mGroupFlags & FLAG_SPLIT_MOTION_EVENTS) != 0;
        TouchTarget newTouchTarget = null ;
        boolean alreadyDispatchedToNewTouchTarget = false ;
 //It is not an ACTION_CANCEL event and intercepted is false (ViewGroup does not intercept the event onInterceptTouchEvent() method returns false )
        if (!canceled && !intercepted) {
 //Handle ACTION_DOWN event
            if (actionMasked == MotionEvent.ACTION_DOWN
                || (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)
                || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
                final int actionIndex = ev.getActionIndex();
                final int idBitsToAssign = split ? 1 << ev.getPointerId(actionIndex):TouchTarget.ALL_POINTER_IDS;
                removePointersFromTouchTargets(idBitsToAssign);
                final int childrenCount = mChildrenCount;
                if (childrenCount != 0) {
 // Find the child control based on the Touch coordinates to consume the Touch event
                    final View [] children = mChildren;
                    final float x = ev.getX(actionIndex);
                    final float y = ev.getY(actionIndex);
                    final boolean customOrder = isChildrenDrawingOrderEnabled();
 // Traverse all child controls to determine which one consumes the Touch event
 for ( int i = childrenCount - 1; i >= 0; i --) {
                        final int childIndex = customOrder ? getChildDrawingOrder(childrenCount, i) : i;
                        final View child = children[childIndex];
                        if (!canViewReceivePointerEvents(child) || !isTransformedTouchPointInView(x, y, child, null )) {
 continue ;
 }
                        newTouchTarget = getTouchTarget(child);
                        if (newTouchTarget != null ) {
 // Find the child control that consumes the Touch event, jump out of the loop, and use newTouchTarget to represent the child control
                            newTouchTarget.pointerIdBits |= idBitsToAssign;
                            break;
 }
                        resetCancelNextUpFlag(child);
 // Without jumping out of the loop, at this step, the dispatchTransformedTouchEvent() method will be called to pass the event to the child control for recursive processing. The third parameter is not null
                        if (dispatchTransformedTouchEvent(ev, false , child, idBitsToAssign)) {
                           ...
 }
 }
 }
 /**
 * If there is no child control consuming the event in the loop and the previous mFirstTouchTarget is not empty
 */
                if (newTouchTarget == null && mFirstTouchTarget != null ) {
 // Assign mFirstTouchTarget to newTouchTarget
                    newTouchTarget = mFirstTouchTarget;
                    while (newTouchTarget. next != null ) {
                        newTouchTarget = newTouchTarget.next ;
 }
 // newTouchTarget points to the original TouchTarget
                    newTouchTarget.pointerIdBits |= idBitsToAssign;
 }
 }
 }
 /**
 * Distribute Touch events to the target control (target). The above process is mainly for ACTION_DOWN.
 * If not (judged in the previous step), such as ACTION_MOVE and ACTION_UP, execution starts from here
 */
        if (mFirstTouchTarget == null ) {
 /**
 * mFirstTouchTarget is null , which means the Touch event has not been consumed or has been intercepted.
 * Call the dispatchTransformedTouchEvent() method of ViewGroup, recursively process, and the third parameter is null
 */
            handled = dispatchTransformedTouchEvent(ev, canceled, null ,TouchTarget.ALL_POINTER_IDS);
 } else {
 /**
 * mFirstTouchTarget is not null , indicating that a child View that can consume Touch events has been found
 * And the MOVE or UP event can be passed to the child View
 */
            TouchTarget predecessor = null ;
 // Assign the found mFirstTouchTarget that can consume events to the target control (target)
            TouchTarget target = mFirstTouchTarget;
            while (target != null ) {
                final TouchTarget next = target. next ;
 // If it has been distributed to a new control and the target control of the consumption event is the new control
                if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
                    handled = true ;
 } else {
                    final boolean cancelChild = resetCancelNextUpFlag(target.child) || intercepted;
 // Otherwise, call the dispatchTransformedTouchEvent() method for recursive processing, and the third parameter is not null
                    if (dispatchTransformedTouchEvent(ev, cancelChild, target.child, target.pointerIdBits)) {
                        handled = true ;
 }
 ...
 }
                predecessor = target;
                target = next ;
 }
 }
 /**
 * If it is ACTION_UP and ACTION_CANCEL events, restore the state
 */
        if (canceled|| actionMasked == MotionEvent.ACTION_UP
                    || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
            resetTouchState();
        } else if (split && actionMasked == MotionEvent.ACTION_POINTER_UP) {
 ...
 }
 }
 ...
 return handled;
 }

We can see that in the above method, onInterceptTouchEvent() is called to determine whether the event needs to be intercepted.

Check out the dispatchTransformedTouchEvent() method in ViewGroup:

 private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
 View child, int desiredPointerIdBits) {
 final boolean handled;
 ...
 if (child == null ) {
 // If the child control is empty, call the View 's dispatchTouchEvent() method, and the onTouchEvent() method will be called in the View 's dispatchTouchEvent() method
            handled = super.dispatchTouchEvent(event);
 } else {
 // If the child control is not empty, call the dispatchTouchEvent() method of the child control
 // Here the child control may also be a ViewGroup, so just continue to call the dispatchTouchEvent() method of ViewGroup
            handled = child.dispatchTouchEvent(event);
 }
        event.setAction(oldAction);
 return handled;
 }
 ...
    transformedEvent.recycle();
 return handled;
 }
 Check the onInterceptTouchEvent() method in ViewGroup:
 public boolean onInterceptTouchEvent(MotionEvent ev) {
 return false ;
 }

In ViewGroup, the onTouchEvent() method is not overridden, so the onTouchEvent() method in View is called.

4. In the View class, first look at the dispatchTouchEvent() method in View:

 public boolean dispatchTouchEvent(MotionEvent event) {
    // If the event should be handled by accessibility focus first .
    if (event.isTargetAccessibilityFocus()) {
        // We don't have focus or no virtual descendant has it, do not handle the event.
        if (!isAccessibilityFocusedViewOrHost()) {
 return false ;
 }
        // We have focus and got the event, then use normal event dispatch.
        event.setTargetAccessibilityFocus( false );
 }
 boolean result = false ;
    if (mInputEventConsistencyVerifier != null ) {
        mInputEventConsistencyVerifier.onTouchEvent(event, 0);
 }
 // If it is a DOWN event, reset the state
    final int actionMasked = event.getActionMasked();
    if (actionMasked == MotionEvent.ACTION_DOWN) {
 stopNestedScroll();
 }
 // Filter touch safety policy. If it is false (when the window or control is covered), directly exit the touch event
 // Returns True if the event should be dispatched (calling onTouch() or onTouchEvdent() method); returns false if the event should be deleted
    if (onFilterTouchEventForSecurity(event)) {
        ListenerInfo li = mListenerInfo;
        if (li != null && li.mOnTouchListener != null
                && (mViewFlags & ENABLED_MASK) == ENABLED
                && li.mOnTouchListener.onTouch(this, event)) {
 // If the current control is enabled and the View calls the setOnTouchListener() method and returns true , then set result to true
 result = true ;
 }
 // result is false , indicating that the setOnTouchListener() method has not been called or the method returns false , then call
 // View 's onTouchEvent() method
        if (!result && onTouchEvent(event)) {
 result = true ;
 }
 }
    if (!result && mInputEventConsistencyVerifier != null ) {
        mInputEventConsistencyVerifier.onUnhandledEvent(event, 0);
 }
 // If it is an UP event, CANCEL event, or DOWN event but the control cannot consume the event, reset the state
    if (actionMasked == MotionEvent.ACTION_UP ||
            actionMasked == MotionEvent.ACTION_CANCEL ||
            (actionMasked == MotionEvent.ACTION_DOWN && !result)) {
 stopNestedScroll();
 }
 return result;
 }

Finally, check the onTouchEvent() method of View:

 public boolean onTouchEvent(MotionEvent event) {
    final float x = event.getX();
    final float y = event.getY();
    final int viewFlags = mViewFlags;
    final int action = event.getAction();
 // Determine whether there is a single click or long press event
    final boolean clickable = ((viewFlags & CLICKABLE) == CLICKABLE
            || (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)
            || (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE;
    if ((viewFlags & ENABLED_MASK) == DISABLED) {
        if ( action == MotionEvent.ACTION_UP && (mPrivateFlags & PFLAG_PRESSED) != 0) {
            setPressed( false );
 }
        mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
 // The control is disabled. It can still consume touch events, but it will not respond to them.
 return clickable;
 }
 // If there is a proxy, call the proxy method
    if (mTouchDelegate != null ) {
        if (mTouchDelegate.onTouchEvent(event)) {
 return true ;
 }
 }
 // Specific processing of click events. As long as there is a click event, the onTouchEvent() method returns true
    if (clickable || (viewFlags & TOOLTIP) == TOOLTIP) {
 switch ( action ) {
 case MotionEvent.ACTION_UP:
 // ...
 // mHasPerformedLongPress indicates the return value of the long press event. If the callback method of the long press event returns true , then the click event will not be called in the same event sequence (otherwise it will respond to both the long press event and the click event)
                    if (!mHasPerformedLongPress && !mIgnoreNextUpEvent) {
                        // This is a tap, so remove the longpress check
                        removeLongPressCallback();
                        // Only perform take click actions if we were in the pressed state
                        if (!focusTaken) {
                            // Use a Runnable and post this rather than calling
                            // performClick directly. This lets other visual state
                            // of the view update before click actions start.
                            if (mPerformClick == null ) {
                                mPerformClick = new PerformClick();
 }
                            if (!post(mPerformClick)) {
 performClickInternal(); // will call the performClick() method to handle the click event
 }
 }
 }
                    if (mUnsetPressedState == null ) {
                        mUnsetPressedState = new UnsetPressedState();
 }
                    if (prepressed) {
                        postDelayed(mUnsetPressedState,
                                ViewConfiguration.getPressedStateDuration());
                    } else if (!post(mUnsetPressedState)) {
                        // If the post failed, unpress right now
                        mUnsetPressedState.run();
 }
                    removeTapCallback();
 }
                mIgnoreNextUpEvent = false ;
 break;
 case MotionEvent.ACTION_DOWN:
                if (event.getSource() == InputDevice.SOURCE_TOUCHSCREEN) {
                    mPrivateFlags3 |= PFLAG3_FINGER_DOWN;
 }
                mHasPerformedLongPress = false ;
                if (!clickable) {
                    checkForLongClick(0, x, y);
 break;
 }
                if (performButtonActionOnTouchDown(event)) {
 break;
 }
                // Walk up the hierarchy to determine if we're inside a scrolling container.
                boolean isInScrollingContainer = isInScrollingContainer();
 // Depending on whether it is in the scroll container, use different methods to call the callback of the long press event
                if (isInScrollingContainer) {
                    mPrivateFlags |= PFLAG_PREPRESSED;
                    if (mPendingCheckForTap == null ) {
 mPendingCheckForTap = new CheckForTap(); // Finally call the long press event callback
 }
                    mPendingCheckForTap.x = event.getX();
                    mPendingCheckForTap.y = event.getY();
                    postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());
 } else {
                    // Not inside a scrolling container, so show the feedback right away
                    setPressed( true , x, y);
 checkForLongClick(0, x, y); // Finally call the long press event callback
 }
 break;
 case MotionEvent.ACTION_CANCEL:
 // ...
 break;
 }
 // As long as there is a click event, the onTouchEvent() method returns true
 return true ;
 }
 return false ;
 }

From the above code, as long as one of the View's CLICLABLE and LONG_CLICKABLE is true, the onTouchEvent() method will return true, regardless of whether the View is in DISABLE state, otherwise it returns false. True means that the control can consume events, and false means that the control cannot consume events. Now, looking back at the first picture, is it clearer?

5. Finally, for the default values ​​of CLICKABLE and LONG_CLICKABLE of View, the default value of LONG_CLICKABLE is false, but for CLICKABLE, it depends on the specific View. To be precise, the CLICKABLE value of a clickable View is true, such as Button, and the CLICKABLE value of a non-clickable View is false, such as TextView. However, when we call the setOnClickListener(@Nullable OnClickListener l) method or the setOnLongClickListener(@Nullable OnLongClickListener l) method of View, the corresponding value will be changed to true.

 public void setOnClickListener(@Nullable OnClickListener l) {
 if (!isClickable()) {
 setClickable( true );
 }
    getListenerInfo().mOnClickListener = l;
 }
 public void setOnLongClickListener(@Nullable OnLongClickListener l) {
 if (!isLongClickable()) {
        setLongClickable( true );
 }
    getListenerInfo().mOnLongClickListener = l;
 }

Summarize

• For the disatchTouchEvent() and onTouchEvent() methods of ViewGroup and View, return true means processing the event and the event ends; return false means not processing the event and letting the event pass back to the onTouchEvent() method of the upper layer, that is, the onTouchEvent() method in the parent control;
• For the disatchTouchEvent() method of Activity, if it is not overridden, it will start distributing events by calling the disatchTouchEvent() method of ViewGroup. If it is overridden, the event will be consumed regardless of whether it returns true or false, and the event will not be distributed downward;
• For the dispatchTouchEvent() method, if the developer does not rewrite it, the default implementation in the system will be used. In ViewGroup, the onInterceptTouchEvent() method of ViewGroup will be called, and in View, the event will be directly dispatched to the onTouchEvent() method of View for processing;
• For ViewGroup, if ViewGroup wants to handle events by itself, it needs to override the onInterceptTouchEvent() method and return true, so as to terminate the event transmission and call the onTouchEvent() method of ViewGroup to handle the event. Otherwise, the system onInterceptTouchEvent() method is called, and the system default return value is false, and the event is not processed and passed on.
• For View, there is no onInterceptTouchEvent() method in View, because it has no child controls and does not need to be intercepted. The system will dispatch the event to the onTouchEvent() method of View by default in the dispatchTouchEvent() method;
• In Android, the first to get the event is the Activity, and then the Activity's dispatchTouchEvent() method starts to distribute the event;
• If an event is sent from the Activity, but all controls do not handle the event, it will eventually return to the onTouchEvent() method of the Activity. If the Activity does not consume the event, the event will be lost.