Android R WindowManagerService模块(5) 焦点窗口和InputWindows的更新(1)

if (mode != UPDATE_FOCUS_WILL_ASSIGN_LAYERS) {
getInputMonitor().setInputFocusLw(newFocus, updateInputWindows);
}
// 为IME窗口进行调整
adjustForImeIfNeeded();
// Toast窗口
scheduleToastWindowsTimeoutIfNeededLocked(oldFocus, newFocus);

if (mode == UPDATE_FOCUS_PLACING_SURFACES) {
pendingLayoutChanges |= FINISH_LAYOUT_REDO_ANIM;
}
return true;
}

以上方法中：

1. 通过findFocusedWindowIfNeeded()方法寻找焦点窗口；
1. 根据焦点窗口的变化，更新Input Target窗口；
1. 更新全局焦点窗口对象mCurrentFocus；
1. 根据更新的不同阶段做不同处理。

下面看下如何寻找到焦点窗口。

1.4.DisplayContent#findFocusedWindowIfNeeded()

在这个方法中，会寻找到新的焦点窗口：

// frameworks/base/services/core/java/com/android/server/wm/DisplayContent.java

WindowState findFocusedWindowIfNeeded(int topFocusedDisplayId) {
return (mWmService.mPerDisplayFocusEnabled || topFocusedDisplayId == INVALID_DISPLAY)
? findFocusedWindow() : null;
}

当topFocusedDisplayId为INVALID_DISPLAY时，认为当前焦点display没有焦点窗口，需要寻找重新确认，所以又继续执行findFocusedWindow()方法寻找：

// frameworks/base/services/core/java/com/android/server/wm/DisplayContent.java

WindowState findFocusedWindow() {
mTmpWindow = null;
// 遍历WindowState
forAllWindows(mFindFocusedWindow, true /* traverseTopToBottom */);

if (mTmpWindow == null) {
return null;
}
return mTmpWindow;
}

该方法中，会遍历所有WindowState，然后将寻找到的WindowState赋值给mTmpWindow，并返回给WMS。接下来看下这个mFindFocusedWindow函数接口对象：

// frameworks/base/services/core/java/com/android/server/wm/DisplayContent.java

private final ToBooleanFunction mFindFocusedWindow = w -> {
// 当前处于前台的ActivityRecord
final ActivityRecord focusedApp = mFocusedApp;
// 如果窗口无法接收key事件，则不能作为焦点窗口，返回false
if (!w.canReceiveKeys()) {
return false;
}

final ActivityRecord activity = w.mActivityRecord;
// 如果前台没有Activity，则此次WindowState将作为焦点窗口返回
if (focusedApp == null) {
mTmpWindow = w;
return true;
}
// 如果前台Activity是不可获焦的，则此次WindowState将作为焦点窗口返回
if (!focusedApp.windowsAreFocusable()) {
mTmpWindow = w;
return true;
}
// 如果当前WindowState由ActivityRecord管理，且非StartingWindow，则当
if (activity != null && w.mAttrs.type != TYPE_APPLICATION_STARTING) {
if (focusedApp.compareTo(activity) > 0) {
mTmpWindow = null;
return true;
}
}
// 不满足以上条件，则此次WindowState将作为焦点窗口返回
mTmpWindow = w;
return true;
};

该方法中，将依次根据如下条件获得焦点窗口：

1. 如果WindowState不能接收Input事件，则不能作为焦点窗口；
1. 如果没有前台Activity，则当前WindowState作为焦点窗口返回；
1. 如果前台Activity是不可获焦状态，则当前WindowState作为焦点窗口返回；
1. 如果当前WindowState由ActivityRecord管理，且该WindowState不是Staring Window类型，那么当前台Activity在当前WindowState所属Activity之上时，不存在焦点窗口；
1. 如果以上条件都不满足，则当前WindowState作为焦点窗口返回；

1.3.1.WindowState能否接受Input事件

这里接着看下第一个条件，判断窗口能否可以接受Input事件，由WindowState#canReceiveKeys()方法进行判断：

// frameworks/base/services/core/java/com/android/server/wm/WindowState.java

