// frameworks/native/services/inputflinger/dispatcher/InputDispatcher.cpp
int32_t InputDispatcher::findFocusedWindowTargetsLocked(nsecs_t currentTime,
                                                        const EventEntry& entry,
                                                        std::vector<InputTarget>& inputTargets,
                                                        nsecs_t* nextWakeupTime) {
    std::string reason;
    int32_t displayId = getTargetDisplayId(entry);
    // mFocusedWindowHandlesByDisplay在setInputWindowsLocked()里賦值
    sp<InputWindowHandle> focusedWindowHandle =
            getValueByKey(mFocusedWindowHandlesByDisplay, displayId);
    // mFocusedApplicationHandlesByDisplay在setFocusedApplication()里賦值
    sp<InputApplicationHandle> focusedApplicationHandle =
            getValueByKey(mFocusedApplicationHandlesByDisplay, displayId);
    // focusedWindowHandle和focusedApplicationHandle都為空時表示當(dāng)前無窗口，該事件會被丟棄，不會執(zhí)行dispatchEventLocked
    // 一般出現(xiàn)兩個都為空的場景，是在窗口切換的過程，此時不處理事件注入
    if (focusedWindowHandle == nullptr && focusedApplicationHandle == nullptr) {
        return INPUT_EVENT_INJECTION_FAILED;
    }
    // focusedWindowHandle為空但focusedApplicationHandle不為空時開始ANR檢查
    if (focusedWindowHandle == nullptr && focusedApplicationHandle != nullptr) {
        // 默認mNoFocusedWindowTimeoutTime沒有值，第一次檢查ANR會走下面這個流程
        if (!mNoFocusedWindowTimeoutTime.has_value()) {
            // DEFAULT_INPUT_DISPATCHING_TIMEOUT = 5s * HwTimeoutMultiplier();
            // 默認input dispatch timeout時間時5s
            const nsecs_t timeout = focusedApplicationHandle->getDispatchingTimeout(
                    DEFAULT_INPUT_DISPATCHING_TIMEOUT.count());
            // 給mNoFocusedWindowTimeoutTime賦值，觸發(fā)ANR時會檢查這個值是否為空，不為空才觸發(fā)ANR
            mNoFocusedWindowTimeoutTime = currentTime + timeout;
            // 把當(dāng)前的focusedApplicationHandle賦值給mAwaitedFocusedApplication，觸發(fā)ANR時會檢查這個值是否為空，不為空才觸發(fā)ANR
            mAwaitedFocusedApplication = focusedApplicationHandle;
            mAwaitedApplicationDisplayId = displayId;
            *nextWakeupTime = *mNoFocusedWindowTimeoutTime;
            // 返回INPUT_EVENT_INJECTION_PENDING表示dispatchKeyLocked()或者dispatchMotionLocked()為false
            return INPUT_EVENT_INJECTION_PENDING;
        } else if (currentTime > *mNoFocusedWindowTimeoutTime) {
            // Already raised ANR. Drop the event
            return INPUT_EVENT_INJECTION_FAILED;
        } else {
            // Still waiting for the focused window
            return INPUT_EVENT_INJECTION_PENDING;
        }
    }
    // 如果走到這個流程，說明沒有ANR，清空mNoFocusedWindowTimeoutTime和mAwaitedFocusedApplication
    resetNoFocusedWindowTimeoutLocked();
    return INPUT_EVENT_INJECTION_SUCCEEDED;
}

// frameworks/native/services/inputflinger/dispatcher/InputDispatcher.cpp
nsecs_t InputDispatcher::processAnrsLocked() {
    const nsecs_t currentTime = now();
    nsecs_t nextAnrCheck = LONG_LONG_MAX;
    // 在findFocusedWindowTargetsLocked()中，如果focusedWindowHandle為空，focusedApplicationHandle不為空，以下條件就會滿足
    if (mNoFocusedWindowTimeoutTime.has_value() && mAwaitedFocusedApplication != nullptr) {
        // mNoFocusedWindowTimeoutTime為檢查時間+5s，如果currentTime大于等于mNoFocusedWindowTimeoutTime，表示超時
        if (currentTime >= *mNoFocusedWindowTimeoutTime) {
            // 觸發(fā)ANR流程，此處觸發(fā)的ANR類型是xxx does not have a focused window
            processNoFocusedWindowAnrLocked();
            // 清空mAwaitedFocusedApplication，下次就不會再走ANR流程
            mAwaitedFocusedApplication.clear();
            mNoFocusedWindowTimeoutTime = std::nullopt;
            return LONG_LONG_MIN;
        } else {
            // Keep waiting
            const nsecs_t millisRemaining = ns2ms(*mNoFocusedWindowTimeoutTime - currentTime);
            ALOGW("Still no focused window. Will drop the event in %" PRId64 "ms", millisRemaining);
            // 還沒有超時，更新檢查時間
            nextAnrCheck = *mNoFocusedWindowTimeoutTime;
        }
    }
    ....
    // 如果走到這個流程，ANR類型是xxx is not responding. Waited xxx ms for xxx
    // 這個地方，focusedWindowHandle和focusedApplicationHandle都是不為空的場景
    onAnrLocked(*connection);
    return LONG_LONG_MIN;
}

