Key事件的分發邏輯，Android按鍵事件的產生與處理解析

作者：Reathin 2024-07-01 08:27:05

KeyEvent類的dispatch方法實現了按鍵事件的分發和處理，為Android應用程序提供了豐富的按鍵事件處理能力。

「事件的產生」：當用戶按下物理按鍵、使用遙控器、輸入法或其他USB-OTG外接鍵盤等設備時，會產生按鍵事件（KeyEvent）。
「事件的分發」：

「分發起點」：按鍵事件由Android系統接收，通過Linux層分發到PhoneWindowManager（系統進程）和ViewRootImpl（應用進程）。
「分發順序」：PhoneWindowManager先執行，處理系統級的按鍵事件（如音量鍵、電源鍵等），ViewRootImpl后執行，處理應用層的按鍵事件（如方向鍵、回車鍵等）。
「分發過程」：在ViewRootImpl中，存在一個名為InputStage的責任鏈，用于處理輸入事件，每個階段都可能對事件進行處理或將其傳遞給下一個階段。

/frameworks/base/core/java/android/view/ViewRootImpl.java

private int processKeyEvent(QueuedInputEvent q) {
    final KeyEvent event = (KeyEvent) q.mEvent;
    if (mUnhandledKeyManager.preViewDispatch(event)) {
        return FINISH_HANDLED;
    }

    // Deliver the key to the view hierarchy.
    if (mView.dispatchKeyEvent(event)) {
        return FINISH_HANDLED;
    }

    if (shouldDropInputEvent(q)) {
        return FINISH_NOT_HANDLED;
    }

    // This dispatch is for windows that don't have a Window.Callback. Otherwise,
    // the Window.Callback usually will have already called this (see
    // DecorView.superDispatchKeyEvent) leaving this call a no-op.
    if (mUnhandledKeyManager.dispatch(mView, event)) {
        return FINISH_HANDLED;
    }

    int groupNavigationDirection = 0;

    if (event.getAction() == KeyEvent.ACTION_DOWN
            && event.getKeyCode() == KeyEvent.KEYCODE_TAB) {
        if (KeyEvent.metaStateHasModifiers(event.getMetaState(), KeyEvent.META_META_ON)) {
            groupNavigationDirection = View.FOCUS_FORWARD;
        } else if (KeyEvent.metaStateHasModifiers(event.getMetaState(),KeyEvent.META_META_ON | KeyEvent.META_SHIFT_ON)) {
            groupNavigationDirection = View.FOCUS_BACKWARD;
        }
    }

    // If a modifier is held, try to interpret the key as a shortcut.
    if (event.getAction() == KeyEvent.ACTION_DOWN && !KeyEvent.metaStateHasNoModifiers(event.getMetaState()) && event.getRepeatCount() == 0
                    && !KeyEvent.isModifierKey(event.getKeyCode())
                    && groupNavigationDirection == 0) {
        if (mView.dispatchKeyShortcutEvent(event)) {
            return FINISH_HANDLED;
        }
        if (shouldDropInputEvent(q)) {
            return FINISH_NOT_HANDLED;
        }
    }

    // Apply the fallback event policy.
    if (mFallbackEventHandler.dispatchKeyEvent(event)) {
        return FINISH_HANDLED;
    }
    if (shouldDropInputEvent(q)) {
        return FINISH_NOT_HANDLED;
    }

    // Handle automatic focus changes.
    if (event.getAction() == KeyEvent.ACTION_DOWN) {
        if (groupNavigationDirection != 0) {
            if (performKeyboardGroupNavigation(groupNavigationDirection)) {
                return FINISH_HANDLED;
            }
        } else {
            if (performFocusNavigation(event)) {
                return FINISH_HANDLED;
            }
        }
    }
    return FORWARD;
}

