@UnsupportedAppUsage
      void enqueueInputEvent(InputEvent event,
              InputEventReceiver receiver, int flags, boolean processImmediately) {
          QueuedInputEvent q = obtainQueuedInputEvent(event, receiver, flags);
          if (event instanceof MotionEvent) {
              MotionEvent me = (MotionEvent) event;
              if (me.getAction() == MotionEvent.ACTION_CANCEL) {
                  EventLog.writeEvent(EventLogTags.VIEW_ENQUEUE_INPUT_EVENT, "Motion - Cancel",
                          getTitle().toString());
              }
          } else if (event instanceof KeyEvent) {
              KeyEvent ke = (KeyEvent) event;
              if (ke.isCanceled()) {
                  EventLog.writeEvent(EventLogTags.VIEW_ENQUEUE_INPUT_EVENT, "Key - Cancel",
                          getTitle().toString());
              }
          }
          // Always enqueue the input event in order, regardless of its time stamp.
          // We do this because the application or the IME may inject key events
          // in response to touch events and we want to ensure that the injected keys
          // are processed in the order they were received and we cannot trust that
          // the time stamp of injected events are monotonic.
          QueuedInputEvent last = mPendingInputEventTail;
          if (last == null) {
              mPendingInputEventHead = q;
              mPendingInputEventTail = q;
          } else {
              last.mNext = q;
              mPendingInputEventTail = q;
          }
          mPendingInputEventCount += 1;
          Trace.traceCounter(Trace.TRACE_TAG_INPUT, mPendingInputEventQueueLengthCounterName,
                  mPendingInputEventCount);
          //添加log打印關鍵信息
          Log.i(">_<!!","enqueueInputEvent: event = " + event + " ,this = " + this);
          if (processImmediately) {
              doProcessInputEvents();
          } else {
              scheduleProcessInputEvents();
          }
      }

  bool InputDispatcher::dispatchKeyLocked(nsecs_t currentTime, std::shared_ptr<KeyEntry> entry,
                                          DropReason* dropReason, nsecs_t* nextWakeupTime) {
      // Preprocessing.
      if (!entry->dispatchInProgress) {
          // 這個是AOSP的log機制，不用再另外添加log
          logOutboundKeyDetails("dispatchKey - ", *entry);
      }
  void InputDispatcher::logOutboundKeyDetails(const char* prefix, const KeyEntry& entry) {
      //if (DEBUG_OUTBOUND_EVENT_DETAILS) {
        if (true) {
          ALOGD("%seventTime=%" PRId64 ", deviceId=%d, source=0x%x, displayId=%" PRId32 ", "
                "policyFlags=0x%x, action=0x%x, flags=0x%x, keyCode=0x%x, scanCode=0x%x, "
                "metaState=0x%x, repeatCount=%d, downTime=%" PRId64,
                prefix, entry.eventTime, entry.deviceId, entry.source, entry.displayId,
                entry.policyFlags, entry.action, entry.flags, entry.keyCode, entry.scanCode,
                entry.metaState, entry.repeatCount, entry.downTime);
      }
  }

                                       int32_t usageCode) {
      int32_t keyCode;
      int32_t keyMetaState;
      uint32_t policyFlags;
      if (getDeviceContext().mapKey(scanCode, usageCode, mMetaState, &keyCode, &keyMetaState,
                                    &policyFlags)) {
          keyCode = AKEYCODE_UNKNOWN;
          keyMetaState = mMetaState;
          policyFlags = 0;
      }
      if (mParameters.handlesKeyRepeat) {
          policyFlags |= POLICY_FLAG_DISABLE_KEY_REPEAT;
      }
      NotifyKeyArgs args(getContext()->getNextId(), when, readTime, getDeviceId(), mSource,
                         getDisplayId(), policyFlags,
                         down ? AKEY_EVENT_ACTION_DOWN : AKEY_EVENT_ACTION_UP,
                         AKEY_EVENT_FLAG_FROM_SYSTEM, keyCode, scanCode, keyMetaState, downTime);
      getListener().notifyKey(&args);
      ALOGI("device: %s, keyCode=%d, scanCode=%d， eventTime = %lld, action=0x%x,duwnTime=%lld",getDeviceName().c_str(), keyCode, scanCode, args,eventTime, args.action. args.downTime);
  }

  void InputDispatcher::dumpDispatchStateLocked(std::string& dump) {
      dump += StringPrintf(INDENT "DispatchEnabled: %s\n", toString(mDispatchEnabled));
      dump += StringPrintf(INDENT "DispatchFrozen: %s\n", toString(mDispatchFrozen));
      dump += StringPrintf(INDENT "InputFilterEnabled: %s\n", toString(mInputFilterEnabled));
      dump += StringPrintf(INDENT "FocusedDisplayId: %" PRId32 "\n", mFocusedDisplayId);

      public boolean dispatchKeyEvent(KeyEvent event) {
          if (mInputEventConsistencyVerifier != null) {
              mInputEventConsistencyVerifier.onKeyEvent(event, 0);
          }
     Log.i(">_<!!","dispatchKeyEvent event:" + event + " to :" + v);
          // Give any attached key listener a first crack at the event.
          //noinspection SimplifiableIfStatement
          ListenerInfo li = mListenerInfo;
          if (li != null && li.mOnKeyListener != null && (mViewFlags & ENABLED_MASK) == ENABLED
                  && li.mOnKeyListener.onKey(this, event.getKeyCode(), event)) {
              //表明input被消費了
              Log.i(">_<!!","Event：" + event+ " handle in: " + v 
                  + " ,ListenerInfo = " + li.toString());
              return true;
          }
          if (event.dispatch(this, mAttachInfo != null
                  ? mAttachInfo.mKeyDispatchState : null, this)) {
              return true;
          }
          if (mInputEventConsistencyVerifier != null) {
              mInputEventConsistencyVerifier.onUnhandledEvent(event, 0);
          }
          return false;
      }