WindowManagerService（WMS）是 Android 窗口系统的核心。它管理系统中所有窗口的添加、删除、层级、焦点和动画，是 Surface 分配和 Input 事件分发的中枢。本文基于 Android 11 (API 30) AOSP 源码，深入分析 WMS 的核心架构、窗口容器层级、窗口添加流程、Z-Order 管理、Input 焦点机制和 SurfaceFlinger 交互。

一、WMS 在系统架构中的定位

WMS 运行在 system_server 进程中，作为系统服务注册在 ServiceManager 中。它在 startOtherServices() 阶段被启动，晚于 AMS（因为 WMS 的一些初始化依赖 AMS 已就绪）。

应用进程                         system_server
┌──────────────┐              ┌─────────────────────────────┐
│  View        │              │  WindowManagerService (WMS) │
│  ViewRootImpl│  Binder IPC  │  ├── WindowManagerPolicy    │
│  IWindow     │◄────────────►│  │   (PhoneWindowManager)   │
│  IWindowSession│            │  ├── RootWindowContainer    │
│              │              │  │   ├── DisplayContent     │
│              │              │  │   │   ├── Task           │
│              │              │  │   │   │   └── WindowState│
│              │              │  ├── WindowAnimator         │
│              │              │  ├── InputManagerService    │
│              │              │  └── SurfaceAnimationRunner │
└──────────────┘              └──────────┬──────────────────┘
                                         │
                              ┌──────────▼──────────────────┐
                              │    SurfaceFlinger           │
                              │    (native service)         │
                              │    负责 Surface 合成与显示   │
                              └─────────────────────────────┘

AOSP 核心路径：

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

二、WMS 的启动流程

2.1 SystemServer 中启动 WMS

// frameworks/base/services/java/com/android/server/SystemServer.java
private void startOtherServices() {
    // 先创建 InputManagerService，WMS 依赖它
    inputManager = new InputManagerService(context);

    // 创建 WMS
    wm = WindowManagerService.main(context, inputManager,
            !mFirstBoot, mOnlyCore,
            new PhoneWindowManager(), mActivityManagerService.mActivityTaskManager);
    ServiceManager.addService(Context.WINDOW_SERVICE, wm, false,
            DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PRIORITY_NORMAL);

    // 发布 InputManagerService
    inputManager.setWindowManagerCallbacks(wm.getInputMonitor());
    inputManager.start();

    // 在 AMS 就绪后告知 WMS
    mActivityManagerService.setWindowManager(wm);
    wm.onInitReady();
}

2.2 WMS.main 和构造函数

// frameworks/base/services/core/java/com/android/server/wm/WindowManagerService.java
public static WindowManagerService main(Context context,
        InputManagerService inputManager, boolean showBootMsgs,
        boolean onlyCore, WindowManagerPolicy policy,
        ActivityTaskManagerService atm) {
    return new WindowManagerService(context, inputManager, showBootMsgs, onlyCore, policy, atm);
}

private WindowManagerService(Context context, InputManagerService inputManager,
        boolean showBootMsgs, boolean onlyCore, WindowManagerPolicy policy,
        ActivityTaskManagerService atm) {
    mContext = context;
    mPolicy = policy;               // PhoneWindowManager，处理窗口策略
    mAtmService = atm;              // ATMS 引用
    mInputManager = inputManager;

    // 创建主线程 Handler
    mH = new H(mHandlerThread.getLooper());

    // 创建 WindowAnimator（管理窗口动画）
    mAnimator = new WindowAnimator(this);

    // 创建 RootWindowContainer（窗口容器根节点）
    mRoot = new RootWindowContainer(this);

    // 初始化 Surface 控制工厂
    mSurfaceControlFactory = new SurfaceControl.Builder()::build;

    // 注册到 Watchdog
    Watchdog.getInstance().addMonitor(this);

    // 创建 Choreographer，用于协调 vsync
    mChoreographer = Choreographer.getSfInstance();
}

三、窗口容器层级体系（WindowContainer Hierarchy）

Android 10+ 重构了窗口管理层级，引入了统一的 WindowContainer 体系。这是 WMS 最核心的数据结构设计。