在處理按鍵事件之前，首先會調用mUnhandledKeyManager.preViewDispatch(event)來判斷是否有未處理的按鍵事件。如果有未處理的事件，則直接返回FINISH_HANDLED表示該事件已被處理。
如果沒有未處理的事件，則調用mView.dispatchKeyEvent(event)將按鍵事件分發給View層次結構。如果View層次結構中的任何一個View處理了該事件，則直接返回FINISH_HANDLED表示該事件已被處理。
如果按鍵事件不能被處理或應該被丟棄，則調用shouldDropInputEvent(q)方法來決定是否應該丟棄該事件。如果應該丟棄，則返回FINISH_NOT_HANDLED表示該事件未被處理；否則繼續處理該事件。
如果事件仍未被處理，則調用mUnhandledKeyManager.dispatch(mView, event)來判斷是否有未處理的事件。如果有，則直接返回FINISH_HANDLED表示該事件已被處理。
如果按鍵事件是一個特定的按鍵（如Tab鍵）并且同時滿足一些特定的條件，則設置groupNavigationDirection變量并調用performKeyboardGroupNavigation方法來處理自動的聚焦變化。
如果按鍵事件是一個快捷鍵（即同時按下一個或多個修飾鍵和另一個鍵），則調用mView.dispatchKeyShortcutEvent(event)將事件分發給View層次結構來嘗試解釋該按鍵事件。如果該事件被處理，則返回FINISH_HANDLED表示該事件已被處理。
如果事件仍未被處理，則調用mFallbackEventHandler.dispatchKeyEvent(event)應用回退事件策略來嘗試處理該事件。如果該事件被處理，則返回FINISH_HANDLED表示該事件已被處理。
如果事件仍未被處理，則調用performFocusNavigation方法來處理自動的聚焦變化。如果該事件被處理，則返回FINISH_HANDLED表示該事件已被處理。
最后，如果事件仍未被處理，則返回FORWARD表示該事件應該被傳遞給下一個事件處理程序。

private boolean performFocusNavigation(KeyEvent event) {
    int direction = 0;
    switch (event.getKeyCode()) {
        case KeyEvent.KEYCODE_DPAD_LEFT:
            if (event.hasNoModifiers()) {
                direction = View.FOCUS_LEFT;
            }
            break;
        case KeyEvent.KEYCODE_DPAD_RIGHT:
            if (event.hasNoModifiers()) {
                direction = View.FOCUS_RIGHT;
            }
            break;
        case KeyEvent.KEYCODE_DPAD_UP:
            if (event.hasNoModifiers()) {
                direction = View.FOCUS_UP;
            }
            break;
        case KeyEvent.KEYCODE_DPAD_DOWN:
            if (event.hasNoModifiers()) {
                direction = View.FOCUS_DOWN;
            }
            break;
        case KeyEvent.KEYCODE_TAB:
            if (event.hasNoModifiers()) {
                direction = View.FOCUS_FORWARD;
            } else if (event.hasModifiers(KeyEvent.META_SHIFT_ON)) {
                direction = View.FOCUS_BACKWARD;
            }
            break;
    }
    if (direction != 0) {
        View focused = mView.findFocus();
        if (focused != null) {
            View v = focused.focusSearch(direction);
            if (v != null && v != focused) {
                // do the math the get the interesting rect
                // of previous focused into the coord system of
                // newly focused view
                focused.getFocusedRect(mTempRect);
                if (mView instanceof ViewGroup) {
                    ((ViewGroup) mView).offsetDescendantRectToMyCoords(focused, mTempRect);
                    ((ViewGroup) mView).offsetRectIntoDescendantCoords(v, mTempRect);
                }
                if (v.requestFocus(direction, mTempRect)) {
                    Log.i(TAG, "v.requestFocus == true");
                    boolean isFastScrolling = event.getRepeatCount() > 0;
                    playSoundEffect(SoundEffectConstants.getConstantForFocusDirection(direction,isFastScrolling));
                    return true;
                }
            }

            // Give the focused view a last chance to handle the dpad key.
            if (mView.dispatchUnhandledMove(focused, direction)) {
                return true;
            }
        } else {
            if (mView.restoreDefaultFocus()) {
                return true;
            }
        }
    }
    return false;
}

該方法用于處理焦點導航相關的按鍵事件，例如方向鍵和Tab鍵等。該方法接收一個KeyEvent對象作為參數，根據不同的按鍵碼和修飾符，計算出焦點導航的方向，然后嘗試在View樹中找到新的焦點，并將其設置為當前焦點。如果找到新的焦點并成功設置為當前焦點，則播放焦點變化時的聲音效果，并返回true表示焦點變化事件已被處理。如果沒有找到新的焦點，或者新的焦點不接受焦點設置請求，則返回false表示該事件未被處理。

/frameworks/base/core/java/com/android/internal/policy/DecorView.java