public boolean canReceiveKeys(boolean fromUserTouch) {
// 可见或处于addWindow()~relayout之间
final boolean canReceiveKeys = isVisibleOrAdding()
// 客户端View可见
&& (mViewVisibility == View.VISIBLE)
// 退出动画执行完毕
&& !mRemoveOnExit
// 没有FLAG_NOT_FOCUSABLE标记
&& ((mAttrs.flags & WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE) == 0)
// mActivityRecord为null或者其可获焦
&& (mActivityRecord == null || mActivityRecord.windowsAreFocusable(fromUserTouch))
// 可以接受touch事件
&& !cantReceiveTouchInput();
if (!canReceiveKeys) {
return false;
}
return fromUserTouch || getDisplayContent().isOnTop()
|| getDisplayContent().isTrusted();
}

如果一个WindowState可以接受Input事件，需要同时满足多个条件：

1. isVisibleOrAdding()方法为true，表示该WindowState可见或处于添加过程中:
1. mViewVisibility属性为View.VISIBLE，表示客户端View可见；
1. mRemoveOnExit为false，表示WindowState的退出动画不存在；
1. mAttrs.flags中不存在FLAG_NOT_FOCUSABLE标记，该标记如果设置，表示该窗口为不可获焦窗口；
1. mActivityRecord为null或者mActivityRecord可获焦；
1. cantReceiveTouchInput()方法为false，表示可以接受Touch事件。

isVisibleOrAdding()方法用来判断该WindowState可见或处于添加过程中:

// frameworks/base/services/core/java/com/android/server/wm/WindowState.java

boolean isVisibleOrAdding() {
final ActivityRecord atoken = mActivityRecord;
// Surface已经创建，说明relayout()已经执行
return (mHasSurface
// relayout()未执行，且客户端View可见状态
|| (!mRelayoutCalled && mViewVisibility == View.VISIBLE))
// 表示该WindowState由policy控制可见性的flag全部设置
&& isVisibleByPolicy()
// 如果是子窗口，其副窗口的mHidden属性为false
&& !isParentWindowHidden()
// mActivityRecord为null，或者其mVisibleRequested为true
&& (atoken == null || atoken.mVisibleRequested)
// 没有执行退出动画
&& !mAnimatingExit
// Surface没有进行销毁
&& !mDestroying;
}

如果以上条件都满足，则返回true。

cantReceiveTouchInput()方法用来判断该WindowState是否能够接收touch事件：

// frameworks/base/services/core/java/com/android/server/wm/WindowState.java

boolean cantReceiveTouchInput() {
// 如果mActivityRecord为null，或mActivityRecord所在Task为null，返回false
if (mActivityRecord == null || mActivityRecord.getTask() == null) {
return false;
}
// 所在Task是否忽略输入事件
return mActivityRecord.getTask().getStack().shouldIgnoreInput()
// mActivityRecord.mVisibleRequested属性为false
|| !mActivityRecord.mVisibleRequested
// 最近任务动画在消费Input事件
|| isRecentsAnimationConsumingAppInput();
}

回到mFindFocusedWindow接口对象中，其他条件就不一一说明，最终从DisplayContent中自顶向下寻找到的第一个满足条件的窗口，将作为新的焦点窗口后，接下来更新Display#mCurrentFocus变量，表示当前焦点窗口。

2.InputWindows的更新

InputWindow的更新，是通过InputMonitor#updateInputWindowsLw()方法来进行。在焦点窗口的更新过程以及窗口的添加过程中，都会通过InputMonitor#setInputFocusLw()方法将新的焦点窗口同步给InputMonitor，并开始更新Input Windows。下面从这个方法开始看下Input windows的更新过程。

2.1.InputMonitor#updateInputWindowsLw()

该方法中，会将新的焦点窗口同步给InputMonitor：

// frameworks/base/services/core/java/com/android/server/wm/InputMonitor.java

public void setInputFocusLw(WindowState newWindow, boolean updateInputWindows) {
if (newWindow != mInputFocus) {
if (newWindow != null && newWindow.canReceiveKeys()) {
newWindow.mToken.paused = false;
}
// 更新当前焦点窗口
mInputFocus = newWindow;
setUpdateInputWindowsNeededLw();
// 更新所有inputwindow
if (updateInputWindows) {
updateInputWindowsLw(false /force/);
}
}
}

之后将执行updateInputWindowsLw()方法来完成所有InputWindows的更新，该方法的执行时机非常多。

2.2.InputMonitor#updateInputWindowsLw()

在该方法中，只有当强制更新或者mUpdateInputWindowsNeeded值为true时，才会进行InputWindows的更新：

// frameworks/base/services/core/java/com/android/server/wm/InputMonitor.java

