1.源码解析

  1. /**
  2.      * Base class for implementing a stage in the chain of responsibility
  3.      * for processing input events.
  4.      * <p>
  5.      * Events are delivered to the stage by the {@link #deliver} method.  The stage
  6.      * then has the choice of finishing the event or forwarding it to the next stage.
  7.      * </p>
  8.      */
  9.     abstract class InputStage {
  10.         private final InputStage mNext;//下一个节点
  12.         protected static final int FORWARD = 0;//onProcess()处理后的结果值之一
  13.         protected static final int FINISH_HANDLED = 1;//onProcess()处理后的结果之一
  14.         protected static final int FINISH_NOT_HANDLED = 2;//onProcess()处理后的结果之一
  16.         private String mTracePrefix;//用于android SystemTrace调试使用的前缀标志字符串
  18.         /**
  19.          * Creates an input stage.
  20.          * @param next The next stage to which events should be forwarded.
  21.          */
  22.         public InputStage(InputStage next) {
  23.             mNext = next;
  24.         }
  26.         /**
  27.          * Delivers an event to be processed.
  28.          */
  29.         public final void deliver(QueuedInputEvent q) {
  30.             if ((q.mFlags & QueuedInputEvent.FLAG_FINISHED) != 0) {
  31.                 forward(q);
  32.             } else if (shouldDropInputEvent(q)) {
  33.                 finish(q, false);
  34.             } else {
  35.                 traceEvent(q, Trace.TRACE_TAG_VIEW);
  36.                 final int result;
  37.                 try {
  38.                     result = onProcess(q);
  39.                 } finally {
  40.                     Trace.traceEnd(Trace.TRACE_TAG_VIEW);
  41.                 }
  42.                 apply(q, result);
  43.             }
  44.         }
  46.         /**
  47.          * Marks the input event as finished then forwards it to the next stage.
  48.          */
  49.         protected void finish(QueuedInputEvent q, boolean handled) {
  50.             q.mFlags |= QueuedInputEvent.FLAG_FINISHED;
  51.             if (handled) {
  52.                 q.mFlags |= QueuedInputEvent.FLAG_FINISHED_HANDLED;
  53.             }
  54.             forward(q);
  55.         }
  57.         /**
  58.          * Forwards the event to the next stage.
  59.          */
  60.         protected void forward(QueuedInputEvent q) {
  61.             onDeliverToNext(q);
  62.         }
  64.         /**
  65.          * Applies a result code from {@link #onProcess} to the specified event.
  66.          */
  67.         protected void apply(QueuedInputEvent q, int result) {
  68.             if (result == FORWARD) {
  69.                 forward(q);
  70.             } else if (result == FINISH_HANDLED) {
  71.                 finish(q, true);
  72.             } else if (result == FINISH_NOT_HANDLED) {
  73.                 finish(q, false);
  74.             } else {
  75.                 throw new IllegalArgumentException("Invalid result: " + result);
  76.             }
  77.         }
  79.         /**
  80.          * Called when an event is ready to be processed.
  81.          * @return A result code indicating how the event was handled.
  82.          */
  83.         protected int onProcess(QueuedInputEvent q) {
  84.             return FORWARD;
  85.         }
  87.         /**
  88.          * Called when an event is being delivered to the next stage.
  89.          */
  90.         protected void onDeliverToNext(QueuedInputEvent q) {
  91.             if (DEBUG_INPUT_STAGES) {
  92.                 Log.v(mTag, "Done with " + getClass().getSimpleName() + ". " + q);
  93.             }
  94.             if (mNext != null) {
  95.                 mNext.deliver(q);
  96.             } else {
  97.                 finishInputEvent(q);
  98.             }
  99.         }
  101.         protected void onWindowFocusChanged(boolean hasWindowFocus) {
  102.             if (mNext != null) {
  103.                 mNext.onWindowFocusChanged(hasWindowFocus);
  104.             }
  105.         }
  107.         protected void onDetachedFromWindow() {
  108.             if (mNext != null) {
  109.                 mNext.onDetachedFromWindow();
  110.             }
  111.         }
  113.         protected boolean shouldDropInputEvent(QueuedInputEvent q) {
  114.             if (mView == null || !mAdded) {
  115.                 Slog.w(mTag, "Dropping event due to root view being removed: " + q.mEvent);
  116.                 return true;
  117.             } else if ((!mAttachInfo.mHasWindowFocus
  118.                     && !q.mEvent.isFromSource(InputDevice.SOURCE_CLASS_POINTER)
  119.                     && !isAutofillUiShowing()) || mStopped
  120.                     || (mIsAmbientMode && !q.mEvent.isFromSource(InputDevice.SOURCE_CLASS_BUTTON))
  121.                     || (mPausedForTransition && !isBack(q.mEvent))) {
  122.                 // This is a focus event and the window doesn't currently have input focus or
  123.                 // has stopped. This could be an event that came back from the previous stage
  124.                 // but the window has lost focus or stopped in the meantime.
  125.                 if (isTerminalInputEvent(q.mEvent)) {
  126.                     // Don't drop terminal input events, however mark them as canceled.
  127.                     q.mEvent.cancel();
  128.                     Slog.w(mTag, "Cancelling event due to no window focus: " + q.mEvent);
  129.                     return false;
  130.                 }
  132.                 // Drop non-terminal input events.
  133.                 Slog.w(mTag, "Dropping event due to no window focus: " + q.mEvent);
  134.                 return true;
  135.             }
  136.             return false;
  137.         }
  139.         void dump(String prefix, PrintWriter writer) {
  140.             if (mNext != null) {
  141.                 mNext.dump(prefix, writer);
  142.             }
  143.         }
  145.         private boolean isBack(InputEvent event) {
  146.             if (event instanceof KeyEvent) {
  147.                 return ((KeyEvent) event).getKeyCode() == KeyEvent.KEYCODE_BACK;
  148.             } else {
  149.                 return false;
  150.             }
  151.         }
  153.         private void traceEvent(QueuedInputEvent q, long traceTag) {
  154.             if (!Trace.isTagEnabled(traceTag)) {
  155.                 return;
  156.             }
  158.             if (mTracePrefix == null) {
  159.                 mTracePrefix = getClass().getSimpleName();
  160.             }
  161.             Trace.traceBegin(traceTag, mTracePrefix + " id=0x"
  162.                     + Integer.toHexString(q.mEvent.getId()));
  163.         }
  164.     }

