手柄方向键无效，分析KeyEvent的寻焦与分派
刚起身准备去上厕所，就被小金拦住了去路。小金说:"我这里有个手柄的bug，你看看是不是你的问题"。小金有理有据的说："你看看的launcher在android6上完美兼容手柄，但是在android12上，完全不能用手柄控制切换应用选择，下压方向键无数次，没有一个应用能被选中"。我竟无法反驳-乖乖把bug单接过来，开始看~ 对于一个android仔来说，接触的最多就是TouchEvent事件了，这个手柄的方向键是触发了什么事件呢? 一时有点蒙
正常手柄方向键触发之后的效果，如下图:
图一：正常获取焦点
在看一下我们的launcher的首页布局，由一层层ViewGroup嵌套而来，最终ShortcutAndWidgetContainer包含了桌面当前页面的所有应用图标 
图二：首页布局
咱都2023年了，先问一波chatgpt。问:"android中手柄方向键触发失效，怎么解?",回答如下:
检查焦点和事件分发：手柄方向键触发通常需要焦点和正确的事件分发。请确保您的视图（如Activity或Fragment）具有焦点，并且正确地处理了方向键事件。您可以使用以下方法来检查和处理焦点和事件：
ini在视图的XML布局文件中，确保您的视图元素具有`android:focusable="true"`和`android:focusableInTouchMode="true"`属性，以确保能够获取焦点。
回答中提到了android:focusable 、android:focusableInTouchMode 、焦点等字眼，我们查看相关文档，知道一个view必须是可获取焦点的才可以分派keyEvent事件到该view。首先第一个问题出现，是否我们的应用图标在android12上是不可以获取焦点的呢？我们打印日志看看，如下图所示：
图三：BubbleTextView 可获取焦点日志
可见我们的应用图标是具备获取焦点能力的。那究竟是什么阻碍了KeyEvent派发到应用图标呢？因为keyEvent、和MotionEvent都是InputEvent的子类，那么感觉keyEvent的派发应该和MotionEvent差不多。通过查看源码，首次第一个焦点的检索如下流程所示： 
图四：退出TouchMode下检索焦点和派发KeyEvent流程
其中涉及到的流程
java
// ViewRootImpl.EarlyPostImeInputStage.java
// 1.处理退出TouchMode入口
@Override
protected int onProcess(QueuedInputEvent q) {
if (q.mEvent instanceof KeyEvent) {
return processKeyEvent(q);
} else if (q.mEvent instanceof MotionEvent) {
return processMotionEvent(q);
}
return FORWARD;
}
// 2.退出touchmode处理
private int processKeyEvent(QueuedInputEvent q) {
final KeyEvent event = (KeyEvent) q.mEvent;
// 省略 ....
// 判断退出触摸模式
if (checkForLeavingTouchModeAndConsume(event)) {
return FINISH_HANDLED;
}
// Make sure the fallback event policy sees all keys that will be
// delivered to the view hierarchy.
mFallbackEventHandler.preDispatchKeyEvent(event);
return FORWARD;
}
// 3.event事件具体类型检测，满足触发ensureTouchMode(false)
private boolean checkForLeavingTouchModeAndConsume(KeyEvent event) {
// 省略 ....
// 1.因为我们触发的是←键，所以满足isNavigationKey判断
// If the key can be used for keyboard navigation then leave touch mode
// and select a focused view if needed (in ensureTouchMode).
// When a new focused view is selected, we consume the navigation key because
// navigation doesn't make much sense unless a view already has focus so
// the key's purpose is to set focus.
if (isNavigationKey(event)) {
return ensureTouchMode(false);
}
// If the key can be used for typing then leave touch mode
// and select a focused view if needed (in ensureTouchMode).
// Always allow the view to process the typing key.
if (isTypingKey(event)) {
ensureTouchMode(false);
return false;
}
return false;
}
// 4.inTouchMode = false，退出触摸模式
boolean ensureTouchMode(boolean inTouchMode) {
// .... 省略
// handle the change
// 继续处理
return ensureTouchModeLocally(inTouchMode);
}
// 5.inTouchMode = false，会执行enterTouchMode()
private boolean ensureTouchModeLocally(boolean inTouchMode) {
// .... 省略
return (inTouchMode) ? enterTouchMode() : leaveTouchMode();
}
//6.实际执行退出touchmode
private boolean leaveTouchMode() {
if (mView != null) {
// 1.首次没有可获取焦点view
if (mView.hasFocus()) {
View focusedView = mView.findFocus();
if (!(focusedView instanceof ViewGroup)) {
// some view has focus, let it keep it
return false;
} else if (((ViewGroup) focusedView).getDescendantFocusability() !=
ViewGroup.FOCUS_AFTER_DESCENDANTS) {
// some view group has focus, and doesn't prefer its children
// over itself for focus, so let them keep it.
return false;
}
}
// find the best view to give focus to in this brave new non-touch-mode
// world
// 2.获取默认焦点
return mView.restoreDefaultFocus();
}
return false;
}
// 7.触发实际检索焦点的逻辑，开启自上而下遍历寻焦
public boolean restoreDefaultFocus() {
return requestFocus(View.FOCUS_DOWN);
}
// 8.自上而下请求焦点
public final boolean requestFocus(int direction) {
return requestFocus(direction, null);
}
public boolean requestFocus(int direction, Rect previouslyFocusedRect) {
return requestFocusNoSearch(direction, previouslyFocusedRect);
}
// 8.正常逻辑都是寻焦模式是以子view优先的，一些viewGroup拦截焦点逻辑的除外，比如配置了setDescendantFocusability(ViewGroup.FOCUS_AFTER_DESCENDANTS);等
public boolean requestFocus(int direction, Rect previouslyFocusedRect) {
if (DBG) {
System.out.println(this + " ViewGroup.requestFocus direction="
+ direction);
}
int descendantFocusability = getDescendantFocusability();
boolean result;
switch (descendantFocusability) {
case FOCUS_BLOCK_DESCENDANTS:
result = super.requestFocus(direction, previouslyFocusedRect);
break;
case FOCUS_BEFORE_DESCENDANTS: {
final boolean took = super.requestFocus(direction, previouslyFocusedRect);
result = took ? took : onRequestFocusInDescendants(direction,
previouslyFocusedRect);
break;
}
case FOCUS_AFTER_DESCENDANTS: {
// 1.主要是这里进焦点查找
final boolean took = onRequestFocusInDescendants(direction, previouslyFocusedRect);
result = took ? took : super.requestFocus(direction, previouslyFocusedRect);
break;
}
default:
throw new IllegalStateException("descendant focusability must be "
+ "one of FOCUS_BEFORE_DESCENDANTS, FOCUS_AFTER_DESCENDANTS, FOCUS_BLOCK_DESCENDANTS "
+ "but is " + descendantFocusability);
}
if (result && !isLayoutValid() && ((mPrivateFlags & PFLAG_WANTS_FOCUS) == 0)) {
mPrivateFlags |= PFLAG_WANTS_FOCUS;
}
return result;
}
// 9.viewGroup的默认实现，这里深度优先遍历子view
protected boolean onRequestFocusInDescendants(int direction,
Rect previouslyFocusedRect) {
int index;
int increment;
int end;
int count = mChildrenCount;
if ((direction & FOCUS_FORWARD) != 0) {
index = 0;
increment = 1;
end = count;
} else {
index = count - 1;
increment = -1;
end = -1;
}
final View[] children = mChildren;
for (int i = index; i != end; i += increment) {
View child = children[i];
if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE) {
// 子view调用请求焦点
if (child.requestFocus(direction, previouslyFocusedRect)) {
return true;
}
}
}
return false;
}
// 10.上面requestFocus会调用requestFocusNoSearch，如何获取焦点就会执行handleFocusGainInternal，执行结束焦点查询
private boolean requestFocusNoSearch(int direction, Rect previouslyFocusedRect) {
// need to be focusable
if (!canTakeFocus()) {
return false;
}
// need to be focusable in touch mode if in touch mode
if (isInTouchMode() &&
(FOCUSABLE_IN_TOUCH_MODE != (mViewFlags & FOCUSABLE_IN_TOUCH_MODE))) {
return false;
}
// need to not have any parents blocking us
if (hasAncestorThatBlocksDescendantFocus()) {
return false;
}
if (!isLayoutValid()) {
mPrivateFlags |= PFLAG_WANTS_FOCUS;
} else {
clearParentsWantFocus();
}
// 1.终结焦点查询实际处理
handleFocusGainInternal(direction, previouslyFocusedRect);
return true;
}
// 11.其内部调用requestChildFocus自下而上更新所有viewgroup中的focused属性
void handleFocusGainInternal(@FocusRealDirection int direction, Rect previouslyFocusedRect) {
if (DBG) {
System.out.println(this + " requestFocus()");
}
if ((mPrivateFlags & PFLAG_FOCUSED) == 0) {
mPrivateFlags |= PFLAG_FOCUSED;
View oldFocus = (mAttachInfo != null) ? getRootView().findFocus() : null;
if (mParent != null) {
// 我们这里得到了能处理焦点的view，现在自下而上更新所有viewgroup中的focused属性，绑定焦点下发链路
mParent.requestChildFocus(this, this);
updateFocusedInCluster(oldFocus, direction);
}
if (mAttachInfo != null) {
mAttachInfo.mTreeObserver.dispatchOnGlobalFocusChange(oldFocus, this);
}
onFocusChanged(true, direction, previouslyFocusedRect);
refreshDrawableState();
}
}
// 12.其内部调用mParent.requestChildFocus(this, focused)自下而上绑定焦点view路径
@Override
public void requestChildFocus(View child, View focused) {
if (DBG) {
System.out.println(this + " requestChildFocus()");
}
if (getDescendantFocusability() == FOCUS_BLOCK_DESCENDANTS) {
return;
}
// Unfocus us, if necessary
super.unFocus(focused);
// We had a previous notion of who had focus. Clear it.
if (mFocused != child) {
if (mFocused != null) {
mFocused.unFocus(focused);
}
mFocused = child;
}
if (mParent != null) {
// 这里绑定直接包含获取焦点的子view到自己的focused属性
mParent.requestChildFocus(this, focused);
}
}
// 13.绑定焦点路径之后，会ViewRootImpl.ViewPostImeInputStage.java，实际的keyEvent派发
protected int onProcess(QueuedInputEvent q) {
if (q.mEvent instanceof KeyEvent) {
// 派发
return processKeyEvent(q);
} else {
final int source = q.mEvent.getSource();
if ((source & InputDevice.SOURCE_CLASS_POINTER) != 0) {
return processPointerEvent(q);
} else if ((source & InputDevice.SOURCE_CLASS_TRACKBALL) != 0) {
return processTrackballEvent(q);
} else {
return processGenericMotionEvent(q);
}
}
}
// 14. 触发dispatchKeyEvent派发KeyEvent
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.
// 派发KeyEvent到View树中
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.
// 省略 .....
return FORWARD;
}
// 15.嵌套的ViewGroup一层一层向下执行调用，ViewGroup.dispatchKeyEvent
@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)) {
return true;
}
} else if (mFocused != null && (mFocused.mPrivateFlags & PFLAG_HAS_BOUNDS)
== PFLAG_HAS_BOUNDS) {
// 这里mFocused是我们检索焦点完成之后，保存的直接包含焦点view的直接子类，这里循环下发到最终的有焦点的view上
if (mFocused.dispatchKeyEvent(event)) {
return true;
}
}
if (mInputEventConsistencyVerifier != null) {
mInputEventConsistencyVerifier.onUnhandledEvent(event, 1);
}
return false;
}
// 16.最终获取焦点的view，执行其View.dispatchKeyEvent函数，判断是否有mOnKeyListener 触发，消费事件
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)) {
return true;
}
if (event.dispatch(this, mAttachInfo != null
? mAttachInfo.mKeyDispatchState : null, this)) {
return true;
}
if (mInputEventConsistencyVerifier != null) {
mInputEventConsistencyVerifier.onUnhandledEvent(event, 0);
}
return false;
}下图中展示了检索焦点view时候的调用栈，其中是检索阶段
图五：检索默认焦点堆栈
下图展示了KeyEvent下发的调用栈，可以看到绑定了焦点路径的所有view或者viewGroup的DispatchKeyEvent都被调用了
图六：自上而下传递KeyEvent，最终被view接收处理
通过查看源码和触发调用栈，我们清楚了在首次方向键触发的时候，其实会有一个寻焦过程，其由ViewRootImpl.EarlyPostImeInputStage.java承接，通过自上而下requestFocus循环调用最终确定了获取焦点的View，在之后触发的KeyEvent事件会根据"焦点路径"直接下发到焦点view中。
以上场景只是适用于首次寻焦，之后的KeyEvent派发都会由我们自己代码进行焦点指定的场景。
下面放一张网上的图看下正常KeyEvent分派的流程
那么我们在android12 上遇到无法触发应用选中的问题要怎么定位呢？
首先看下焦点是否已经分配到目标view上，通过设置断点主要是断点到requestFocus函数。其中ViewGroup和View对其实现是不一致的，在ViewGroup中会通过descendantFocusability来决定判断策略，如果是以自己优先还是以子view优先，通过这一步，其实我们的问题已经可以得到答案，在首页架构的Celllayout层，其寻焦策略是FOCUS_BEFORE_DESCENDANTS，使得其子view没办法参与焦点的获取。我们修改其策略就可以解决。
参考资料：
www.jianshu.com/p/2115b3f17...