void updateInputWindowsLw(boolean force) {
if (!force && !mUpdateInputWindowsNeeded) {
return;
}
scheduleUpdateInputWindows();
}

mUpdateInputWindowsNeeded变量表示是否需要更新InputWindows，当需要更新时，会通过setUpdateInputWindowsNeededLw()将该变量值设置为true：

// frameworks/base/services/core/java/com/android/server/wm/InputMonitor.java

void setUpdateInputWindowsNeededLw() {
mUpdateInputWindowsNeeded = true;
}

之后将执行scheduleUpdateInputWindows()方法，在这个方法中，会post一个Runnable对象，在mHandler所在的android.anim线程中执行更新流程：

// frameworks/base/services/core/java/com/android/server/wm/InputMonitor.java

private class UpdateInputWindows implements Runnable {
@Override
public void run() {
synchronized (mService.mGlobalLock) {
// 重置
mUpdateInputWindowsPending = false;
mUpdateInputWindowsNeeded = false;

// 是否正在拖拽
final boolean inDrag = mService.mDragDropController.dragDropActiveLocked();

mUpdateInputForAllWindowsConsumer.updateInputWindows(inDrag);
}
}
}

接下来执行mUpdateInputForAllWindowsConsumer.updateInputWindows()方法。

2.3.mUpdateInputForAllWindowsConsumer.updateInputWindows()

在该方法中，首先会确认是否存在几类特殊的InputConsumer。InputConsumer用于读取事件，每个窗口对应的客户端都会通过InputConsumer来读取和消费事件，一般情况下，ViewRootImpl在添加窗口过程中，会在注册InputEventReceiver时自动创建InputConsumer对象。此处的四类特殊InputConsumer则是对一些系统UI显式地进行了创建：

// frameworks/base/services/core/java/com/android/server/wm/InputMonitor.java

private void updateInputWindows(boolean inDrag) {
// 显式创建的特殊InputConsumer对象
// 用于处理Nav相关input事件
mNavInputConsumer = getInputConsumer(INPUT_CONSUMER_NAVIGATION);
// 用于处理Pip相关input事件
mPipInputConsumer = getInputConsumer(INPUT_CONSUMER_PIP);
// 用于处理壁纸相关input事件
mWallpaperInputConsumer = getInputConsumer(INPUT_CONSUMER_WALLPAPER);
// 用于处理最近任务相关input事件
mRecentsAnimationInputConsumer = getInputConsumer(INPUT_CONSUMER_RECENTS_ANIMATION);

mAddRecentsAnimationInputConsumerHandle = mRecentsAnimationInputConsumer != null;

mTmpRect.setEmpty();
mDisableWallpaperTouchEvents = false;
mInDrag = inDrag;

mWallpaperController = mDisplayContent.mWallpaperController;
// 重置mInputTransaction
resetInputConsumers(mInputTransaction);

// 遍历
mDisplayContent.forAllWindows(this,
true /* traverseTopToBottom */);
// 将mInputTransaction合并到mPendingTransaction上进行提交
if (!mUpdateInputWindowsImmediately) {
mDisplayContent.getPendingTransaction().merge(mInputTransaction);
mDisplayContent.scheduleAnimation();
}

}

然后，将发起所有WindowState的遍历，mUpdateInputForAllWindowsConsumer本身是一个Consumer接口对象，因此会回调accept()方法对每个WindowState进行处理：

// frameworks/base/services/core/java/com/android/server/wm/InputMonitor.java