由上源码可分析得到InputStage调用deliver()方法后，内部方法调用流，如下图所示：
InputStage内部方法调用流程.png
观察该图可知，InputStage调用deliver(）方法，最终可能会调用到下个节点的deliver或结束该事件的处理。也就是说具有链式传递调用的特性。
InputStage 设计成一个单向链表的节点，持有下一个节点的引用，其构造方法仅有一个，即下个节点作为参数的构造方法，在ViewRootImpl的setView(View,WindowManager.LayoutParams,View,int)方法中的最后面，创建了一条InputStage处理链，由各个InputStage的子类按顺序初始化，然后作为参数初始化下个节点，代码如下：

  1.                 // Set up the input pipeline.
  2.                 CharSequence counterSuffix = attrs.getTitle();
  3.                 mSyntheticInputStage = new SyntheticInputStage();
  4.                 InputStage viewPostImeStage = new ViewPostImeInputStage(mSyntheticInputStage);
  5.                 InputStage nativePostImeStage = new NativePostImeInputStage(viewPostImeStage,
  6.                         "aq:native-post-ime:" + counterSuffix);
  7.                 InputStage earlyPostImeStage = new EarlyPostImeInputStage(nativePostImeStage);
  8.                 InputStage imeStage = new ImeInputStage(earlyPostImeStage,
  9.                         "aq:ime:" + counterSuffix);
  10.                 InputStage viewPreImeStage = new ViewPreImeInputStage(imeStage);
  11.                 InputStage nativePreImeStage = new NativePreImeInputStage(viewPreImeStage,
  12.                         "aq:native-pre-ime:" + counterSuffix);
  13.                 mFirstInputStage = nativePreImeStage;
  14.                 mFirstPostImeInputStage = earlyPostImeStage;

由上可知构建的InputStage链结构如下：
NativePreImeInputStage ===> ViewPreImeInputStage ===> ImeInputStage ===> EarlyPostImeInputStage ===> NativePostImeInputStage ===> ViewPostImeInputStage ===> SyetheticInputStage。在创建InputStage链后，将NativePreImeInputStage对象赋值给了 mFirstInputStage，从变量名也可知其指向处理链的头部，所以要追踪哪里开始经过这个处理链，就要追踪mFirstInputStage。