• Z-ordered的维护函数

• 输入法管理

• AddWindow/RemoveWindow

• Layerout

• Token管理，AppToken

• 活动窗口管理（FocusWindow）

• 活动应用管理（FocusApp）

• 转场动画

• 系统消息收集线程

• 系统消息分发线程

• 用于描述多屏输出相关信息；

• 根据窗口的显示位置将其分组。隶属于同一个DisplayContent的窗口将会被显示在同一个屏幕中。每个DisplayContent都对应着唯一ID，在添加窗口的时候可以通过指定这个ID决定其将显示在哪个屏幕中；

• DisplayContent是一个非常具有隔离性的一个概念。处于不同DisplayContent的两个窗口在布局、显示顺序以及动画处理上不会产生任何耦合；

• 窗口Token，用来做Binder通信；同时也是一种标识；

• 在进行窗口Zorder排序时，属于同一个WindowToken的窗口会被安排在一起，而且在其中定义的一些属性将会影响所有属于此WindowToken的窗口，这些都表明了属于同一个WindowToken的窗口之间的紧密联系；

• 应用组件在需要新的窗口时，必须提供WindowToken以表明自己的身份，并且窗口的类型必须与所持有的WindowToken的类型一致；

• 在创建系统类型的窗口时不需要提供一个有效的Token，WMS会隐式地为其声明一个WindowToken，看起来谁都可以添加个系统级的窗口。难道Android为了内部使用方便而置安全于不顾吗？非也，addWindow()函数一开始的mPolicy.checkAddPermission()的目的就是如此。它要求客户端必须拥有SYSTEM_ALERT_WINDOW或INTERNAL_SYSTEM_WINDOW权限才能创建系；

   private void startOtherServices() {        ...        try {            ...            // 创建WMS对象            // 创建WMS对象需要依赖于InputManager、PhoneWindowManager、和AMS            // IMS是用来管理每个窗口的输入事件通道以及向通道上派发事件            // PhoneWindowManager是实现了窗口的各种策略，定义了窗口相关策略            // 比如：告诉WMS某一个类型Window的Z-Order的值是多少，帮助WMS矫正不合理的窗口属性，            // 为WMS监听屏幕旋转的状态，预处理一些系统按键事件（例如HOME、BACK键等的默认行为就是在这里实现的）等            wm = WindowManagerService.main(context, inputManager, !mFirstBoot, mOnlyCore,                    new PhoneWindowManager(), mActivityManagerService.mActivityTaskManager);            ServiceManager.addService(Context.WINDOW_SERVICE, wm, /* allowIsolated= */ false,                    DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PROTO);            ServiceManager.addService(Context.INPUT_SERVICE, inputManager,                    /* allowIsolated= */ false, DUMP_FLAG_PRIORITY_CRITICAL);            traceEnd();            traceBeginAndSlog("SetWindowManagerService");            // 将AMS与WMS做绑定            mActivityManagerService.setWindowManager(wm);            traceEnd();            traceBeginAndSlog("WindowManagerServiceOnInitReady");            // 这里主要是调用initPolicy用来初始化PhoneWindowManager            wm.onInitReady();            traceEnd();            ...        }        ...        traceBeginAndSlog("MakeDisplayReady");        try {            // 主要是初始化UI尺寸            wm.displayReady();        } catch (Throwable e) {            reportWtf("making display ready", e);        }        traceEnd();        ...        traceBeginAndSlog("MakeWindowManagerServiceReady");        try {            // 准备工作已经完成            wm.systemReady();        } catch (Throwable e) {            reportWtf("making Window Manager Service ready", e);        }        traceEnd();        ...    }

• WMS的main方法：是运行在SystemServer进程的主线程，但是WMS的初始化是在DisplayThread线程构建的；

• DisplayThread其实就是一个HandlerThread；

• Handler中有一个runWithScissors方法：这个方法其实就是Handler.post消息执行之后能够再继续往下执行；

• 即runWithScissors后面的内容，需要等待消息的处理完成之后才会继续执行。其实就是实现一个同步执行的过程；

• DisplayThread其实是android.display线程，这是系统共享的单例前台线程，在该线程内部创建了WMS；

   public static WindowManagerService main(final Context context, final InputManagerService im,            final boolean showBootMsgs, final boolean onlyCore, WindowManagerPolicy policy,            ActivityTaskManagerService atm) {        return main(context, im, showBootMsgs, onlyCore, policy, atm,                SurfaceControl.Transaction::new);    }

• WMS的main方法是在SystemServer进程的主线程调用的，然后在调用WMS的main方法的时候，通过DisplayThread这个HandlerThread，实现异步处理；

• 这里的异步处理，其实是通过跨线程的一个同步，即通过DisplayThread中的Handler对象，调用runWithScissors方法；

• 该方法其实是可以实现发送消息等待消息处理完成以后再继续执行runWithScissors方法调用位置之后的代码，即等待消息处理完之后再进行return WMS对象的返回操作； 

 @VisibleForTesting    public static WindowManagerService main(final Context context, final InputManagerService im,            final boolean showBootMsgs, final boolean onlyCore, WindowManagerPolicy policy,            ActivityTaskManagerService atm, TransactionFactory transactionFactory) {        // wms是运行在android.display线程        DisplayThread.getHandler().runWithScissors(() ->                sInstance = new WindowManagerService(context, im, showBootMsgs, onlyCore, policy,                        atm, transactionFactory), 0);        return sInstance;    }

sInstance = new WindowManagerService(context, im, showBootMsgs, onlyCore, policy,atm, transactionFactory), 0);public final boolean runWithScissors(@NonNull Runnable r, long timeout) {    if (r == null) {        throw new IllegalArgumentException("runnable must not be null");    }    if (timeout < 0) {        throw new IllegalArgumentException("timeout must be non-negative");    }    // 如果调用runWithScissors方法的线程是与消息处理线程在同一个线程    // 则直接执行Runnable的run方法。    if (Looper.myLooper() == mLooper) {        r.run();        return true;    }    // 如果调用runWithScissors方法的线程与消息处理线程不是同一个，则创建一个BlockingRunnable    BlockingRunnable br = new BlockingRunnable(r);    return br.postAndWait(this, timeout);}

• 则创建一个BlockingRunnable；

• 调用BlockingRunnable.postAndWait方法；

• 这里的返回值会先等待，等待DisplayThread线程中的Handler处理完；

• 消息之后，然后唤醒BlockingRunnable；

• 该Handler处理消息是在DisplayThread线程，而BlockingRunnable；

• 而BlockingRunnable调用wait并不会让DisplayThread线程中的；

• Handler等待，Handler依然会处理消息，处理消息其实就是调用了；

•  BlockingRunnable.run()方法，当BlockingRunnable.run()执行完成；

• 就会调用notifyAll唤醒BlockingRunnable，执行postAndWait的return；

private static final class BlockingRunnable implements Runnable {    private final Runnable mTask;    private boolean mDone;    public BlockingRunnable(Runnable task) {        mTask = task;    }    @Override    public void run() {        try {            mTask.run();        } finally {            synchronized (this) {                mDone = true;                notifyAll();            }        }    }    public boolean postAndWait(Handler handler, long timeout) {        // 调用postAndWait的时候，先调用handler对象的post将消息发送出        // 如果入队成功，则为true，则开始阻塞        if (!handler.post(this)) {            return false;        }        // 在上面的方法调用中，timeout=0，则阻塞。        synchronized (this) {            if (timeout > 0) {                final long expirationTime = SystemClock.uptimeMillis() + timeout;                // 如果mDone为false的时候，则会等待，只有为true的时候，会执行                while (!mDone) {                    long delay = expirationTime - SystemClock.uptimeMillis();                    if (delay <= 0) {                        return false; // timeout                    }                    try {                        wait(delay);                    } catch (InterruptedException ex) {                    }                }            } else {                while (!mDone) {                    try {                        wait();                    } catch (InterruptedException ex) {                    }                }            }        }        return true;    }}

• mTask其实就是runWithScissors中传入的Runnable对象；

• BlockingRunnable的run方法的执行，其实就是需要Handler遍历到消息处理的时候；

• 然后处理这个BlockingRunnable消息，在处理BlockingRunnable消息的时候；

• 就会处理runWithScissors的参数中的Runnable这个mTask；

• 处理完成之后，就会调用notifyAll唤醒等待线程，然后执行postAndWait的return；

• 因为BlockingRunnable的run方法是由Handler处理消息；

• 这个消息的处理与BlockingRunnable是在不同的线程；

• 所以BlockingRunnable等待的时候，其run方法是可以由handler消息处理；

   private WindowManagerService(Context context, InputManagerService inputManager,        boolean showBootMsgs, boolean onlyCore, WindowManagerPolicy policy,        ActivityTaskManagerService atm, TransactionFactory transactionFactory) {    installLock(this, INDEX_WINDOW);    mGlobalLock = atm.getGlobalLock();    mAtmService = atm;    mContext = context;    mAllowBootMessages = showBootMsgs;    mOnlyCore = onlyCore;    // 各种变量读取    mLimitedAlphaCompositing = context.getResources().getBoolean(            com.android.internal.R.bool.config_sf_limitedAlpha);    mHasPermanentDpad = context.getResources().getBoolean(            com.android.internal.R.bool.config_hasPermanentDpad);    mInTouchMode = context.getResources().getBoolean(            com.android.internal.R.bool.config_defaultInTouchMode);    ......    mInputManager = inputManager;    mDisplayManagerInternal =        LocalServices.getService(DisplayManagerInternal.class);    // Display设置    mDisplayWindowSettings = new DisplayWindowSettings(this);    mTransactionFactory = transactionFactory;    mTransaction = mTransactionFactory.make();    //PhoneWindowManager(继承于WindowManagerPolicy, 用来提供UI相关的一些行为)    mPolicy = policy;    // 在一个单独的task中执行动画和Surface操作的类    mAnimator = new WindowAnimator(this);    // 根Window容器    mRoot = new RootWindowContainer(this);    // 用来确定Window和Surface的位置    mWindowPlacerLocked = new WindowSurfacePlacer(this);    // 任务快照管理器(当App不可见时, 会将Task的快照以Bitmap形式存在缓存中)    mTaskSnapshotController = new TaskSnapshotController(this);    LocalServices.addService(WindowManagerPolicy.class, mPolicy);    mDisplayManager =     (DisplayManager)context.getSystemService(Context.DISPLAY_SERVICE);    // Keyguard处理器    mKeyguardDisableHandler =        KeyguardDisableHandler.create(mContext, mPolicy, mH);    // PowerManager是控制设备电池状态的管理器    mPowerManager =         (PowerManager)context.getSystemService(Context.POWER_SERVICE);    // PowerManagerInternal是PowerMananger的本地服务    mPowerManagerInternal =        LocalServices.getService(PowerManagerInternal.class);    if (mPowerManagerInternal != null) {        mPowerManagerInternal.registerLowPowerModeObserver(                new PowerManagerInternal.LowPowerModeListener() {            @Override            public int getServiceType() {                return ServiceType.ANIMATION;            }            @Override            public void onLowPowerModeChanged(PowerSaveState result) {                synchronized (mGlobalLock) {                    // 低电量模式发生变化时, 需要调整对应的动画                    final boolean enabled = result.batterySaverEnabled;if (mAnimationsDisabled != enabled && !mAllowAnimationsInLowPowerMode) {                        mAnimationsDisabled = enabled;                        dispatchNewAnimatorScaleLocked(null);                    }                }            }        });        // 获取是否允许动画        mAnimationsDisabled =            mPowerManagerInternal.getLowPowerState(            ServiceType.ANIMATION).batterySaverEnabled;    }    mScreenFrozenLock =    mPowerManager.newWakeLock(        PowerManager.PARTIAL_WAKE_LOCK, "SCREEN_FROZEN");    mScreenFrozenLock.setReferenceCounted(false);    // 获取IActivity.Stub.Proxy(new BinderProxy())    mActivityManager = ActivityManager.getService();    // 获取IActivityTaskManager.Stub.Proxy    mActivityTaskManager = ActivityTaskManager.getService();    // ActivityManagerInternal是ActivityManager的本地服务    mAmInternal =        LocalServices.getService(ActivityManagerInternal.class);    // ActivityTaskManagerInternal是ActivityTaskManager的本地服务    mAtmInternal =        LocalServices.getService(ActivityTaskManagerInternal.class);    mAppOps =     (AppOpsManager)context.getSystemService(Context.APP_OPS_SERVICE);    AppOpsManager.OnOpChangedInternalListener opListener =            new AppOpsManager.OnOpChangedInternalListener() {                @Override                 public void onOpChanged(int op, String packageName) {                    updateAppOpsState();                }            };    mAppOps.startWatchingMode(OP_SYSTEM_ALERT_WINDOW, null, opListener);    mAppOps.startWatchingMode(AppOpsManager.OP_TOAST_WINDOW,        null, opListener);    // PackageManagerInternal是PackageManager的本地服务    mPmInternal = LocalServices.getService(PackageManagerInternal.class);    // 注册Package suspend/unsuspend广播    final IntentFilter suspendPackagesFilter = new IntentFilter();    suspendPackagesFilter.addAction(Intent.ACTION_PACKAGES_SUSPENDED);    suspendPackagesFilter.addAction(Intent.ACTION_PACKAGES_UNSUSPENDED);    context.registerReceiverAsUser(new BroadcastReceiver() {        @Override        public void onReceive(Context context, Intent intent) {            final String[] affectedPackages =            intent.getStringArrayExtra(Intent.EXTRA_CHANGED_PACKAGE_LIST);            final boolean suspended =            Intent.ACTION_PACKAGES_SUSPENDED.equals(intent.getAction());            updateHiddenWhileSuspendedState(            new ArraySet<>(Arrays.asList(affectedPackages)), suspended);        }    }, UserHandle.ALL, suspendPackagesFilter, null, null);    // 获取并设置window scale设置    final ContentResolver resolver = context.getContentResolver();    mWindowAnimationScaleSetting = Settings.Global.getFloat(resolver,Settings.Global.WINDOW_ANIMATION_SCALE, mWindowAnimationScaleSetting);    ......    // 注册广播, 当DevicePolicyManager状态发生变化时设置keyguard属性是否可用    IntentFilter filter = new IntentFilter();    filter.addAction(ACTION_DEVICE_POLICY_MANAGER_STATE_CHANGED);    mContext.registerReceiverAsUser(mBroadcastReceiver,        UserHandle.ALL, filter, null, null);    mLatencyTracker = LatencyTracker.getInstance(context);    mSettingsObserver = new SettingsObserver();     ......     mSurfaceAnimationRunner = new SurfaceAnimationRunner(mPowerManagerInternal);    mAllowTheaterModeWakeFromLayout = context.getResources().getBoolean(com.android.internal.R.bool.config_allowTheaterModeWakeFromWindowLayout);    // Task定位控制器    mTaskPositioningController = new TaskPositioningController(this,        mInputManager, mActivityTaskManager, mH.getLooper());    // View的拖/拉操作控制器    mDragDropController = new DragDropController(this, mH.getLooper());     ......    // 注册WindowManager的本地服务WindowManagerInternal    LocalServices.addService(WindowManagerInternal.class, new LocalService());}

•  LocalServices与ServiceManager类似，但是LocalServices只能是在同一个进程中使用；

• 并且LocalServices中注册的并不是一个Binder对象，注册进的都是对应的Service的静态内部类；

• 也就是LocalService，比如WMS有一个WindowManagerInternal，LocalService就是其子类实现；

public void onInitReady() {    // 初始化PhoneWindowManager    initPolicy();    // 添加Watchdog monitor    Watchdog.getInstance().addMonitor(this);     // 调用SurfaceControl.openTransaction(), 启动一个事务    openSurfaceTransaction();    // 创建水印    createWatermarkInTransaction();    // 结束事务closeSurfaceTransaction("createWatermarkInTransaction");     // 显示模拟器显示层    showEmulatorDisplayOverlayIfNeeded();}

private void initPolicy() {        UiThread.getHandler().runWithScissors(new Runnable() {            @Override            public void run() {                WindowManagerPolicyThread.set(Thread.currentThread(),                    Looper.myLooper());                mPolicy.init(mContext, WindowManagerService.this,                    WindowManagerService.this);            }        }, 0);    }

public void displayReady() {    synchronized (mGlobalLock) {        // 设置RootWindowContainer的Window列表的最大宽度        if (mMaxUiWidth > 0) {            mRoot.forAllDisplays(            displayContent -> displayContent.setMaxUiWidth(mMaxUiWidth));        }        final boolean changed = applyForcedPropertiesForDefaultDisplay();        mAnimator.ready();        mDisplayReady = true;        if (changed) {            // 重新配置DiaplayContent属性            reconfigureDisplayLocked(getDefaultDisplayContentLocked());        }        mIsTouchDevice = mContext.getPackageManager().hasSystemFeature(        PackageManager.FEATURE_TOUCHSCREEN);    }    // 1.修改当前configuration 2.确保当前Activity正在运行当前configuration    mActivityTaskManager.updateConfiguration(null);    // 更新CircularDisplayMask    updateCircularDisplayMaskIfNeeded();}

public void systemReady() {    mSystemReady = true;    mPolicy.systemReady();    mRoot.forAllDisplayPolicies(DisplayPolicy::systemReady);    mTaskSnapshotController.systemReady();    // 是否支持色域    mHasWideColorGamutSupport = queryWideColorGamutSupport();    // 是否支持HDR渲染    mHasHdrSupport = queryHdrSupport();    UiThread.getHandler().post(mSettingsObserver::updateSystemUiSettings);    UiThread.getHandler().post(mSettingsObserver::updatePointerLocation);    // 获取IVrManager.Stub.Proxy, 并注册状态变化listener    IVrManager vrManager = IVrManager.Stub.asInterface(            ServiceManager.getService(Context.VR_SERVICE));    if (vrManager != null) {        final boolean vrModeEnabled = vrManager.getVrModeState();        synchronized (mGlobalLock) {            vrManager.registerListener(mVrStateCallbacks);            if (vrModeEnabled) {                mVrModeEnabled = vrModeEnabled;                mVrStateCallbacks.onVrStateChanged(vrModeEnabled);            }        }    }}

• 整个启动过程涉及3个线程: system_server主线程, “android.display”, “android.ui”；

•  整个过程是采用阻塞方式(利用Handler.runWithScissors)执行的；

•  其中WindowManagerService.mH的Looper运行在 “android.display”进程，也就意味着WMS.H.handleMessage()在该线程执行；

• WMS 主要用于窗口的添加和移除操作，其对应的方法是 addWindow 和 removeWindow，关于窗口的添加和删除过程