@Override
public boolean dispatchKeyEvent(KeyEvent event) {
    final int keyCode = event.getKeyCode();
    final int action = event.getAction();
    final boolean isDown = action == KeyEvent.ACTION_DOWN;

    if (isDown && (event.getRepeatCount() == 0)) {
        // First handle chording of panel key: if a panel key is held
        // but not released, try to execute a shortcut in it.
        if ((mWindow.mPanelChordingKey > 0) && (mWindow.mPanelChordingKey != keyCode)) {
            boolean handled = dispatchKeyShortcutEvent(event);
            if (handled) {
                return true;
            }
        }

        // If a panel is open, perform a shortcut on it without the
        // chorded panel key
        if ((mWindow.mPreparedPanel != null) && mWindow.mPreparedPanel.isOpen) {
            if (mWindow.performPanelShortcut(mWindow.mPreparedPanel, keyCode, event, 0)) {
                return true;
            }
        }
    }

    if (!mWindow.isDestroyed()) {
        final Window.Callback cb = mWindow.getCallback();
        final boolean handled = cb != null && mFeatureId < 0 ? cb.dispatchKeyEvent(event) : super.dispatchKeyEvent(event);
        if (handled) {
            return true;
        }
    }
    boolean result = isDown ? mWindow.onKeyDown(mFeatureId, event.getKeyCode(), event) : mWindow.onKeyUp(mFeatureId, event.getKeyCode(), event);
    return result;
}

該方法用于處理按鍵事件的分發和處理，該方法接收一個KeyEvent對象，并提取出鍵碼和事件類型。如果該事件為按下事件并且重復次數為0，則執行以下操作：

首先，處理面板按鍵的彈奏：如果面板按鍵已按下但未釋放，則嘗試在其中執行一個快捷方式。如果已處理該快捷方式，則返回true表示事件已處理。
然后，如果面板已經打開，則在沒有面板按鍵的情況下執行其上的快捷方式。如果已處理該快捷方式，則返回true表示事件已處理。
如果事件仍未被處理，則檢查Window對象是否已被銷毀，如果沒有，則獲取Window.Callback對象并將事件分派給它。如果已處理該事件，則返回true表示事件已處理。
最后，如果事件仍未被處理，則將其傳遞給Window對象進行處理，并返回該事件是否為按下事件的結果。

public boolean superDispatchKeyEvent(KeyEvent event) {
    // Give priority to closing action modes if applicable.
    if (event.getKeyCode() == KeyEvent.KEYCODE_BACK) {
        final int action = event.getAction();
        // Back cancels action modes first.
        if (mPrimaryActionMode != null) {
            if (action == KeyEvent.ACTION_UP) {
                mPrimaryActionMode.finish();
            }
            return true;
        }
    }

    if (super.dispatchKeyEvent(event)) {
        return true;
    }
    boolean handle = (getViewRootImpl() != null) && getViewRootImpl().dispatchUnhandledKeyEvent(event);
    return handle;
}

其作用是對KeyEvent事件進行分發處理。該方法首先判斷事件是否為返回鍵，如果是則優先處理當前的操作模式，如果存在操作模式則先結束操作模式，否則將事件交由父類ViewGroup進行處理。如果父類能夠處理該事件，則返回true，否則返回false，并將事件交由該DecorView 所對應的ViewRootImpl實例進行處理。

其中，getViewRootImpl()方法返回當前DecorView所在的ViewRootImpl實例。如果該實例存在，則調用dispatchUnhandledKeyEvent(event)方法進行處理，否則返回false。dispatchUnhandledKeyEvent(event)方法用于將該事件交由輸入法進行處理。

「View的事件處理」：

「ViewGroup與View」：在Android中，ViewGroup是View的容器，負責分發事件給其子View。如果ViewGroup的dispatchTouchEvent方法返回true，事件被消費，不會傳遞給其onTouchEvent方法或子View。如果返回false，調用父控件的onTouchEvent方法或繼續傳遞給子View。
「事件攔截」：ViewGroup有一個onInterceptTouchEvent方法，可以在事件傳遞給子View之前進行攔截。如果該方法返回true，則事件被攔截并在當前ViewGroup的onTouchEvent方法中處理。
「事件消費」：無論是ViewGroup還是View，如果onTouchEvent方法返回true，表示事件被消費，不再傳遞給其他View或父控件。

/frameworks/base/core/java/android/app/Activity.java

public boolean dispatchKeyEvent(KeyEvent event) {
    onUserInteraction();

    // Let action bars open menus in response to the menu key prioritized over
    // the window handling it
    final int keyCode = event.getKeyCode();
    if (keyCode == KeyEvent.KEYCODE_MENU && mActionBar != null && mActionBar.onMenuKeyEvent(event)) {
        return true;
    }

    Window win = getWindow();
    if (win.superDispatchKeyEvent(event)) {
        return true;
    }
    View decor = mDecor;
    if (decor == null) decor = win.getDecorView();
    boolean handler = event.dispatch(this, decor != null ? decor.getKeyDispatcherState() : null, this);
    return handler;
}