3.1 WindowContainer 类继承树

// frameworks/base/services/core/java/com/android/server/wm/WindowContainer.java
/**
 * Defines common functionality for classes that can hold windows directly or
 * through their children in a hierarchy.
 */
class WindowContainer<E extends WindowContainer> extends ConfigurationContainer<E>
        implements Comparable<WindowContainer>, Animatable, SurfaceFreezer.Freezable {
    // 子容器列表
    protected final WindowList<E> mChildren = new WindowList<E>();
    // 父容器
    private WindowContainer mParent;
    // 自身 Surface 控制
    SurfaceControl mSurfaceControl;
    // 自己的 WindowToken（如果是窗口根）
    WindowToken mOwner;
}

3.2 完整的容器层级树

从 Android 10 开始，完整的窗口容器层级如下：

RootWindowContainer
└── DisplayContent (每个物理/虚拟屏幕)
    └── DisplayArea (Android 11+ 引入的显示区域，替代部分 Stack 功能)
        ├── TaskDisplayArea (容纳应用任务窗口)
        │   └── Task (即之前的 ActivityStack)
        │       └── ActivityRecord (即之前的 AppWindowToken)
        │           └── WindowState (每个实际的窗口 Surface)
        ├── ImeContainer (输入法容器)
        │   └── WindowToken
        │       └── WindowState (输入法窗口)
        ├── StatusBar (状态栏，Wallpaper 等)
        └── NavBar (导航栏)

3.3 WindowState——窗口的基本单位

每一个 View 对应的 Window 在 WMS 端都有一个对应的 WindowState 对象：

// frameworks/base/services/core/java/com/android/server/wm/WindowState.java
class WindowState extends WindowContainer<WindowState> implements WindowManagerPolicy.WindowState {
    final int mOwnerUid;
    final int mOwnerPid;
    final int mBaseLayer;         // 基础层级
    final int mSubLayer;          // 子层级（如 Dialog 高于 Activity）
    final WindowManager.LayoutParams mAttrs;  // 窗口属性
    final Session mSession;       // 创建此窗口的 Binder Session
    final IWindow mClient;        // 客户端 IWindow Binder 引用
    WindowToken mToken;           // 所属的 WindowToken
    SurfaceControl mSurfaceControl; // 实际的 Surface 控制对象
    boolean mHasSurface;          // Surface 是否已分配
    int mViewVisibility;          // View 可见性
    boolean mRelayoutCalled;      // 是否已经调过 relayout
}

3.4 WindowToken——应用窗口的组织者

// frameworks/base/services/core/java/com/android/server/wm/WindowToken.java
class WindowToken extends WindowContainer<WindowState> {
    final IBinder token;           // 客户端的 Binder token，用于与服务端对应
    final int windowType;          // TYPE_APPLICATION, TYPE_INPUT_METHOD 等
    final boolean mPersistOnEmpty;  // 窗口清空后是否保持 token
    boolean mRoundedCornerOverlay;  // 是否有圆角遮盖
}

3.5 DisplayContent——多屏幕支持

// frameworks/base/services/core/java/com/android/server/wm/DisplayContent.java
class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowContainer> {
    final int mDisplayId;        // 屏幕 ID
    final Display mDisplay;      // DisplayManager 的 Display 对象
    final DisplayPolicy mDisplayPolicy;  // 屏幕显示策略
    DisplayInfo mDisplayInfo;    // 屏幕信息（分辨率、DPI 等）
    // Android 11+ 引入 DisplayArea 管理
    DisplayArea.Tokens mImeInputTargetContainer; // IME 输入目标
    DisplayArea.Tokens mImeControlTargetContainer; // IME 控制目标
}

四、窗口添加流程（addWindow 全链路追踪）

窗口添加是 WMS 最核心、最复杂的操作。这里以 WindowManager.addView 为入口，追踪全链路。

4.1 应用端：WindowManager.addView → ViewRootImpl

