InputDispatcher::InputDispatcher(const sp<InputDispatcherPolicyInterface>& policy)      : mPolicy(policy),
        mPendingEvent(nullptr),
        mLastDropReason(DropReason::NOT_DROPPED),
        mIdGenerator(IdGenerator::Source::INPUT_DISPATCHER),
        mAppSwitchSawKeyDown(false),
        mAppSwitchDueTime(LONG_LONG_MAX),
        mNextUnblockedEvent(nullptr),
        mDispatchEnabled(false),
        mDispatchFrozen(false),
        mInputFilterEnabled(false),
        // mInTouchMode will be initialized by the WindowManager to the default device config.
        // To avoid leaking stack in case that call never comes, and for tests,
        // initialize it here anyways.
        mInTouchMode(true),
        mFocusedDisplayId(ADISPLAY_ID_DEFAULT) {
    //创建Looper对象
    mLooper = new Looper(false);
    mReporter = createInputReporter();

    mKeyRepeatState.lastKeyEntry = nullptr;
    //获取分发超时参数,保存在mConfig
    policy->getDispatcherConfiguration(&mConfig);
}

status_t InputDispatcher::start() {    if (mThread) {
        return ALREADY_EXISTS;
    }
    mThread = std::make_unique<InputThread>(
            "InputDispatcher", [this]() { dispatchOnce(); }, [this]() { mLooper->wake(); });
    return OK;
}

void InputDispatcher::dispatchOnce() {
    nsecs_t nextWakeupTime = LONG_LONG_MAX;
    { // acquire lock
        std::scoped_lock _l(mLock);
        //唤醒所有等待线程
        mDispatcherIsAlive.notify_all();

        // haveCommandsLocked()判断消息队列mCommandQueue是否为空
        // 当mCommandQueue不为空时，则派发输入事件
        if (!haveCommandsLocked()) {
            dispatchOnceInnerLocked(&nextWakeupTime);
        }

        // 通过循环处理mCommandQueue中的所有事件.
        // 若所有事件执行完毕，将nextWakeupTime设置得极小（即当有新事件到来时立即唤醒线程）.
        if (runCommandsLockedInterruptible()) {
            nextWakeupTime = LONG_LONG_MIN;
        }

        // 检查是否发生了ANR，并返回下次执行的时间
        const nsecs_t nextAnrCheck = processAnrsLocked();
        //选择一个最小的时间，作为下次执行时间
        nextWakeupTime = std::min(nextWakeupTime, nextAnrCheck);

        // 若满足条件，进入一个无限长的睡眠，因为没有命令或挂起或排队的事件
        if (nextWakeupTime == LONG_LONG_MAX) {
            mDispatcherEnteredIdle.notify_all();
        }
    } // release lock

    // Wait for callback or timeout or wake.  (make sure we round up, not down)
    nsecs_t currentTime = now();
    int timeoutMillis = toMillisecondTimeoutDelay(currentTime, nextWakeupTime);
    mLooper->pollOnce(timeoutMillis);
}

void InputDispatcher::dispatchOnceInnerLocked(nsecs_t* nextWakeupTime) {
    //......
    switch (mPendingEvent->type) {
        case EventEntry::Type::CONFIGURATION_CHANGED: {  //配置改变
            //......
            break;
        }
        case EventEntry::Type::DEVICE_RESET: {  //设备重置
            //......
            break;
        }
        case EventEntry::Type::FOCUS: {  
            //焦点变化
            break;
        }
        case EventEntry::Type::KEY: {  //按键输入
            KeyEntry* typedEntry = static_cast<KeyEntry*>(mPendingEvent);
            //......
            done = dispatchKeyLocked(currentTime, typedEntry, &dropReason, nextWakeupTime);
            break;
        }
        case EventEntry::Type::MOTION: {  //触屏输入
            MotionEntry* typedEntry = static_cast<MotionEntry*>(mPendingEvent);
            //......
            done = dispatchMotionLocked(currentTime, typedEntry, &dropReason, nextWakeupTime);
            break;
        }
}
//......
}

