Android开发之漫漫长途 Ⅵ——图解Android事件分发机制（深入底层源码）

注：上述第2第3步与第1步里的处理基本相同，但是需要注意的是Android是**串行处理事件的**，也就是说按下的动作（ACTION_DOWN|ACTION_POINTER_DOWN）处理完成之前是不会处理后续的ACTION_MOVE|ACTION_POINTER_MOVE和ACTION_UP|ACTION_POINTER_UP事件的。并且后续的ACTION_MOVE|ACTION_POINTER_MOVE和ACTION_UP|ACTION_POINTER_UP事件会根据对ACTION_DOWN|ACTION_POINTER_DOWN事件的不同而稍有不同。下面我们先来分析按下的事件ACTION_DOWN|ACTION_POINTER_DOWN的分发。

//创建INotify对象，并用描述符inotifyFd 描述它
int inotifyFd = inotify_init();
/*
    添加监听
    inotify_add_watch函数参数说明
        inotifyFd：上面建立的INotify对象的描述符，当监听的目录或文件发生变化时记录在INotify对象
        “/dev/input”：被监听的文件或者目录
        IN_CREATE | IN_DELETE：事件类型
综合起来下面的代码表示的意思就是当“/dev/input”下发生IN_CREATE | IN_DELETE（创建或者删除）时即把这个事件写入到INotify对象中
*/
int wd = inotify_add_watch(inotifyFd, "/dev/input", IN_CREATE|IN_DELETE )

`// ② 初始化mInputChanel。InputChannel是窗口接收来自InputDispatcher的输入事件的管道。这部分内容我们将在下一篇介绍。
  if ((mWindowAttributes.inputFeatures
          & WindowManager.LayoutParams.INPUT_FEATURE_NO_INPUT_CHANNEL) == 0) {
      mInputChannel = new InputChannel();
  }
  ...


  ...
// ③ 如果mInputChannel不为空，则创建mInputEventReceiver用于接收输入事件。
  if (mInputChannel != null) {

      mInputEventReceiver = new WindowInputEventReceiver(mInputChannel,
              Looper.myLooper());
  }

final class WindowInputEventReceiver extends InputEventReceiver {
        public WindowInputEventReceiver(InputChannel inputChannel, Looper looper) {
            super(inputChannel, looper);
        }
        //重写了onInputEvent方法，所以当InputChannel有事件时，会触发WindowInputEventReceiver.onInputEvent(),而其内部直接调用了enqueueInputEvent
        @Override
        public void onInputEvent(InputEvent event) {
            enqueueInputEvent(event, this, 0, true);
        }

        @Override
        public void onBatchedInputEventPending() {
            if (mUnbufferedInputDispatch) {
                super.onBatchedInputEventPending();
            } else {
                scheduleConsumeBatchedInput();
            }
        }

        @Override
        public void dispose() {
            unscheduleConsumeBatchedInput();
            super.dispose();
        }
    }

void enqueueInputEvent(InputEvent event,
            InputEventReceiver receiver, int flags, boolean processImmediately) {
        ...
        `//① 将InputEvent对应的InputEventReceiver封装为一个QueuedInputEvent 
        QueuedInputEvent q = obtainQueuedInputEvent(event, receiver, flags);
        //② 将新建的QueuedInputEvent 追加到mPendingInputEventTail所表示的一个单向链表中
        QueuedInputEvent last = mPendingInputEventTail;
        if (last == null) {
            mPendingInputEventHead = q;
            mPendingInputEventTail = q;
        } else {
            last.mNext = q;
            mPendingInputEventTail = q;
        }
        mPendingInputEventCount += 1;
       

        if (processImmediately) {
            //③ 如果第三个参数为true，则直接在当前线程中开始对输入事件的处理工作
            doProcessInputEvents();
        } else {
            //④ 否则将处理事件的请求发送给主线程的Handler，随后进行处理
            scheduleProcessInputEvents();
        }
    }