// frameworks/base/core/java/android/view/WindowManagerGlobal.java
public void addView(View view, ViewGroup.LayoutParams params,
        Display display, Window parentWindow) {
    final WindowManager.LayoutParams wparams =
            (WindowManager.LayoutParams) params;

    ViewRootImpl root;
    synchronized (mLock) {
        // 创建 ViewRootImpl——每个 Window 一个 ViewRootImpl
        root = new ViewRootImpl(view.getContext(), display);
        view.setLayoutParams(wparams);

        mViews.add(view);
        mRoots.add(root);
        mParams.add(wparams);

        // 关键调用：通过 IWindowSession 跨进程添加窗口
        root.setView(view, wparams, panelParentView);
    }
}

4.2 ViewRootImpl.setView——创建 IWindow Session

// frameworks/base/core/java/android/view/ViewRootImpl.java
public void setView(View view, WindowManager.LayoutParams attrs,
        View panelParentView) {
    synchronized (this) {
        if (mView == null) {
            mView = view;
            // 获取 WindowSession（Binder 代理）
            mWindowSession = WindowManagerGlobal.getWindowSession();
            // 添加自身到 WMS
            int res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
                    getHostVisibility(), mDisplay.getDisplayId(), mWinFrame,
                    mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,
                    mAttachInfo.mOutsets, mAttachInfo.mDisplayCutout, mInputChannel,
                    mTempInsets);
            // 创建 InputChannel 接收输入事件
            if (mInputChannel != null) {
                mInputEventReceiver = new WindowInputEventReceiver(mInputChannel,
                        Looper.myLooper());
            }
        }
    }
}

4.3 WMS 端：Session.addToDisplay → WMS.addWindow

Session 是每个应用进程在 WMS 端的代理（代表），继承自 IWindowSession.Stub：

// frameworks/base/services/core/java/com/android/server/wm/Session.java
class Session extends IWindowSession.Stub implements IBinder.DeathRecipient {
    final WindowManagerService mService;

    @Override
    public int addToDisplay(IWindow window, int seq, WindowManager.LayoutParams attrs,
            int viewVisibility, int displayId, Rect outFrame, Rect outContentInsets,
            Rect outStableInsets, Rect outOutsets,
            DisplayCutout.ParcelableWrapper outDisplayCutout, InputChannel outInputChannel,
            InsetsState outInsetsState) {
        // 调用 WMS.addWindow
        return mService.addWindow(this, window, seq, attrs, viewVisibility, displayId,
                outFrame, outContentInsets, outStableInsets, outOutsets,
                outDisplayCutout, outInputChannel, outInsetsState);
    }
}

4.4 WMS.addWindow——核心逻辑

// frameworks/base/services/core/java/com/android/server/wm/WindowManagerService.java
public int addWindow(Session session, IWindow client, int seq,
        LayoutParams attrs, int viewVisibility, int displayId, Rect outFrame,
        Rect outContentInsets, Rect outStableInsets, Rect outOutsets,
        DisplayCutout.ParcelableWrapper outDisplayCutout, InputChannel outInputChannel,
        InsetsState outInsetsState) {

    // 1. 权限检查：INTERNAL_SYSTEM_WINDOW 等
    int res = mPolicy.checkAddPermission(attrs, session.mUid);

    // 2. 获取对应的 DisplayContent
    final DisplayContent displayContent = mRoot.getDisplayContentOrCreate(displayId);

    // 3. 根据窗口类型获取或创建 WindowToken
    WindowToken token = displayContent.getWindowToken(
            hasParent ? parentWindow.mAttrs.token : attrs.token);
    if (token == null) {
        // 创建新的 WindowToken（如新 Activity 的窗口令牌）
        token = new WindowToken(this, binder, type, false, displayContent,
                session.mCanAddInternalSystemWindow);
    }

    // 4. 创建 WindowState
    final WindowState win = new WindowState(this, session, client, token,
            parentWindow, appOp[0], seq, attrs, viewVisibility, session.mUid,
            session.mCanAddInternalSystemWindow);

    // 5. 调整窗口参数（通过 Policy 检查）
    mPolicy.adjustWindowParamsLw(win, win.mAttrs);

    // 6. 将 WindowState 添加到合适的父容器中
    win.attach();
    // 这会将 WindowState 插入容器层级树的正确位置

    // 7. 如果这是应用窗口的第一个子窗口，创建 InputChannel
    if (type == TYPE_INPUT_METHOD || type == TYPE_INPUT_METHOD_DIALOG) {
        displayContent.computeImeTarget(true);
    }

    // 8. 安排窗口绘制
    win.openInputChannel(outInputChannel);
    win.setHasSurface(true);

    // 9. 分配 Surface
    mWindowPlacerLocked.performSurfacePlacement();

    return res;
}