// frameworks/native/services/inputflinger/dispatcher/InputDispatcher.cpp
void InputDispatcher::processNoFocusedWindowAnrLocked() {
    // 在觸發(fā)ANR前，再獲取一次當(dāng)前的focusedApplication
    sp<InputApplicationHandle> focusedApplication =
            getValueByKey(mFocusedApplicationHandlesByDisplay, mAwaitedApplicationDisplayId);
    // 檢查觸發(fā)ANR時的條件是focusedApplication不為空
    // 如果此時focusedApplication為空，或者focusedApplication不等于前一個mAwaitedFocusedApplication表示已經(jīng)切換application focus，取消觸發(fā)ANR
    if (focusedApplication == nullptr ||
        focusedApplication->getApplicationToken() !=
                mAwaitedFocusedApplication->getApplicationToken()) {
        return; // The focused application has changed.
    }
    // 在觸發(fā)ANR前，再獲取一次當(dāng)前的focusedWindowHandle 
    const sp<InputWindowHandle>& focusedWindowHandle =
            getFocusedWindowHandleLocked(mAwaitedApplicationDisplayId);
    // 檢查觸發(fā)ANR時focusedWindowHandle為空，如果此時focusedWindowHandle不為空，取消觸發(fā)ANR
    if (focusedWindowHandle != nullptr) {
        return; // We now have a focused window. No need for ANR.
    }
    // 通過前面的判斷，還是無法攔截，說明該ANR無可避免，最終觸發(fā)ANR
    // 早期代碼沒有前面一系列的判斷，是直接觸發(fā)的ANR，會在性能較差的場景下出現(xiàn)誤判
    onAnrLocked(mAwaitedFocusedApplication);
}

// frameworks/base/services/core/jni/com_android_server_input_InputManagerService.cpp
void InputDispatcher::setFocusedApplication(
        int32_t displayId, const sp<InputApplicationHandle>& inputApplicationHandle) {
    { // acquire lock
        std::scoped_lock _l(mLock);
        // 獲取當(dāng)前的focusedApplicationHandle
        sp<InputApplicationHandle> oldFocusedApplicationHandle =
                getValueByKey(mFocusedApplicationHandlesByDisplay, displayId);
        // 如果當(dāng)前的focusedApplicationHandle跟觸發(fā)ANR是的focusedApplicationHandle是一樣且
        // 新的focusedApplicationHandle跟舊的不一樣，說明focusedApplicationHandle有更新
        // 需要重置ANR計時
        if (oldFocusedApplicationHandle == mAwaitedFocusedApplication &&
            inputApplicationHandle != oldFocusedApplicationHandle) {
            // 重置ANR計時
            resetNoFocusedWindowTimeoutLocked();
        }
        if (inputApplicationHandle != nullptr && inputApplicationHandle->updateInfo()) {
            if (oldFocusedApplicationHandle != inputApplicationHandle) {
                // 賦值新的inputApplicationHandle到mFocusedApplicationHandlesByDisplay，在findFocusedWindowTargetsLocked()時用到
                mFocusedApplicationHandlesByDisplay[displayId] = inputApplicationHandle;
            }
        } else if (oldFocusedApplicationHandle != nullptr) {
            // 如果inputApplicationHandle為空，oldFocusedApplicationHandle不為空，需要清除oldFocusedApplicationHandle
            oldFocusedApplicationHandle.clear();
            // 走到這個流程會出現(xiàn)findFocusedWindowTargetsLocked()中focusedApplicationHandle為空
            mFocusedApplicationHandlesByDisplay.erase(displayId);
        }
    } // release lock
    // Wake up poll loop since it may need to make new input dispatching choices.
    mLooper->wake();
}