該方法用于分發鍵事件，當用戶按下或釋放某個按鍵時，該方法將被調用。

首先，方法調用onUserInteraction()，用于通知Activity用戶正在與應用程序交互。
接著，方法檢查事件是否為菜單鍵事件，如果是，則首先檢查 ActionBar 是否存在，并且將事件傳遞給 ActionBar 的 onMenuKeyEvent() 方法進行處理。如果 ActionBar 成功處理該事件，則直接返回 true，表示事件已被處理。
如果事件不是菜單鍵事件或者ActionBar無法處理該事件，則將事件傳遞給窗口處理，并返回窗口處理結果。如果窗口處理了該事件，則直接返回true，表示事件已被處理。
如果事件既不是菜單鍵事件，也無法被窗口處理，則將事件分發給DecorView（該Activity 的根View），并返回DecorView的dispatchKeyEvent()方法的處理結果。

/frameworks/base/core/java/com/android/internal/policy/PhoneWindow.java

public boolean superDispatchKeyEvent(KeyEvent event) {
    return mDecor.superDispatchKeyEvent(event);
}

/frameworks/base/core/java/android/view/ViewGroup.java

@Override
public boolean dispatchKeyEvent(KeyEvent event) {
    if (mInputEventConsistencyVerifier != null) {
        mInputEventConsistencyVerifier.onKeyEvent(event, 1);
    }

    if ((mPrivateFlags & (PFLAG_FOCUSED | PFLAG_HAS_BOUNDS)) == (PFLAG_FOCUSED | PFLAG_HAS_BOUNDS)) {
        if (super.dispatchKeyEvent(event)) {
            Log.e("ViewRootImpl","super.dispatchKeyEvent(event)");
            return true;
        }
    } else if (mFocused != null && (mFocused.mPrivateFlags & PFLAG_HAS_BOUNDS) == PFLAG_HAS_BOUNDS) {
        if (mFocused.dispatchKeyEvent(event)) {
            Log.e("ViewRootImpl","Focused.dispatchKeyEvent(event)");
            return true;
        }
    }

    if (mInputEventConsistencyVerifier != null) {
        mInputEventConsistencyVerifier.onUnhandledEvent(event, 1);
    }
    return false;
}

用于將按鍵事件分派到該ViewGroup及其子View。該方法首先通過檢查ViewGroup本身的狀態（是否擁有焦點且有邊界）來決定是否自己處理KeyEvent，如果ViewGroup本身滿足條件，則通過調用父類的dispatchKeyEvent方法處理事件，并返回true表示已處理。如果ViewGroup本身不滿足條件，則將KeyEvent分派到當前擁有焦點的子View，如果該子View處理了事件，則返回true表示已處理。如果KeyEvent最終未被處理，則返回false表示未處理。此方法還包含一些調試代碼，用于確保事件派發的一致性。

/frameworks/base/core/java/android/view/View.java

public boolean dispatchKeyEvent(KeyEvent event) {
    if (mInputEventConsistencyVerifier != null) {
        mInputEventConsistencyVerifier.onKeyEvent(event, 0);
    }

    // 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)) {
        Log.e("ViewRootImpl","mOnKeyListener.onKey");
        return true;
    }

    if (event.dispatch(this, mAttachInfo != null ? mAttachInfo.mKeyDispatchState : null, this)) {
        Log.e("ViewRootImpl","event.dispatch");
        return true;
    }

    if (mInputEventConsistencyVerifier != null) {
        mInputEventConsistencyVerifier.onUnhandledEvent(event, 0);
    }
    return false;
}

該方法用于分派鍵盤事件到對應的視圖，并根據事件的處理結果返回一個布爾值。方法的參數event表示一個鍵盤事件，該事件將被分派到相應的視圖。方法中的第一步是調用mInputEventConsistencyVerifier.onKeyEvent(event, 0)方法來記錄鍵盤事件的一些基本信息，用于后續的事件一致性檢查。然后會首先調用視圖的OnKeyListener對象（如果有的話）的onKey 方法，如果該方法返回true，則表示該鍵盤事件被該監聽器處理，方法返回true，否則該鍵盤事件被傳遞給了該視圖的dispatch方法。在這里調用了event.dispatch(this, mAttachInfo != null ? mAttachInfo.mKeyDispatchState : null, this)方法，該方法會根據鍵盤事件的類型，將其分發給視圖的onKeyDown或onKeyUp方法進行處理。如果該事件被處理了，則返回true，否則會調用mInputEventConsistencyVerifier.onUnhandledEvent(event, 0)方法記錄該事件未被處理的信息，并返回false表示該事件未被處理。