4.5 WindowState.attach——插入容器树

// frameworks/base/services/core/java/com/android/server/wm/WindowState.java
void attach() {
    if (localLOGV) Slog.v(TAG, "Attaching " + this + " token=" + mToken);
    mSession.windowAddedLocked(mAttrs.packageName);

    if (mAttrs.type >= FIRST_APPLICATION_WINDOW
            && mAttrs.type <= LAST_APPLICATION_WINDOW) {
        // 应用窗口：添加到 ActivityRecord（即 AppWindowToken）下
        mActivityRecord.addWindow(this);
    } else if (mAttrs.type == TYPE_INPUT_METHOD
            || mAttrs.type == TYPE_INPUT_METHOD_DIALOG) {
        // IME 窗口：添加到 DisplayContent 的 IME 容器
        mDisplayContent.addImeWindow(this);
    } else {
        // 系统窗口（状态栏等）
        mDisplayContent.addSystemWindow(this);
    }
}

五、Z-Order 管理与层级排序

WMS 使用 Z-Order 来确定窗口的绘制顺序和输入事件分发顺序。

5.1 层级计算

// frameworks/base/services/core/java/com/android/server/wm/WindowState.java
// 每个窗口有一个基础层级和子层级
static final int TYPE_LAYER_MULTIPLIER = 10000;
static final int TYPE_LAYER_OFFSET = 1000;

// 计算 Z-Order 值
int getBaseTypeLayer() {
    // 根据窗口类型计算基础层级
    // TYPE_BASE_APPLICATION: 1 * TYPE_LAYER_MULTIPLIER = 10000
    // TYPE_INPUT_METHOD:     5 * TYPE_LAYER_MULTIPLIER = 50000
    // TYPE_STATUS_BAR:       6 * TYPE_LAYER_MULTIPLIER = 60000
    // TYPE_KEYGUARD_DIALOG: 10 * TYPE_LAYER_MULTIPLIER = 100000
}

5.2 子层级排序

在同一个 WindowToken（如同一 Activity）内部，子窗口有子层级：

static final int APPLICATION_MEDIA_SUBLAYER = -2;   // 媒体层
static final int APPLICATION_MEDIA_OVERLAY_SUBLAYER = -1; // 媒体覆盖层
static final int APPLICATION_PANEL_SUBLAYER = 1;     // 面板层
static final int APPLICATION_SUB_PANEL_SUBLAYER = 2; // 子面板层
static final int APPLICATION_ABOVE_SUB_PANEL_SUBLAYER = 3; // 面板上层

5.3 全局 Z-Order 排序

WMS 通过 WindowContainer.assignChildOrder 和 WindowContainer.compareTo 实现容器的全局排序。排序规则：

先比较基础层（type layer）
再比较子层（sub layer）
最后按添加时间排序（同层级时后添加的在上层）

六、窗口焦点与 Input 焦点

6.1 窗口焦点（Window Focus）

窗口焦点决定了哪个窗口可以接收按键事件。焦点窗口由 WMS 的 mCurrentFocus 字段追踪。

// frameworks/base/services/core/java/com/android/server/wm/DisplayContent.java
boolean updateFocusedWindowLocked(int mode, boolean updateInputWindows) {
    // 找到当前应该获取焦点的窗口
    WindowState newFocus = findFocusedWindowIfNeeded(mode);

    if (mCurrentFocus != newFocus) {
        // 通知旧窗口失去焦点
        if (mCurrentFocus != null) {
            mCurrentFocus.reportFocusChanged(false);
        }
        // 通知新窗口获得焦点
        if (newFocus != null) {
            newFocus.reportFocusChanged(true);
        }
        mCurrentFocus = newFocus;
    }
    return true;
}

6.2 Input 焦点