void doProcessInputEvents() {
        `//遍历整个输入事件队列，并逐一处理
        while (mPendingInputEventHead != null) {
            QueuedInputEvent q = mPendingInputEventHead;
            mPendingInputEventHead = q.mNext;
            if (mPendingInputEventHead == null) {
                mPendingInputEventTail = null;
            }
            q.mNext = null;

            mPendingInputEventCount -= 1;
            Trace.traceCounter(Trace.TRACE_TAG_INPUT, mPendingInputEventQueueLengthCounterName,
                    mPendingInputEventCount);

            long eventTime = q.mEvent.getEventTimeNano();
            long oldestEventTime = eventTime;
            if (q.mEvent instanceof MotionEvent) {
                MotionEvent me = (MotionEvent)q.mEvent;
                if (me.getHistorySize() > 0) {
                    oldestEventTime = me.getHistoricalEventTimeNano(0);
                }
            }
            mChoreographer.mFrameInfo.updateInputEventTime(eventTime, oldestEventTime);
            //deliverInputEvent()方法会将完成单个事件的整个处理流程
            deliverInputEvent(q);
        }

      ...
    }

 private int processPointerEvent(QueuedInputEvent q) {
            
            final MotionEvent event = (MotionEvent)q.mEvent;

            mAttachInfo.mUnbufferedDispatchRequested = false;
            mAttachInfo.mHandlingPointerEvent = true;
            
            // 此时ViewRootImpl会将事件的处理权移交给View树的根节点，调用dispatchPointerEvent函数  
            boolean handled = mView.dispatchPointerEvent(event);

            maybeUpdatePointerIcon(event);
            maybeUpdateTooltip(event);
            mAttachInfo.mHandlingPointerEvent = false;
            if (mAttachInfo.mUnbufferedDispatchRequested && !mUnbufferedInputDispatch) {
                mUnbufferedInputDispatch = true;
                if (mConsumeBatchedInputScheduled) {
                    scheduleConsumeBatchedInputImmediately();
                }
            }
            return handled ? FINISH_HANDLED : FORWARD;
        }

//decor即DecorView，l是布局参数WindowManager.LayoutParams
wm.addView(decor, l);

 public final boolean dispatchPointerEvent(MotionEvent event) {
        if (event.isTouchEvent()) {
            //事件如果是Touch事件，毫无疑问我们的是啊
            return dispatchTouchEvent(event);
        } else {
            return dispatchGenericMotionEvent(event);
        }
    }

@Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        //获取Window.Callback，Window.Callback是个接口，这里的mWindow是PhoneWindow，调用PhoneWindow.getCallback(),但是PhoneWindow并没有实现该方法，所以我们找到了Window.getCallBack()方法。Window.getCallBack()方法返回Callback类型的变量mCallback
        final Window.Callback cb = mWindow.getCallback();
        //如果cb不为空并且window没有被销毁 mFeatureId < 0 表示是application的DecorView，比如Activity、Dialog把事件传给cb，否则把事件传递给父类的dispatchTouchEvent
        return cb != null && !mWindow.isDestroyed() && mFeatureId < 0
                ? cb.dispatchTouchEvent(ev) : super.dispatchTouchEvent(ev);
    }

public final Callback getCallback() {
        return mCallback;
    }

 public interface Callback {
       ...`//省略一部分函数
       
        public boolean dispatchTouchEvent(MotionEvent event);
        
       ...
        
    }

 final void attach(Context context, ActivityThread aThread,
            Instrumentation instr, IBinder token, int ident,
            Application application, Intent intent, ActivityInfo info,
            CharSequence title, Activity parent, String id,
            NonConfigurationInstances lastNonConfigurationInstances,
            Configuration config, String referrer, IVoiceInteractor voiceInteractor,
            Window window, ActivityConfigCallback activityConfigCallback) {
        ......
        //创建PhoneWindow
        mWindow = new PhoneWindow(this, window, activityConfigCallback);
        
        ......
        //设置当前Activity为Window.Callback,那么毫无疑问，Activity类或者其父类实现了Window.Callback接口
        mWindow.setCallback(this);
        ......
}

 public boolean dispatchTouchEvent(MotionEvent ev) {
        if (ev.getAction() == MotionEvent.ACTION_DOWN) {
            onUserInteraction();
        }
        //在这里我们又把事件给了PhoneWindow.superDispatchTouchEvent方法根据其返回值，若返回值为true，那么dispatchTouchEvent返回true，我们Activity的onTouchEvent方法无法得到执行
        if (getWindow().superDispatchTouchEvent(ev)) {
            return true;
        }
        //这里就是我们的Activity的onTouchEvent方法
        return onTouchEvent(ev);
    }