@Override
public void accept(WindowState w) {
// 获取WindowState的InputChannel对象
final InputChannel inputChannel = w.mInputChannel;
// 获取WindowState的InputWindowHandle对象
final InputWindowHandle inputWindowHandle = w.mInputWindowHandle;
// 最近任务是否存在
final RecentsAnimationController recentsAnimationController =
mService.getRecentsAnimationController();
final boolean shouldApplyRecentsInputConsumer = recentsAnimationController != null
&& recentsAnimationController.shouldApplyInputConsumer(w.mActivityRecord);
final int type = w.mAttrs.type;

…

final int flags = w.mAttrs.flags;
final int privateFlags = w.mAttrs.privateFlags;
// 是否是焦点窗口
final boolean hasFocus = w.isFocused();
// mRecentsAnimationInputConsumer处理最近任务相关input事件
if (mAddRecentsAnimationInputConsumerHandle && shouldApplyRecentsInputConsumer) {
if (recentsAnimationController.updateInputConsumerForApp(
mRecentsAnimationInputConsumer.mWindowHandle, hasFocus)) {
mRecentsAnimationInputConsumer.show(mInputTransaction, w);
mAddRecentsAnimationInputConsumerHandle = false;
}
}

// 处理处于PIP模式时的input事件
if (w.inPinnedWindowingMode()) {

}
// mNavInputConsumer处理Nav相关input事件
if (mAddNavInputConsumerHandle) {
mNavInputConsumer.show(mInputTransaction, w);
mAddNavInputConsumerHandle = false;
}

// mWallpaperInputConsumer处理壁纸input事件
if (mAddWallpaperInputConsumerHandle) {
if (w.mAttrs.type == TYPE_WALLPAPER && w.isVisibleLw()) {
mWallpaperInputConsumer.show(mInputTransaction, w);
mAddWallpaperInputConsumerHandle = false;
}
}
// 是否壁纸不接收input事件
if ((privateFlags & PRIVATE_FLAG_DISABLE_WALLPAPER_TOUCH_EVENTS) != 0) {
mDisableWallpaperTouchEvents = true;
}
final boolean hasWallpaper = mWallpaperController.isWallpaperTarget(w)
&& !mService.mPolicy.isKeyguardShowing()
&& !mDisableWallpaperTouchEvents;
// 是否处于拖拽过程中
if (mInDrag && isVisible && w.getDisplayContent().isDefaultDisplay) {
mService.mDragDropController.sendDragStartedIfNeededLocked(w);
}
// 填充InputWindowHandle
populateInputWindowHandle(
inputWindowHandle, w, flags, type, isVisible, hasFocus, hasWallpaper);

// 提交inputWindowHandle
if (w.mWinAnimator.hasSurface()) {
mInputTransaction.setInputWindowInfo(
w.mWinAnimator.mSurfaceController.getClientViewRootSurface(),
inputWindowHandle);
}
}

以上方法中：

首先会对几类特殊InputConsumer进行单独处理；
然后填充InputWindowHandle对象；
最后将InputWindowHandle对象设置给Transaction对象，并在事物提交后，由SurfaceFlinger设置给InputDispatcher中。

InputWindowHandle代表了WindowState，传给了InputDispatcher中用于派发事件，当InputDispatcher中进行事件的派发时，将以InputWindowHandle确定需要派发给哪些窗口。下面来看下对inputWindowHandle对象的填充。

2.4.InputMonitor#populateInputWindowHandle()

在该方法中，会将WindowState的部分属性填充给inputWindowHandle：

//frameworks/base/services/core/java/com/android/server/wm/InputMonitor.java

void populateInputWindowHandle(final InputWindowHandle inputWindowHandle,
final WindowState child, int flags, final int type, final boolean isVisible,
final boolean hasFocus, final boolean hasWallpaper) {
inputWindowHandle.name = child.toString();
inputWindowHandle.inputApplicationHandle = child.mActivityRecord != null
? child.mActivityRecord.getInputApplicationHandle(false /* update */) : null;
flags = child.getSurfaceTouchableRegion(inputWindowHandle, flags);
inputWindowHandle.layoutParamsFlags = flags;
inputWindowHandle.layoutParamsType = type;
inputWindowHandle.dispatchingTimeoutNanos = child.getInputDispatchingTimeoutNanos();
inputWindowHandle.visible = isVisible;
inputWindowHandle.canReceiveKeys = child.canReceiveKeys();
inputWindowHandle.hasFocus = hasFocus;
inputWindowHandle.hasWallpaper = hasWallpaper;
inputWindowHandle.paused = child.mActivityRecord != null ? child.mActivityRecord.paused : false;
inputWindowHandle.ownerPid = child.mSession.mPid;
inputWindowHandle.ownerUid = child.mSession.mUid;
inputWindowHandle.inputFeatures = child.mAttrs.inputFeatures;
inputWindowHandle.displayId = child.getDisplayId();

final Rect frame = child.getFrameLw();
inputWindowHandle.frameLeft = frame.left;
inputWindowHandle.frameTop = frame.top;
inputWindowHandle.frameRight = frame.right;
inputWindowHandle.frameBottom = frame.bottom;

inputWindowHandle.surfaceInset = child.getAttrs().surfaceInsets.left;

if (child.getTask() != null && child.getTask().isOrganized()) {
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。