/frameworks/base/core/java/android/view/KeyEvent.java

public final boolean dispatch(Callback receiver, DispatcherState state, Object target) {
    switch (mAction) {
        case ACTION_DOWN: {
            mFlags &= ~FLAG_START_TRACKING;
            if (DEBUG) Log.v(TAG, "Key down to " + target + " in " + state + ": " + this);
            boolean res = receiver.onKeyDown(mKeyCode, this);
            if (state != null) {
                if (res && mRepeatCount == 0 && (mFlags&FLAG_START_TRACKING) != 0) {
                    if (DEBUG) Log.v(TAG, "  Start tracking!");
                    state.startTracking(this, target);
                } else if (isLongPress() && state.isTracking(this)) {
                    try {
                        if (receiver.onKeyLongPress(mKeyCode, this)) {
                            if (DEBUG) Log.v(TAG, "  Clear from long press!");
                            state.performedLongPress(this);
                            res = true;
                        }
                    } catch (AbstractMethodError e) {
                    }
                }
            }
            return res;
        }
        case ACTION_UP:
            if (DEBUG) Log.v(TAG, "Key up to " + target + " in " + state + ": " + this);
            if (state != null) {
                state.handleUpEvent(this);
            }
            return receiver.onKeyUp(mKeyCode, this);
        case ACTION_MULTIPLE:
            final int count = mRepeatCount;
            final int code = mKeyCode;
            if (receiver.onKeyMultiple(code, count, this)) {
                return true;
            }
            if (code != KeyEvent.KEYCODE_UNKNOWN) {
                mAction = ACTION_DOWN;
                mRepeatCount = 0;
                boolean handled = receiver.onKeyDown(code, this);
                if (handled) {
                    mAction = ACTION_UP;
                    receiver.onKeyUp(code, this);
                }
                mAction = ACTION_MULTIPLE;
                mRepeatCount = count;
                return handled;
            }
            return false;
    }
    return false;
}

KeyEvent事件分發的核心代碼，主要處理按鍵事件的分發。當一個按鍵事件被分發到一個View時，該View首先嘗試處理該事件。如果該View無法處理該事件，則事件將被分發給它的parent View或Activity，直到事件被處理或到達了View層級的最頂層。

該方法根據KeyEvent的不同Action，分別進行處理。如果Action是ACTION_DOWN，即按下按鍵的事件，首先會調用Callback接口的onKeyDown方法來處理該事件，并根據事件處理的結果進行相應的處理。如果返回true，表示事件被成功處理，并且設置了FLAG_START_TRACKING標志位，則會調用DispatcherState的startTracking方法來開始追蹤該事件。如果事件是長按事件，且當前正在追蹤該事件，則會調用Callback接口的onKeyLongPress方法來處理長按事件。
如果Action是ACTION_UP，即松開按鍵的事件，會調用Callback接口的onKeyUp方法來處理該事件，并根據DispatcherState是否存在，調用DispatcherState的handleUpEvent方法來結束追蹤該事件。
如果Action是ACTION_MULTIPLE，即按鍵事件包含多個重復事件，會調用Callback接口的onKeyMultiple方法來處理該事件，并根據KeyEvent的repeatCount和keyCode信息，依次調用Callback接口的onKeyDown和onKeyUp方法來處理每一個重復事件，最后返回處理結果。

總的來說，KeyEvent類的dispatch方法實現了按鍵事件的分發和處理，為Android應用程序提供了豐富的按鍵事件處理能力。

「特殊情況」：

「自定義處理」：可以通過重寫Activity、ViewGroup或View的dispatchKeyEvent、onInterceptTouchEvent、onTouchEvent等方法來自定義按鍵事件的處理邏輯。
「外圍設備」：對于藍牙鍵盤、USB鍵盤等外圍設備，Android通過KeyEvent事件機制與它們進行交互。開發者可以通過重寫dispatchKeyEvent方法來截獲和處理這些設備發送的事件。

Key事件的分發邏輯是一個復雜但有序的過程，涉及事件的產生、分發和View的事件處理等多個階段。通過理解這個過程，可以更好地控制Android應用中按鍵事件的行為。

責任編輯：武曉燕來源：沐雨花飛蝶