@Override
    public boolean superDispatchTouchEvent(MotionEvent event) {
        //兜兜转转一大圈，还是把事件交给我们的DecorView，DecorView继承自FrameLayout，FrameLayout呢又继承自ViewGroup，所以作为一个ViewGroup，DecorView继续向其子View派发事件，其流程我在文章的开头就已经给了
        return mDecor.superDispatchTouchEvent(event);
    }

@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
  ......
   boolean handled = false;
   if (onFilterTouchEventForSecurity(ev)) {//表示窗口是否为模糊窗口（FILTER_TOUCHES_WHEN_OBSCURED），如果是窗口，则表示不希望处理改事件。(如dialog后的窗口)
        if (onFilterTouchEventForSecurity(ev)) {
       final int action = ev.getAction();
       final int actionMasked = action & MotionEvent.ACTION_MASK;
       /** 第①步 重新设置状态  开始*/
       // 处理初始的按下动作
       if (actionMasked == MotionEvent.ACTION_DOWN) {
           //重新设置状态等，比较重要的是设置mFirstTouchTarget == null，
           cancelAndClearTouchTargets(ev);
           resetTouchState();
       }
       /** 第①步 重新设置状态  结束*/
       
        /** 第②步 检查是否拦截  开始*/
       // 检查是否拦截
       final boolean intercepted;
       if (actionMasked == MotionEvent.ACTION_DOWN
               || mFirstTouchTarget != null) {//如果是ACTION_DOWN事件或者mFirstTouchTarget != null
            //这里我们去问ViewGroup是否允许拦截，如果允许拦截，我们再去问onInterceptTouchEvent
          ......
       } else {
           //如果不是MotionEvent.ACTION_DOWN事件并且mFirstTouchTarget 为空，直接拦截
           intercepted = true;
       }
         /** 第②步 检查是否拦截  结束*/
      ......
      /** 第③步 向子View派发  开始*/
       if (!canceled && !intercepted) {//如果没有取消并且当前ViewGroup没有拦截事件

           ......
           if (actionMasked == MotionEvent.
                        || (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)
                        || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {//判断事件类型，如果是ACTION_DOWN或者ACTION_POINTER_DOWN或者ACTION_HOVER_MOVE则进入
                        
                 if (newTouchTarget == null && childrenCount != 0) {
                     ......
                    
                          ......
                                //获取子View并循环向子View派发事件
                          if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
                          //如果当前ViewGroup的子View消费了事件，则进入if体
                          ......
                              //赋值newTouchTarget和mFirstTouchTarget 
                              newTouchTarget = addTouchTarget(child, idBitsToAssign);
                              alreadyDispatchedToNewTouchTarget = true;
                              break;
                          }
        
                }            
            
            ......
              
       }
    }
    /** 第③步 向子View派发  结束*/
    
    /** 第④步 额外的处理  开始*/
   // Dispatch to touch targets.
    if (mFirstTouchTarget == null) {
    /**这个判断十分重要：
    我们在上面的过程中就知道倘若我们没有拦截即intercepted = false;如果事件是ACTION_DOWN或者ACTION_POINTER_DOWN或者ACTION_HOVER_MOVE我们会进入循环子View并派发事件的过程，如果子View也不想处理该事件即dispatchTransformedTouchEvent()函数返回了false,那么此时ViewGroup的mFirstTouchTarget == null
    倘若我们重写了onInterceptTouchEvent并返回true，那么intercepted = true即进行拦截，那么就不会进入我们的第③步，直接来到第④步，这时当前ViewGroup的mFirstTouchTarget == null
    
    mFirstTouchTarget == null的条件下会调用dispatchTransformedTouchEvent
    */
       
        handled = dispatchTransformedTouchEvent(ev, canceled, null,
                TouchTarget.ALL_POINTER_IDS);
    } else {
       
        TouchTarget predecessor = null;
                TouchTarget target = mFirstTouchTarget;
                while (target != null) {
                    final TouchTarget next = target.next;
                    if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
                        handled = true;
                    } else {
                        final boolean cancelChild = resetCancelNextUpFlag(target.child)
                                || intercepted;
                        if (dispatchTransformedTouchEvent(ev, cancelChild,
                                target.child, target.pointerIdBits)) {
                            handled = true;
                        }
                        if (cancelChild) {
                            if (predecessor == null) {
                                mFirstTouchTarget = next;
                            } else {
                                predecessor.next = next;
                            }
                            target.recycle();
                            target = next;
                            continue;
                        }
                    }
                    predecessor = target;
                    target = next;
                }
    }
    /** 第④步 额外的处理  结束*/
       
     ......
   return handled;
}

