WindowManagerService - 窗口焦点

// frameworks/base/services/core/java/com/android/server/wm/WindowManagerService.java
// TODO: Move to DisplayContent
boolean updateFocusedWindowLocked(int mode, boolean updateInputWindows) {
    // 从RootWindowContainer拿到当前的焦点WindowState，如果同上次获取的`mCurrentFocus`不一致，则认为发生了焦点变动。
    WindowState newFocus = mRoot.computeFocusedWindow();
    if (mCurrentFocus != newFocus) {
        // 发送REPORT_FOCUS_CHANGE消息，告知焦点发生变化。mH对应的Looper同DisplayManagerService的一致。均运行在DisplayThread中。
        mH.removeMessages(H.REPORT_FOCUS_CHANGE);
        mH.sendEmptyMessage(H.REPORT_FOCUS_CHANGE);
        // 这里其实有问题，如果由多个Display，那么此时应当使用newFocus对应的DisplayContent，而不是默认DisplayContent
        final DisplayContent displayContent = getDefaultDisplayContentLocked();
        ...
        final WindowState oldFocus = mCurrentFocus;
        mCurrentFocus = newFocus;
        mLosingFocus.remove(newFocus);
        ...
        int focusChanged = mPolicy.focusChangedLw(oldFocus, newFocus);
        ..
        if ((focusChanged & FINISH_LAYOUT_REDO_LAYOUT) != 0) {
            // The change in focus caused us to need to do a layout.  Okay.
            displayContent.setLayoutNeeded();
            if (mode == UPDATE_FOCUS_PLACING_SURFACES) {
                displayContent.performLayout(true /*initial*/, updateInputWindows);
            }
        }
        ...
        return true;
    }
    return false;
}

// frameworks/base/services/core/java/com/android/server/wm/RootWindowContainer.java
WindowState computeFocusedWindow() {
    for (int i = mChildren.size() - 1; i >= 0; i--) {
        final DisplayContent dc = mChildren.get(i);
        final WindowState win = dc.findFocusedWindow();
        if (win != null) {
            return win;
        }
    }
    return null;
}

// frameworks/base/services/core/java/com/android/server/wm/DisplayContent.java
WindowState findFocusedWindow() {
    mTmpWindow = null;
    // 遍历所有的Child，其中traverseTopToBottom这个参数则表示从后往前倒序遍历。
    forAllWindows(mFindFocusedWindow, true /* traverseTopToBottom */);
    return mTmpWindow;
}

private final ToBooleanFunction<WindowState> mFindFocusedWindow = w -> {
    // 拿到WindowManagerService中的`mFocusedApp`，即处在焦点状态下的AppWindowToken。ActivityThread收到`scheduleResumeActivity`消息之前，会调用WMS的`setFocusedApp`将mFocusedApp设定。
    final AppWindowToken focusedApp = mService.mFocusedApp;
    if (!w.canReceiveKeys())  return false;
    final AppWindowToken wtoken = w.mAppToken;
    // If this window's application has been removed, just skip it.
    if (wtoken != null && (wtoken.removed || wtoken.sendingToBottom)) {
        return false;
    }
    if (focusedApp == null) {
        mTmpWindow = w;
        return true;
    }
    if (!focusedApp.windowsAreFocusable()) {
        mTmpWindow = w;
        return true;
    }
    if (wtoken != null && w.mAttrs.type != TYPE_APPLICATION_STARTING) {
        if (focusedApp.compareTo(wtoken) > 0) {
            mTmpWindow = null;
            return true;
        }
    }
    mTmpWindow = w;
    return true;
};

// frameworks/base/services/core/java/com/android/server/wm/DisplayContent.java
@Override
boolean forAllWindows(ToBooleanFunction<WindowState> callback, boolean traverseTopToBottom) {
    // Special handling so we can process IME windows with #forAllImeWindows above their IME
    // target, or here in order if there isn't an IME target.
    // 在这里mChildren被当作一个栈来处理。也就是说
    if (traverseTopToBottom) {
        for (int i = mChildren.size() - 1; i >= 0; --i) {
            final DisplayChildWindowContainer child = mChildren.get(i);
            if (child == mImeWindowsContainers && mService.mInputMethodTarget != null) {
                // In this case the Ime windows will be processed above their target so we skip here.
                continue;
            }
            if (child.forAllWindows(callback, traverseTopToBottom)) {
                return true;
            }
        }
    }
    ...
    return false;
}

// frameworks/base/services/core/java/com/android/server/wm/DisplayContent.java
DisplayContent(Display display, WindowManagerService service,
        WindowLayersController layersController, WallpaperController wallpaperController) {
    ...
    // These are the only direct children we should ever have and they are permanent.
    super.addChild(mBelowAppWindowsContainers, null);
    super.addChild(mTaskStackContainers, null);
    super.addChild(mAboveAppWindowsContainers, null);
    super.addChild(mImeWindowsContainers, null);
    // Add itself as a child to the root container.
    mService.mRoot.addChild(this, null);
    mDisplayReady = true;
}