Input 焦点是通过 InputDispatcher 分发的触摸/按键事件的窗口。WMS 向 InputManagerService 提供窗口信息，由 InputDispatcher 在 native 层进行实际的分发决策。关键方法：

// frameworks/base/services/core/java/com/android/server/wm/InputMonitor.java
void updateInputWindowsLw(boolean force) {
    // 收集所有可接收输入的窗口
    mUpdateInputForAllWindowsConsumer.updateInputWindows(inDrag);
    // 将窗口列表发送给 InputDispatcher
    mInputManagerService.setInputWindows(
            mUpdateInputForAllWindowsConsumer.getInputWindowHandles(),
            mDisplayId);
}

七、SurfaceControl 与 SurfaceFlinger 的交互

7.1 SurfaceControl 的创建

每个 WindowState 在显示前需要分配一个 Surface，这是通过 SurfaceControl 实现的。SurfaceControl 是 Java 层对 native Surface 的封装：

// frameworks/base/core/java/android/view/SurfaceControl.java
public SurfaceControl(SurfaceSession session, String name, int w, int h,
        int format, int flags, SurfaceControl parent, SparseIntArray metadata) {
    // 调用 native 方法创建 Surface
    mNativeObject = nativeCreate(session, name, w, h, format, flags,
            parent != null ? parent.mNativeObject : 0, metadata);
}

7.2 WindowSurfaceController——窗口的 Surface 管理

// frameworks/base/services/core/java/com/android/server/wm/WindowSurfaceController.java
class WindowSurfaceController {
    SurfaceControl mSurfaceControl;
    final WindowStateAnimator mAnimator;

    void createSurfaceControl() {
        // 为窗口创建 SurfaceControl
        mSurfaceControl = mAnimator.createSurfaceLocked(
                mAnimator.mWin.mAttrs.type, mAnimator.mWin.getOwningUid());
    }

    void setPositionAndLayer(float x, float y, int layer) {
        // 设置位置和层级
        if (mSurfaceControl != null) {
            mSurfaceControl.setPosition(x, y);
            mSurfaceControl.setLayer(layer);
        }
    }
}

7.3 SurfaceFlinger 合成流程

WMS 不直接渲染任何内容，它只管理 Surface 的布局和属性。实际的合成工作由 SurfaceFlinger 在 native 层完成：

WMS 通过 WindowSurfacePlacer.performSurfacePlacement() 遍历所有窗口，计算每个窗口的 frame、layer 和可见性。
调用 SurfaceControl.setPosition/setLayer/setMatrix/setCrop 等方法更新 native 层属性。
SurfaceFlinger 在下一个 vsync 周期读取所有 Surface 的属性并进行合成。
合成结果通过 Hardware Composer（HWC）或 GPU（GLES）交给显示驱动。

AOSP SurfaceFlinger 路径：frameworks/native/services/surfaceflinger/

八、IME 窗口管理

IME（输入法）窗口是一种特殊窗口，WMS 对其有专门的管理逻辑。

// frameworks/base/services/core/java/com/android/server/wm/DisplayContent.java
WindowState mInputMethodWindow;    // 当前 IME 窗口
WindowState mInputMethodTarget;    // IME 的输入目标窗口（正在输入的窗口）

void computeImeTarget(boolean updateImeTarget) {
    // 找到当前应该接收 IME 输入的目标窗口
    mInputMethodTarget = findImeInputTarget();

    if (mInputMethodTarget != null) {
        // 调整 IME 窗口位置，使其在目标窗口下方
        mInputMethodWindow.adjustForImeIfNeeded(mInputMethodTarget);
    }
}

九、屏幕旋转处理

当设备旋转时，WMS 通过 DisplayRotation 和 WindowManagerPolicy 协作处理。

// frameworks/base/services/core/java/com/android/server/wm/DisplayRotation.java
boolean updateRotationUnchecked(boolean alwaysSendConfiguration) {
    // 从 WindowManagerPolicy（PhoneWindowManager）获取推荐的旋转方向
    final int rotation = mPolicy.rotationForOrientationLw(
            mService.getLastOrientation(), mRotation);
    if (rotation != mRotation) {
        // 执行旋转
        mRotation = rotation;
        // 更新所有窗口的 Surface 旋转属性
        mDisplayContent.updateRotationUnchecked();
    }
    return changed;
}