nsecs_t InputDispatcher::processAnrsLocked() {
    const nsecs_t currentTime = now();
    nsecs_t nextAnrCheck = LONG_LONG_MAX;
    // 窗口无焦点，但应用有焦点
    if (mNoFocusedWindowTimeoutTime.has_value() && mAwaitedFocusedApplication != nullptr) {
        if (currentTime >= *mNoFocusedWindowTimeoutTime) {  //如果等待时间超过ANR时间
            onAnrLocked(mAwaitedFocusedApplication);  //执行ANR代码
            mAwaitedFocusedApplication.clear();
            return LONG_LONG_MIN;
        } else {   // 未超时，继续等待焦点窗口出现
            const nsecs_t millisRemaining = ns2ms(*mNoFocusedWindowTimeoutTime - currentTime);
            ALOGW("Still no focused window. Will drop the event in %" PRId64 "ms", millisRemaining);
            nextAnrCheck = *mNoFocusedWindowTimeoutTime;
        }
    }

    // 检查是否有connection中的ANR触发时间到了
    nextAnrCheck = std::min(nextAnrCheck, mAnrTracker.firstTimeout());
    if (currentTime < nextAnrCheck) {  //还没到检查时间,即还没发生ANR
        return nextAnrCheck;
    }

    // 执行到此处，已经发生了ANR
    sp<Connection> connection = getConnectionLocked(mAnrTracker.firstToken());
    if (connection == nullptr) {
        ALOGE("Could not find connection for entry %" PRId64, mAnrTracker.firstTimeout());
        return nextAnrCheck;
    }
    connection->responsive = false;  //置connection状态为未响应
    // Stop waking up for this unresponsive connection
    mAnrTracker.eraseToken(connection->inputChannel->getConnectionToken());
    onAnrLocked(connection);  //处理ANR
    return LONG_LONG_MIN;
}

// connection的ANR触发时间到产生的ANR
void InputDispatcher::onAnrLocked(const sp<Connection>& connection) {
    if (connection->waitQueue.empty()) {
        ALOGI("Not raising ANR because the connection %s has recovered",
              connection->inputChannel->getName().c_str());
        return;
    }
    DispatchEntry* oldestEntry = *connection->waitQueue.begin();
    const nsecs_t currentWait = now() - oldestEntry->deliveryTime;
    std::string reason =
            android::base::StringPrintf("%s is not responding. Waited %" PRId64 "ms for %s",
                                        connection->inputChannel->getName().c_str(),
                                        ns2ms(currentWait),
                                        oldestEntry->eventEntry->getDescription().c_str());

   updateLastAnrStateLocked(getWindowHandleLocked(connection->inputChannel->getConnectionToken()),reason);

    std::unique_ptr<CommandEntry> commandEntry =
            std::make_unique<CommandEntry>(&InputDispatcher::doNotifyAnrLockedInterruptible);
    commandEntry->inputApplicationHandle = nullptr;
    commandEntry->inputChannel = connection->inputChannel;
    commandEntry->reason = std::move(reason);
    postCommandLocked(std::move(commandEntry));
}

// 事件下发，但系统在等待出现焦点窗口
void InputDispatcher::onAnrLocked(const sp<InputApplicationHandle>& application) {
    std::string reason = android::base::StringPrintf("%s does not have a focused window",application->getName().c_str());

    updateLastAnrStateLocked(application, reason);

    std::unique_ptr<CommandEntry> commandEntry =
            std::make_unique<CommandEntry>(&InputDispatcher::doNotifyAnrLockedInterruptible);
    commandEntry->inputApplicationHandle = application;
    commandEntry->inputChannel = nullptr;
    commandEntry->reason = std::move(reason);
    postCommandLocked(std::move(commandEntry));
}