// frameworks/native/services/inputflinger/dispatcher/InputDispatcher.cpp
// 當(dāng)VSYNC信號來了之后，會調(diào)用到SurfaceFlinger的onMessageInvalidate()方法
// SurfaceFlinger::onMessageInvalidate() 
//   ==> SurfaceFlinger: updateInputFlinger()
//    ==> SurfaceFlinger: updateInputWindowInfo()
//      ==> InputManager::setInputWindows()
//        ==> InputDispatcher::setInputWindows()
//          ==> InputDispatcher::setInputWindowsLocked()
void InputDispatcher::setInputWindowsLocked(
        const std::vector<sp<InputWindowHandle>>& inputWindowHandles, int32_t displayId) {
    // ......
    const std::vector<sp<InputWindowHandle>> oldWindowHandles = getWindowHandlesLocked(displayId);
    // 更新mWindowHandlesByDisplay這個map，然后通過getWindowHandlesLocked()找newFocusedWindowHandle
    updateWindowHandlesForDisplayLocked(inputWindowHandles, displayId);
    sp<InputWindowHandle> newFocusedWindowHandle = nullptr;
    bool foundHoveredWindow = false;
    // 在mWindowHandlesByDisplay這個map里面找newFocusedWindowHandle
    for (const sp<InputWindowHandle>& windowHandle : getWindowHandlesLocked(displayId)) {
        // newFocusedWindowHandle要不為空，windowHandle具備focusable和visible屬性
        if (!newFocusedWindowHandle && windowHandle->getInfo()->hasFocus &&
            windowHandle->getInfo()->visible) {
            // 給newFocusedWindowHandle賦值，最后這個值存到mFocusedWindowHandlesByDisplay這個map
            newFocusedWindowHandle = windowHandle;
        }
        if (windowHandle == mLastHoverWindowHandle) {
            foundHoveredWindow = true;
        }
    }
    if (!foundHoveredWindow) {
        mLastHoverWindowHandle = nullptr;
    }
    // 在mFocusedWindowHandlesByDisplay這個map里找當(dāng)前的焦點窗口
    sp<InputWindowHandle> oldFocusedWindowHandle =
            getValueByKey(mFocusedWindowHandlesByDisplay, displayId);
    // 判斷oldFocusedWindowHandle是否等于newFocusedWindowHandle，如果相等則不走focus change流程
    if (!haveSameToken(oldFocusedWindowHandle, newFocusedWindowHandle)) {
        // 如果當(dāng)前的焦點窗口不為空，需要從mFocusedWindowHandlesByDisplay移除掉
        if (oldFocusedWindowHandle != nullptr) {
            sp<InputChannel> focusedInputChannel =
                    getInputChannelLocked(oldFocusedWindowHandle->getToken());
            if (focusedInputChannel != nullptr) {
                CancelationOptions options(CancelationOptions::CANCEL_NON_POINTER_EVENTS,
                                           "focus left window");
                synthesizeCancelationEventsForInputChannelLocked(focusedInputChannel, options);
                // 新建一個FocusEntry加入到mInboundQueue去dispatch
                enqueueFocusEventLocked(*oldFocusedWindowHandle, false /*hasFocus*/);
            }
            // oldFocusedWindowHandle不為空時需要移除舊的
            mFocusedWindowHandlesByDisplay.erase(displayId);
        }
        // 走到這個流程，如果oldFocusedWindowHandle不為空，newFocusedWindowHandle為空，那么在findFocusedWindowTargetsLocked()中的focusedWindowHandle為空
        // 如果newFocusedWindowHandle不為空，更新mFocusedWindowHandlesByDisplay
        if (newFocusedWindowHandle != nullptr) {
            // 更新mFocusedWindowHandlesByDisplay，在findFocusedWindowTargetsLocked()時用到
            mFocusedWindowHandlesByDisplay[displayId] = newFocusedWindowHandle;
            // 新建一個FocusEntry加入到mInboundQueue去dispatch
            enqueueFocusEventLocked(*newFocusedWindowHandle, true /*hasFocus*/);
        }
        if (mFocusedDisplayId == displayId) {
            // 添加focusChanged到mCommandQueue，在dispatchOnce時會執(zhí)行
            onFocusChangedLocked(oldFocusedWindowHandle, newFocusedWindowHandle);
        }
    }
    // ......
}