旋转涉及的关键步骤：

传感器检测到设备方向变化，报告给 WindowOrientationListener。
PhoneWindowManager.rotationForOrientationLw() 决定目标旋转角度。
WMS 更新 DisplayContent 的旋转信息。
通过 WMS → AMS → ActivityThread 通知 App 进程 Configuration 改变。
Activity 选择处理 onConfigurationChanged（声明了 configChanges）或重建自身。
SurfaceFlinger 在合成时应用旋转矩阵到 Display 输出。

十、核心面试题

Q1：ViewRootImpl、Window、WindowManager、WMS 之间的关系是什么？

每个 Activity 对应一个 PhoneWindow（Window 的唯一实现类），它作为顶层视图树的容器。当调用 WindowManager.addView(decorView) 时，会创建一个 ViewRootImpl 对象。ViewRootImpl 持有 IWindowSession（即 Session 的 Binder 代理），通过它向 WMS 发起 addWindow 请求。WMS 端创建对应的 WindowState 并分配 Surface。ViewRootImpl 是 App 端视图树和 WMS 之间的桥梁，它同时也是 View 绘制的入口（performTraversals）。

Q2：Dialog 的窗口和 Activity 的窗口在 WMS 中如何组织？

Dialog 窗口是 Activity 窗口的子窗口（sub-window）。在 WindowManager.LayoutParams 中，Dialog 的 token 被设置为宿主 Activity 的 Window token。WMS 在添加 Dialog 窗口时，根据 token 找到父窗口，将 Dialog 的 WindowState 作为父窗口的子窗口管理，因此 Dialog 有更高的 sub-layer，总是显示在 Activity 之上。Dialog 关闭时不会触发 Activity 的生命周期变化，因为 WMS 只是移除了一个子窗口。

Q3：WMS 是如何与 InputManagerService 交互来完成事件分发的？

WMS 通过 InputMonitor.updateInputWindowsLw() 收集所有当前可接收输入的窗口，并传递给 InputManagerService。IMS 将这些窗口信息发送到 native 层的 InputDispatcher。InputDispatcher 收到触摸事件后，根据窗口的 Z-Order（从高到低）和触摸坐标找到目标窗口，然后通过 InputChannel（每个窗口特有的 Unix Domain Socket 对）将事件发送到对应的 App 进程。

Q4：为什么 Android 需要 WMS 管理窗口，而不是像传统 Linux GUI 那样由 X11/Wayland 管理？

Android 选择了自主的窗口系统，原因包括：(1) 移动设备的资源受限性，需要轻量级的窗口管理，传统 X11 协议过于复杂和重量级；(2) 需要与 Android 的 Activity 生命周期深度绑定——Activity 的暂停/恢复必须与窗口的显示/隐藏同步；(3) 安全性——每个应用窗口的 Surface 是隔离的，配合 Binder 权限检查可以防止恶意应用截取其他应用的渲染内容；(4) 统一的动画系统——WMS 与 Choreographer 协作，确保所有窗口动画与 vsync 对齐。

AOSP 核心路径参考：

frameworks/base/services/core/java/com/android/server/wm/WindowManagerService.java
frameworks/base/services/core/java/com/android/server/wm/WindowContainer.java
frameworks/base/services/core/java/com/android/server/wm/WindowState.java
frameworks/base/services/core/java/com/android/server/wm/WindowToken.java
frameworks/base/services/core/java/com/android/server/wm/RootWindowContainer.java
frameworks/base/services/core/java/com/android/server/wm/DisplayContent.java
frameworks/base/services/core/java/com/android/server/wm/DisplayArea.java
frameworks/base/services/core/java/com/android/server/wm/Session.java
frameworks/base/services/core/java/com/android/server/wm/InputMonitor.java
frameworks/base/core/java/android/view/ViewRootImpl.java
frameworks/base/core/java/android/view/WindowManagerGlobal.java
frameworks/base/core/java/android/view/SurfaceControl.java
frameworks/native/services/surfaceflinger/