Android event distribution mechanism

Event distribution mechanism

Android event distribution refers to the process in which the system passes these events to the correct view or component for processing when the user touches the screen or performs other operations in the Android system.

Android event distribution follows a rule called "event distribution mechanism", which consists of three main stages: touch event capture stage, target view processing stage and bubbling stage.

In the capture phase of touch events, events start from the top-level view (such as Activity) and are passed down level by level until the bottom-level subview is found. In this process, each view has the opportunity to intercept the event. If a view intercepts the event, the subsequent views will not be able to receive the event.

In the processing phase of the target view, the event is passed to the bottom-level child view and processed by that view. If the view does not handle the event, the event is passed to its parent view until a view that can handle the event is found.

In the bubbling phase, the event bubbles up from the bottom view until it reaches the top view. In this process, each view has the opportunity to handle the event. If a view handles the event, the subsequent view will not receive the event.

Through this event distribution mechanism, the Android system can accurately pass the user's operation to the correct view or component for processing, thereby realizing the interaction between the user and the application. In actual development, we can customize the event processing logic by rewriting the relevant methods of the view (such as onTouchEvent()) to meet specific needs.

Objects involved

1. View: View is the basic UI component in Android. It is responsible for receiving user input events (such as clicks, touches, etc.) and passing the events to the corresponding processing methods.
2. ViewGroup: ViewGroup is a subclass of View, which can contain other Views or ViewGroups. When an event occurs on a ViewGroup, it traverses its child Views and passes the event to the appropriate child View.
3. MotionEvent: MotionEvent is an event object in Android, which encapsulates the user's touch event information, including the coordinates of the touch point, the touch action, etc.
4. MotionEventCompat: MotionEventCompat is a compatibility class used to handle touch event compatibility issues between different Android versions.
5. GestureDetector: GestureDetector is a gesture detector provided by Android, which can recognize user gesture operations such as sliding, long pressing, double-clicking, etc.
6. OnTouchListener: OnTouchListener is an interface used to listen to the touch events of View. By implementing this interface, you can customize the processing logic of touch events.

The above are some key objects in event distribution, which work together to implement the event distribution mechanism in Android.

MotionEvent

MotionEvent is a class in Android that handles events related to user interaction, such as touching the screen, pressing a button, etc. It contains a series of constants and methods for obtaining information such as event type, coordinates, time, etc. By listening to MotionEvent, developers can respond to and process user touch operations.

The following are some commonly used MotionEvent methods:

• getAction(): Gets the action type of a touch event and returns an integer value. You can use constants such as MotionEvent.ACTION_DOWN, MotionEvent.ACTION_MOVE, and MotionEvent.ACTION_UP to determine the specific type of a touch event.
• getDownTime(): Gets the time (in milliseconds) when the screen is just pressed. This time remains unchanged after pressing.
• getEventTime(): Gets the time (in milliseconds) when the event in which the MotionEvent is located is triggered
• getX() and getY(): Get the horizontal and vertical coordinates of the location where the touch event occurred. The coordinates returned are relative to the location where the touch event occurred.
• getRawX() and getRawY(): Get the original horizontal and vertical coordinates of the location where the touch event occurred. The coordinate values ​​returned are relative to the screen.
• getPointerCount(): Gets the number of fingers in a touch event.
• getPointerId(int pointerIndex): Gets the ID of the finger at the specified index.
• getPressure(int pointerIndex): Gets the pressure value of the finger at the specified index.
• getHistorySize(): Gets the number of touch event history records.
• getHistoricalX(int pointerIndex, int pos) and getHistoricalY(int pointerIndex, int pos): Get the horizontal and vertical coordinates of the finger with the specified index at the specified historical record position.

These methods can help developers obtain relevant information about touch events and perform corresponding processing.

MotionEvent#getAction() type

The MotionEvent#getAction() method returns an integer indicating the type of the current touch event. The specific types are as follows:

• ACTION_DOWN: Event triggered when a finger presses the screen
• ACTION_MOVE: Event triggered when a finger slides on the screen
• ACTION_UP: The event triggered when the finger leaves the screen
• ACTION_CANCEL: Event triggered when a touch event is canceled
• ACTION_OUTSIDE: Out of area