private TouchTarget addTouchTarget(@NonNull View child, int pointerIdBits) {
        final TouchTarget target = TouchTarget.obtain(child, pointerIdBits);
        target.next = mFirstTouchTarget;
        //在这里我们可以看到mFirstTouchTarget 指向了子View
        mFirstTouchTarget = target;
        return target;
    }

private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
            View child, int desiredPointerIdBits) {
        final boolean handled;

      
        final int oldAction = event.getAction();
        if (cancel || oldAction == MotionEvent.ACTION_CANCEL) {
            event.setAction(MotionEvent.ACTION_CANCEL);
            if (child == null) {
                //child为空调用父类即View的dispatchTouchEvent
                handled = super.dispatchTouchEvent(event);
            } else {
                handled = child.dispatchTouchEvent(event);
            }
            event.setAction(oldAction);
            return handled;
        }

       
        final int oldPointerIdBits = event.getPointerIdBits();
        final int newPointerIdBits = oldPointerIdBits & desiredPointerIdBits;

   
        if (newPointerIdBits == 0) {
            return false;
        }

   
        final MotionEvent transformedEvent;
        if (newPointerIdBits == oldPointerIdBits) {
            if (child == null || child.hasIdentityMatrix()) {
                if (child == null) {
                     //child为空调用父类即View的dispatchTouchEvent
                    handled = super.dispatchTouchEvent(event);
                } else {
                    final float offsetX = mScrollX - child.mLeft;
                    final float offsetY = mScrollY - child.mTop;
                    event.offsetLocation(offsetX, offsetY);

                    handled = child.dispatchTouchEvent(event);

                    event.offsetLocation(-offsetX, -offsetY);
                }
                return handled;
            }
            transformedEvent = MotionEvent.obtain(event);
        } else {
            transformedEvent = event.split(newPointerIdBits);
        }

       
        if (child == null) {
             //child为空调用父类即View的dispatchTouchEvent
            handled = super.dispatchTouchEvent(transformedEvent);
        } else {
            final float offsetX = mScrollX - child.mLeft;
            final float offsetY = mScrollY - child.mTop;
            transformedEvent.offsetLocation(offsetX, offsetY);
            if (! child.hasIdentityMatrix()) {
                transformedEvent.transform(child.getInverseMatrix());
            }

            handled = child.dispatchTouchEvent(transformedEvent);
        }

        // Done.
        transformedEvent.recycle();
        return handled;
    }

public boolean dispatchTouchEvent(MotionEvent event) {
   
   ......

    if (onFilterTouchEventForSecurity(event)) {
        ......

        ListenerInfo li = mListenerInfo;
        if (li != null && li.mOnTouchListener != null
                && (mViewFlags & ENABLED_MASK) == ENABLED
                && li.mOnTouchListener.onTouch(this, event)) {//这里判断有没有为View是否可用Enabled并且检查是否设置了TouchListener，如果设置了，则触发TouchListener的onTouch
            result = true;
        }

        if (!result && onTouchEvent(event)) {//如果当前View没有设置listener信息，事件也没有被滚动条消费这里回调了我们的onTouchEvent。所以如果为当前View设置了TouchListenerb并在TouchListener的onTouch函数中返回了true，那么，该View的onTouchEvent将无法得到回调。
            result = true;
        }
    }

......
    return result;
}