TaskStack addStackToDisplay(int stackId, boolean onTop) {
    TaskStack stack = getStackById(stackId);
    if (stack != null) {
        mTaskStackContainers.positionChildAt(onTop ? POSITION_TOP : POSITION_BOTTOM, stack, false /* includingParents */);
    } else {
        stack = new TaskStack(mService, stackId);
        mTaskStackContainers.addStackToDisplay(stack, onTop);
    }
    if (stackId == DOCKED_STACK_ID) {
        mDividerControllerLocked.notifyDockedStackExistsChanged(true);
    }
    return stack;
}

// frameworks/base/services/core/java/com/android/server/wm/WindowManagerService.java
final class H extends android.os.Handler {
    @Override
    public void handleMessage(Message msg) {
        switch (msg.what) {
            case REPORT_FOCUS_CHANGE: {
                WindowState lastFocus;
                WindowState newFocus;
                AccessibilityController accessibilityController = null;
                synchronized(mWindowMap) {
                    if (mAccessibilityController != null && getDefaultDisplayContentLocked().getDisplayId() == DEFAULT_DISPLAY) {
                        accessibilityController = mAccessibilityController;
                    }

                    lastFocus = mLastFocus;
                    newFocus = mCurrentFocus;
                    // 当消息运行时，发生了多次Focus变化。此时如果mCurrentFocus同上次分发后的mLastFocus一致。即Client端的窗口并未发生变化，那么就无需通知Client
                    if (lastFocus == newFocus) {
                        return;
                    }
                    mLastFocus = newFocus;
                    if (newFocus != null && lastFocus != null && !newFocus.isDisplayedLw()) {
                        mLosingFocus.add(lastFocus);
                        lastFocus = null;
                    }
                }

                // First notify the accessibility manager for the change so it has
                // the windows before the newly focused one starts firing eventgs.
                if (accessibilityController != null) {
                    accessibilityController.onWindowFocusChangedNotLocked();
                }

                if (newFocus != null) {
                    // 向mCurrentFocus发送一个获得焦点的消息。即mClient.windowFocusChanged(true)
                    newFocus.reportFocusChangedSerialized(true, mInTouchMode);
                    notifyFocusChanged();
                }

                if (lastFocus != null) {
                    // 向lastFocus发送一个失去焦点的消息。即mClient.windowFocusChanged(false)
                    lastFocus.reportFocusChangedSerialized(false, mInTouchMode);
                }
            } break;

            case REPORT_LOSING_FOCUS: {
                ArrayList<WindowState> losers;
                synchronized(mWindowMap) {
                    losers = mLosingFocus;
                    mLosingFocus = new ArrayList<WindowState>();
                }
                final int N = losers.size();
                for (int i=0; i<N; i++) {
                    losers.get(i).reportFocusChangedSerialized(false, mInTouchMode);
                }
            } break;
            ...
        }
    ...
}

// frameworks/base/services/core/java/com/android/server/wm/WindowState.java
void reportFocusChangedSerialized(boolean focused, boolean inTouchMode) {
    try {
        mClient.windowFocusChanged(focused, inTouchMode);
    } catch (RemoteException e) {
    }
    // 回调远程监听焦点的Callback。略。
    ...
}

// frameworks/base/core/java/android/view/ViewRootImpl.java
static class W extends IWindow.Stub {
    ...
    @Override
    public void windowFocusChanged(boolean hasFocus, boolean inTouchMode) {
        final ViewRootImpl viewAncestor = mViewAncestor.get();
        if (viewAncestor != null) {
            viewAncestor.windowFocusChanged(hasFocus, inTouchMode);
        }
    }
    ...
}

// frameworks/base/core/java/android/view/ViewRootImpl.java
public void windowFocusChanged(boolean hasFocus, boolean inTouchMode) {
    synchronized (this) {
        mWindowFocusChanged = true;
        mUpcomingWindowFocus = hasFocus;
        mUpcomingInTouchMode = inTouchMode;
    }
    Message msg = Message.obtain();
    msg.what = MSG_WINDOW_FOCUS_CHANGED;
    mHandler.sendMessage(msg);
}

// frameworks/base/core/java/android/view/ViewRootImpl.java
private void handleWindowFocusChanged() {
    final boolean hasWindowFocus;
    final boolean inTouchMode;
    synchronized (this) {
        if (!mWindowFocusChanged) {
            return;
        }
        mWindowFocusChanged = false;
        hasWindowFocus = mUpcomingWindowFocus;
        inTouchMode = mUpcomingInTouchMode;
    }

    if (mAdded) {
        profileRendering(hasWindowFocus);

        if (hasWindowFocus) {
            ensureTouchModeLocally(inTouchMode);
            if (mAttachInfo.mThreadedRenderer != null && mSurface.isValid()) {
                mFullRedrawNeeded = true;
                try {
                    final WindowManager.LayoutParams lp = mWindowAttributes;
                    final Rect surfaceInsets = lp != null ? lp.surfaceInsets : null;
                    // 更新硬件加速相关的逻辑。
                    mAttachInfo.mThreadedRenderer.initializeIfNeeded(
                            mWidth, mHeight, mAttachInfo, mSurface, surfaceInsets);
                } catch (OutOfResourcesException e) {
                    try {
                        if (!mWindowSession.outOfMemory(mWindow)) {
                            Process.killProcess(Process.myPid());
                        }
                    } catch (RemoteException ex) {
                    }
                    mHandler.sendMessageDelayed(mHandler.obtainMessage(MSG_WINDOW_FOCUS_CHANGED), 500);
                    return;
                }
            }
        }

        mAttachInfo.mHasWindowFocus = hasWindowFocus;

        mLastWasImTarget = WindowManager.LayoutParams.mayUseInputMethod(mWindowAttributes.flags);

        InputMethodManager imm = InputMethodManager.peekInstance();
        if (imm != null && mLastWasImTarget && !isInLocalFocusMode()) {
            imm.onPreWindowFocus(mView, hasWindowFocus);
        }
        if (mView != null) {
            mAttachInfo.mKeyDispatchState.reset();
            // 向DecorView分发dispatchWindowFocusChanged的消息。最后DecorView拿到PhoneWindow的Callback，将消息发送到Activity中。
            mView.dispatchWindowFocusChanged(hasWindowFocus);
            mAttachInfo.mTreeObserver.dispatchOnWindowFocusChange(hasWindowFocus);

            if (mAttachInfo.mTooltipHost != null) {
                mAttachInfo.mTooltipHost.hideTooltip();
            }
        }

        // Note: must be done after the focus change callbacks,
        // so all of the view state is set up correctly.
        if (hasWindowFocus) {
            if (imm != null && mLastWasImTarget && !isInLocalFocusMode()) {
                imm.onPostWindowFocus(mView, mView.findFocus(),
                        mWindowAttributes.softInputMode,
                        !mHasHadWindowFocus, mWindowAttributes.flags);
            }
            // Clear the forward bit.  We can just do this directly, since
            // the window manager doesn't care about it.
            mWindowAttributes.softInputMode &= ~WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION;
            ((WindowManager.LayoutParams) mView.getLayoutParams())
                    .softInputMode &= ~WindowManager.LayoutParams .SOFT_INPUT_IS_FORWARD_NAVIGATION;
            mHasHadWindowFocus = true;

            // Refocusing a window that has a focused view should fire a
            // focus event for the view since the global focused view changed.
            fireAccessibilityFocusEventIfHasFocusedNode();
        } else {
            if (mPointerCapture) {
                handlePointerCaptureChanged(false);
            }
        }
    }
    mFirstInputStage.onWindowFocusChanged(hasWindowFocus);
}

// ViewGroup.java
@Override
public void dispatchWindowFocusChanged(boolean hasFocus) {
    super.dispatchWindowFocusChanged(hasFocus);
    final int count = mChildrenCount;
    final View[] children = mChildren;
    for (int i = 0; i < count; i++) {
        children[i].dispatchWindowFocusChanged(hasFocus);
    }
}

//View.java
public void dispatchWindowFocusChanged(boolean hasFocus) {
    onWindowFocusChanged(hasFocus);
}

// frameworks/base/core/java/com/android/internal/policy/DecorView.java
@Override
public void onWindowFocusChanged(boolean hasWindowFocus) {
    super.onWindowFocusChanged(hasWindowFocus);

    // If the user is chording a menu shortcut, release the chord since
    // this window lost focus
    if (mWindow.hasFeature(Window.FEATURE_OPTIONS_PANEL) && !hasWindowFocus && mWindow.mPanelChordingKey != 0) {
        mWindow.closePanel(Window.FEATURE_OPTIONS_PANEL);
    }

    // 如果是Activity，那么这个Callback就是Activity本身。否则也有可能是Dialog等。
    final Window.Callback cb = mWindow.getCallback();
    if (cb != null && !mWindow.isDestroyed() && mFeatureId < 0) {
        cb.onWindowFocusChanged(hasWindowFocus);
    }
    if (mPrimaryActionMode != null) {
        mPrimaryActionMode.onWindowFocusChanged(hasWindowFocus);
    }
    if (mFloatingActionMode != null) {
        mFloatingActionMode.onWindowFocusChanged(hasWindowFocus);
    }

    updateElevation();
}