These types can be compared with the constants defined in the MotionEvent class to determine the type of the current touch event. For example, you can use the following code to determine whether the current event is a press event:

 if (event.getAction() == MotionEvent.ACTION_DOWN) { // 处理按下事件的逻辑}

Example: Event flow from finger touching the screen to leaving the screen

picture

Event dispatching between objects

In Android, event distribution is implemented through the View event distribution mechanism. When the user touches the screen or performs other operations, the event will be passed down from the top ViewGroup until a suitable View is found to handle the event.

Event distribution in Android involves the following objects:

1. Activity: Activity is a component of an Android application that is responsible for managing the user interface and handling user interactions. When the user touches the screen or performs other operations, the event is first passed to the currently displayed Activity.
2. Window: Window is a property of Activity, which represents a window used to display the user interface of Activity. Events are first passed to Window, which is then responsible for passing the events to the corresponding View.
3. View: View is the basic UI component in Android and is used to build user interfaces. Each View has an event distribution responsibility. It can handle events of interest to itself or pass events to other Views.
4. ViewGroup: ViewGroup is a subclass of View that manages the layout and display of other Views. When an event is passed to a ViewGroup, it traverses its own subViews and passes the event to the appropriate subView.

During the event distribution process, each object has the opportunity to handle the event. If an object handles the event, the event will stop being passed. If an object does not handle the event, the event will continue to be passed down until a suitable handler is found or the event is passed to the bottom-level View.

You can implement event distribution and delivery by overriding the dispatchTouchEvent() method of View. In this method, you can call the super.dispatchTouchEvent() method to pass the event to the parent View or call the onTouchEvent() method of View to handle the event as needed.

Event distribution in Android is achieved through collaboration between objects such as Activity, Window, View, and ViewGroup. Each object has the opportunity to handle events, and event delivery and processing can be achieved by reasonably rewriting related methods.

Analysis of event distribution mechanism

From the above article, we know that the delivery process of Android event distribution mechanism can be divided into three stages: distribution, interception and processing.

1. Dispatch phase: Events are first dispatched by the dispatchTouchEvent() method of Activity or ViewGroup. In this method, the event will be passed to the onInterceptTouchEvent() method of the current ViewGroup for interception judgment. If onInterceptTouchEvent() returns true, it means that the current ViewGroup intercepts the event and no longer passes it down; if it returns false, it means that the current ViewGroup does not intercept the event and continues to pass it down.
2. Interception phase: If the current ViewGroup does not intercept the event, the event will continue to be passed down to the child View. The dispatchTouchEvent() method of the child View will be called, and will also be judged by the onInterceptTouchEvent() method. If the child View intercepts the event, the event will no longer be passed down to other child Views, but will be handed over to the onTouchEvent() method of the child View for processing; if the child View does not intercept the event, the event will continue to be passed down.
3. Processing stage: If the event is not intercepted by any ViewGroup or View, it will eventually be passed to the onTouchEvent() method of the bottom-level View for processing. In this method, you can perform corresponding processing operations based on the type of event (such as touch, slide, click, etc.).

The transmission process of the Android event distribution mechanism is a recursive process from top to bottom. The event will be intercepted and judged by the parent ViewGroup and the child View in turn, and finally reach the bottom View for processing. In this process, you can intercept and process the event by rewriting the relevant methods, so as to realize the customized interaction logic.

Activity event distribution mechanism

The event distribution mechanism of Activity is implemented through the hierarchical relationship between ViewGroup and View. When the user touches the screen or presses a key, the system will pass the event to the root layout ViewGroup of the currently displayed Activity, and then the ViewGroup will be responsible for distributing the event to each child View for processing.

The specific event distribution process is as follows:

1. When the user touches the screen or presses a button, the event is first passed to the root layout ViewGroup of the Activity.
2. ViewGroup will call its own dispatchTouchEvent() method to handle the event. In this method, ViewGroup will handle the event accordingly based on the type of event (such as touch event, key event, etc.), for example, determining whether the event needs to be intercepted or consumed.
3. If the ViewGroup needs to intercept the event, that is, it thinks it should handle the event, then the event will stop being passed down and will be handled directly by the ViewGroup.
4. If the ViewGroup does not need to intercept the event, the event will continue to be passed down to the child View.
5. The child View will receive the event in turn and call its own dispatchTouchEvent() method to handle the event. The child View will also handle the event accordingly based on the type of event, such as determining whether the event needs to be intercepted or consumed.
6. If the child View needs to intercept the event, the event will stop being passed downward and will be handled directly by the child View.
7. If the child View does not need to intercept the event, the event will continue to be passed down to the next child View until the event is consumed or passed to the last child View.
8. If the event is not ultimately consumed by any child View, the event will return to the ViewGroup, which will decide whether to consume the event based on its own circumstances.
9. If the event is not consumed in the end, it will continue to be passed to the upper layer until it is consumed or passed to the top-level Activity.

Through such an event distribution mechanism, the Android system can flexibly process user touch and key events, thereby achieving various interactive effects.

Activity source code:

 public boolean dispatchTouchEvent(MotionEvent ev) { // 开始事件都是Dwon，一般第一次都会进入到onUserInteraction if (ev.getAction() == MotionEvent.ACTION_DOWN) { onUserInteraction(); } // 若Window返回true,则会告诉Activity也返回true。true在所有touch代表着终止，不再继续往下一个事件传递了if (getWindow().superDispatchTouchEvent(ev)) { return true; } return onTouchEvent(ev); }

Let's look at getWindow().superDispatchTouchEvent(ev); Window is an abstract class, and the only implementation class is PhoneWindow. Locate superDispatchTouchEvent() of PhoneWindow.

PhoneWindow source code:

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

mDecor is the DecorView class, which is an inner class of the PhoneWindow class. DecorView is also the top-level View in the entire Window.

DecorView

DecorView is a class in Android. It is a top-level view in the Android system and is used to host the user interface of an application. It is part of the Android window system and is responsible for managing the windows and layout of the application.

DecorView is a special ViewGroup that contains the entire user interface of the application, including the status bar, title bar, content area, etc. It is the root view of an Android application, and all other views are subviews of DecorView.

The main function of DecorView is to provide a container for placing the layout and controls of the application. It is also responsible for handling user input events, such as touch, slide, etc., and passing them to the corresponding subviews for processing.

In Android development, we usually do not operate DecorView directly, but manage and operate the application's user interface through Activity or Fragment. DecorView is automatically created and managed by Activity or Fragment internally, and developers only need to focus on the design and interaction logic of layout and controls.

DecorView is the root view of an Android application. It is responsible for hosting the application's user interface and providing container and event handling functions.

DecorView is a special ViewGroup, and its distribution and processing are the same as ViewGroup. Let's look at ViewGroup's superDispatchTouchEvent()

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

The entire Activity event distribution process is as follows:

picture

ViewGroup event distribution mechanism

ViewGroup is a special View that can contain other Views or ViewGroups. When a user performs a touch operation, the event will be passed to the ViewGroup, and the ViewGroup will be responsible for distributing the event to its child Views or child ViewGroups.

The event distribution mechanism of ViewGroup mainly includes the following processes:

1. Event transmission: When the user touches the screen, the event will first be passed to the top-level ViewGroup, which is the root layout of the Activity. Then, the ViewGroup will determine which child View or child ViewGroup should receive the event based on the coordinate position of the touch event.
2. Event interception: After determining the child View or child ViewGroup that receives the event, the ViewGroup will call the dispatchTouchEvent() method of the child View or child ViewGroup to pass the event to them. During this process, if the parent ViewGroup needs to intercept the event, it can be achieved by overriding the onInterceptTouchEvent() method. If the parent ViewGroup intercepts the event, the event will not be passed to the child View or child ViewGroup, but will be handled by the parent ViewGroup.
3. Event processing: When an event is passed to a child View or a child ViewGroup, they will call their own dispatchTouchEvent() method to handle the event. In this method, the child View or child ViewGroup can handle the event according to its own needs, such as responding to clicks, slides, and other operations. If the child View or child ViewGroup does not consume the event, the event will continue to be passed to the parent ViewGroup until the event is consumed or passed to the top-level ViewGroup.

The event distribution mechanism of ViewGroup is realized through the transmission, interception and processing of events. By overriding the dispatchTouchEvent() and onInterceptTouchEvent() methods, you can customize the processing of events. This mechanism can ensure the correct transmission and processing of events between ViewGroup and its child View or child ViewGroup.

The entire ViewGroup distribution process is as follows:

picture

View event distribution mechanism

The View event distribution mechanism mainly includes three key methods: dispatchTouchEvent, onInterceptTouchEvent and onTouchEvent.

1. dispatchTouchEvent: This method is a key method in the ViewGroup class and is used to dispatch touch events. When a touch event occurs, the system will first pass the event to the top-level ViewGroup, and then the ViewGroup will pass the event to the child View for processing according to certain rules. In the dispatchTouchEvent method, the system will decide which child View to pass the event to for processing based on information such as the event type and touch position.
2. onInterceptTouchEvent: This method is also a key method in the ViewGroup class, used to intercept touch events. When a touch event is passed to the ViewGroup, the ViewGroup will first call the onInterceptTouchEvent method to determine whether the event needs to be intercepted. If the onInterceptTouchEvent method returns true, it means that the ViewGroup will intercept the event and pass the event to its own onTouchEvent method for processing; if it returns false, it means that the ViewGroup will not intercept the event and will continue to pass the event to the child View for processing.
3. onTouchEvent: This method is a key method in the View class, used to handle touch events. When a touch event is passed to the View, the View will call its own onTouchEvent method to handle the event. In the onTouchEvent method, you can perform corresponding processing according to the event type, such as processing click events, sliding events, etc.

The process of View event distribution mechanism is as follows:

1. When the user touches the screen, the system passes the touch event to the top-level ViewGroup.
2. ViewGroup calls the dispatchTouchEvent method to distribute touch events.
3. In the dispatchTouchEvent method, ViewGroup will pass the event to the child View for processing according to certain rules.
4. The child View will first call the onInterceptTouchEvent method to determine whether the event needs to be intercepted.
5. If the onInterceptTouchEvent method returns true, it means that ViewGroup will intercept the event and pass the event to its own onTouchEvent method for processing.
6. If the onInterceptTouchEvent method returns false, it means that the ViewGroup will not intercept the event and will continue to pass the event to the child View for processing.
7. The child View will call its own onTouchEvent method to handle the touch event.

View#dispatchTouchEvent source code:

 public boolean dispatchTouchEvent(MotionEvent event) { ... if (li != null && li.mOnTouchListener != null && (mViewFlags & ENABLED_MASK) == ENABLED && li.mOnTouchListener.onTouch(this, event)) { result = true; } ... }

Only when all four conditions are true will true be returned, otherwise onTouchEvent() is executed. The following analyzes these four conditions one by one:

• li != null: li is ListenerInfo, which encapsulates all events, so as long as any event is assigned, it will never be null.
• mOnTouchListener != null: The mOnTouchListener variable is assigned in the View.setOnTouchListener() method, that is, as long as we register the Touch event for the control, mOnTouchListener will not be null.
• (mViewFlags & ENABLED_MASK) == ENABLED: Determine whether the currently clicked control is enabled. Since View is enabled by default, this condition is true.
• mOnTouchListener.onTouch(this, event): The onTouch() method overridden when the control registers a touch event.

If setOnTouchListener returns true, the above four conditions will be met and true will be returned, so that View.dispatchTouchEvent() will directly return true, the event distribution will end, and onTouchEvent(event) will not be executed.

View#onTouchEvent(event) source code:

 public boolean onTouchEvent(MotionEvent event) { ... // clickable代表该控件是否可点击，可点击就进入下面条件判断if (clickable || (viewFlags & TOOLTIP) == TOOLTIP) { switch (action) { // 1. 当前的事件= 抬起View case MotionEvent.ACTION_UP: // 经过种种判断，此处省略........ if (!focusTaken) { // 执行performClick() if (mPerformClick == null) { mPerformClick = new PerformClick(); } if (!post(mPerformClick)) { performClickInternal(); } } break; // 2. 当前的事件= 按下View case MotionEvent.ACTION_DOWN: // 经过种种判断，此处省略break; // 3. 当前的事件= 结束事件（非人为原因） case MotionEvent.ACTION_CANCEL: // 经过种种判断，此处省略break; // 4. 当前的事件= 滑动View case MotionEvent.ACTION_MOVE: // 经过种种判断，此处省略break; } // 若该控件可点击，就一定返回true return true; } // 若该控件不可点击，就一定返回false return false; ... }

The entire View distribution process is as follows:

picture

Summarize

picture

dispatchTouchEvent

dispatchTouchEvent is used to distribute touch events. It is a method in the ViewGroup class that is used to pass touch events to child Views or process its own touch events.

The transmission of touch events is achieved through the touch event distribution mechanism. When the user touches the screen, the system will pass the touch event to the top-level ViewGroup, which is then responsible for passing the touch event to the child View or processing its own touch event.

The function of the dispatchTouchEvent method is to distribute touch events to child Views or process its own touch events. It determines whether to pass the touch event to a child View or process its own touch event based on the type and location of the touch event.

In the dispatchTouchEvent method, the onInterceptTouchEvent method and the onTouchEvent method are called in sequence to determine whether to intercept the touch event and process the touch event. If the onInterceptTouchEvent method returns true, it means that the touch event is intercepted and the touch event is no longer passed to the child View; if the onTouchEvent method returns true, it means that the touch event is processed and the touch event is no longer passed to the child View.

onTouchEvent

onTouchEvent is used to handle touch events. It is a member method of the View class and can be overridden to implement custom touch event processing logic.

Touch events include pressing (ACTION_DOWN), moving (ACTION_MOVE), lifting (ACTION_UP), etc. When the user touches the screen, the system passes the touch event to the corresponding View and calls the onTouchEvent method of the View to handle the event.

In the onTouchEvent method, you can perform corresponding processing according to different touch actions, such as drawing according to the touch position, processing sliding events, processing click events, etc. You can implement custom touch interaction effects by overriding the onTouchEvent method.

Rewrite the onTouchEvent method to handle touch events:

 @Override public boolean onTouchEvent(MotionEvent event) { int action = event.getAction(); switch (action) { case MotionEvent.ACTION_DOWN: // 处理按下事件break; case MotionEvent.ACTION_MOVE: // 处理移动事件break; case MotionEvent.ACTION_UP: // 处理抬起事件break; } return true; }

It should be noted that the return value of the onTouchEvent method is of boolean type. If it returns true, it means that the touch event has been processed and will not be passed to other Views; if it returns false, the touch event will be passed to the parent View or other related Views for processing.

onInterceptTouchEvent

onInterceptTouchEvent is used to intercept touch events. It is usually used by parent containers to intercept and process touch events of child Views.

Touch events are generated by touch points on the screen, including actions such as pressing, moving, and lifting. When a touch event occurs, the system will pass the event to the top-level View and distribute it through the dispatchTouchEvent method. During the distribution process, if the onInterceptTouchEvent method of the parent container returns true, it means that the parent container will intercept the event and no longer pass the event to the child View; if it returns false, it means that the parent container will not intercept the event and continue to pass the event to the child View.

The return value of the onInterceptTouchEvent method determines whether to intercept the touch event. It has three possible return values:

• Return true: Indicates that the parent container will intercept the touch event and no longer pass it to the child View.
• Return false: indicates that the parent container does not intercept the touch event and continues to pass it to the child View.
• Return super.onInterceptTouchEvent(event): indicates that the parent container does not intercept the touch event and continues to process it in the default way.

By processing touch events in the onInterceptTouchEvent method, we can implement some specific touch event logic, such as sliding conflict handling, multi-finger touch event handling, etc.

setOnTouchListener

setOnTouchListener is a method used to set a touch event listener to handle touch events.

Use the setOnTouchListener method to set a touch event listener for a control (such as Button, ImageView, etc.). When the user touches the control, the touch event listener will be triggered and perform the corresponding operation.

Sample code:

 button.setOnTouchListener(new View.OnTouchListener() { @Override public boolean onTouch(View v, MotionEvent event) { // 处理触摸事件的逻辑代码return true; // 返回true表示已经处理了触摸事件，false表示未处理} });

button is the view object for which the touch event listener is to be set. The setOnTouchListener method accepts a View.OnTouchListener object as a parameter, which implements the onTouch method for handling touch events.

In the onTouch method, you can write your own touch event processing logic. Depending on the different actions of the MotionEvent object (such as pressing, moving, lifting, etc.), you can perform corresponding operations. Finally, you need to return a Boolean value to indicate whether the touch event has been processed.

The setOnTouchListener method can be used to handle various touch events, such as dragging, zooming, sliding, etc. According to specific needs, you can write corresponding code logic in the onTouch method.