fwrite

// SystemServer.java

    private void run() {

        ... 省略部分

        // Start services.
        try {
            t.traceBegin("StartServices");
            startBootstrapServices(t);
            startCoreServices(t);

            // WMS 是在 OtherServices 启动
            startOtherServices(t);
        } catch (Throwable ex) {

            ... 省略 Log

            throw ex;
        } /* 省略 finally */

    }

    private void startOtherServices(@NonNull TimingsTraceAndSlog t) {

        ... 省略部分

        try {
            t.traceBegin("StartWindowManagerService");
            // WMS needs sensor service ready
            mSystemServiceManager.startBootPhase(t, SystemService.PHASE_WAIT_FOR_SENSOR_SERVICE);

            // 1. 启动 WMS
            wm = WindowManagerService.main(context, inputManager, !mFirstBoot, mOnlyCore,
                    new PhoneWindowManager(), mActivityManagerService.mActivityTaskManager);

            // 2. 对 ServiceManager 添加服务 "window"
            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);
            t.traceEnd();

               // 3. 与 AMS 产生关系
             t.traceBegin("SetWindowManagerService");
             mActivityManagerService.setWindowManager(wm);
             t.traceEnd();

           } /* 省略 catch */

       }

// SystemServer.java

    private void startOtherServices(@NonNull TimingsTraceAndSlog t) {
    
        ... 省略部分
        
        try {

            // 初始化准备
            wm.onInitReady();
            
            ... 省略部分
                
            try {
                wm.displayReady();
            } catch (Throwable e) {
                reportWtf("making display ready", e);
            }
                
            wm.systemReady();
        } /* 省略 catch */
    }  

// WindowManagerService.java

 public static WindowManagerService main(final Context context, final InputManagerService im,
        final boolean showBootMsgs, final boolean onlyCore, WindowManagerPolicy policy,
        ActivityTaskManagerService atm) {

    // @ 查看 main 方法
    return main(context, im, showBootMsgs, onlyCore, policy, atm,
            new DisplayWindowSettingsProvider(), SurfaceControl.Transaction::new, Surface::new,
            SurfaceControl.Builder::new);
}


  @VisibleForTesting
  public static WindowManagerService main(final Context context, final InputManagerService im,
          final boolean showBootMsgs, final boolean onlyCore, WindowManagerPolicy policy,
          ActivityTaskManagerService atm, ... 省略部分參數) {

      // 创建新 Thread
      DisplayThread.getHandler().runWithScissors(() ->
              sInstance = new WindowManagerService(context, im, showBootMsgs, onlyCore, policy,
                      atm, displayWindowSettingsProvider, transactionFactory, surfaceFactory,
                      surfaceControlFactory), 0);
      // 执行完 runWithScissors 中的 Runnable 任务后才返回
      return sInstance;
  }

// HandlerThread.java

public class HandlerThread extends Thread {
    
    ... 省略部分方法
    
    @Override
    public void run() {
        mTid = Process.myTid();
        
        // 准备该 Thread 专用的 Looper & MessageQueue 对象
        Looper.prepare();
        synchronized (this) {
            mLooper = Looper.myLooper();
            
            // 通知所有等待的 Thread，Looper 已经创建完成
            notifyAll();
        }
        Process.setThreadPriority(mPriority);
        
        // Looper 准备好
        onLooperPrepared();
        // 准备开始运行 Loop 不断循环处理 Message 任务
        Looper.loop();
        
        mTid = -1;
    }
    
    public Looper getLooper() {
        if (!isAlive()) {
            return null;
        }
        
        // If the thread has been started, wait until the looper has been created.
        synchronized (this) {    // 以当前对象作为锁
            while (isAlive() && mLooper == null) {
                try {
                    wait();    // 直到 Looper 创建
                } catch (InterruptedException e) {
                }
            }
        }
        return mLooper;
    }
    
    
    // 在需要时才创建（但线程不安全）
    public Handler getThreadHandler() {
        if (mHandler == null) {
            mHandler = new Handler(getLooper());
        }
        return mHandler;
    }
}

// DisplayThread.java

public final class DisplayThread extends ServiceThread {
    private static DisplayThread sInstance;
    private static Handler sHandler;

    // 單例模式
    private DisplayThread() {
        // DisplayThread runs important stuff, but these are not as important as things running in
        // AnimationThread. Thus, set the priority to one lower.
        super("android.display", Process.THREAD_PRIORITY_DISPLAY + 1, false /*allowIo*/);
    }

    private static void ensureThreadLocked() {
        if (sInstance == null) {
            sInstance = new DisplayThread();
            sInstance.start();
            sInstance.getLooper().setTraceTag(Trace.TRACE_TAG_SYSTEM_SERVER);
            sHandler = new Handler(sInstance.getLooper());
        }
    }

    public static DisplayThread get() {
        // 类锁
        synchronized (DisplayThread.class) {
            // 创建 DisplayThread 对象
            ensureThreadLocked();
            return sInstance;
        }
    }

    // 透过 DisplayThread.class 类锁来达成安全创建
    public static Handler getHandler() {
        // 类锁
        synchronized (DisplayThread.class) {
            // 创建 DisplayThread 对象
            ensureThreadLocked();
            return sHandler;
        }
    }
}

// WindowManagerService.java

    @Override
    public boolean isKeyguardLocked() {
        // mPolicy 类型 WindowManagerPolicy 
        return mPolicy.isKeyguardLocked();
    }

// WindowManagerService.java

    final H mH = new H();

    final class H extends android.os.Handler {
        ...
    }

    @Override
    public void setAnimationScale(int which, float scale) {
        if (!checkCallingPermission(android.Manifest.permission.SET_ANIMATION_SCALE,
                "setAnimationScale()")) {
            throw new SecurityException("Requires SET_ANIMATION_SCALE permission");
        }

        scale = fixScale(scale);
        switch (which) {
            case 0: mWindowAnimationScaleSetting = scale; break;
            case 1: mTransitionAnimationScaleSetting = scale; break;
            case 2: mAnimatorDurationScaleSetting = scale; break;
        }

        // Persist setting
        mH.sendEmptyMessage(H.PERSIST_ANIMATION_SCALE);
    }

// UiThread.java
public final class UiThread extends ServiceThread {
    private static final long SLOW_DISPATCH_THRESHOLD_MS = 100;
    private static final long SLOW_DELIVERY_THRESHOLD_MS = 200;
    private static UiThread sInstance;
    private static Handler sHandler;
    private UiThread() {
        super("android.ui", Process.THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
    }
    @Override
    public void run() {
        // Make sure UiThread is in the fg stune boost group
        Process.setThreadGroup(Process.myTid(), Process.THREAD_GROUP_TOP_APP);
        super.run();
    }
    private static void ensureThreadLocked() {
        if (sInstance == null) {
            sInstance = new UiThread();
            sInstance.start();
            final Looper looper = sInstance.getLooper();
            looper.setTraceTag(Trace.TRACE_TAG_SYSTEM_SERVER);
            looper.setSlowLogThresholdMs(
                    SLOW_DISPATCH_THRESHOLD_MS, SLOW_DELIVERY_THRESHOLD_MS);
            sHandler = new Handler(sInstance.getLooper());
        }
    }
    public static UiThread get() {
        synchronized (UiThread.class) {
            ensureThreadLocked();
            return sInstance;
        }
    }
    public static Handler getHandler() {
        synchronized (UiThread.class) {
            ensureThreadLocked();
            return sHandler;
        }
    }
    /**
     * Disposes current ui thread if it's initialized. Should only be used in tests to set up a
     * new environment.
     */
    @VisibleForTesting
    public static void dispose() {
        synchronized (UiThread.class) {
            if (sInstance == null) {
                return;
            }
            // 执行完 runWithScissors 才会往下执行
            getHandler().runWithScissors(sInstance::quit, 0 /* timeout */);
            sInstance = null;
        }
    }
}

// AnimationThread.java

public final class AnimationThread extends ServiceThread {
    private static AnimationThread sInstance;
    private static Handler sHandler;
    
    private AnimationThread() {
        super("android.anim", THREAD_PRIORITY_DISPLAY, false /*allowIo*/);
    }
    
    private static void ensureThreadLocked() {
        if (sInstance == null) {
            sInstance = new AnimationThread();
            sInstance.start();
            sInstance.getLooper().setTraceTag(Trace.TRACE_TAG_WINDOW_MANAGER);
            sHandler = new Handler(sInstance.getLooper());
        }
    }
    public static AnimationThread get() {
        synchronized (AnimationThread.class) {
            ensureThreadLocked();
            return sInstance;
        }
    }
    public static Handler getHandler() {
        synchronized (AnimationThread.class) {
            ensureThreadLocked();
            return sHandler;
        }
    }
    
    // 使用到 HandlerThread#quit 方法，停止 Looper
    @VisibleForTesting
    public static void dispose() {
        synchronized (AnimationThread.class) {
            if (sInstance == null) {
                return;
            }
            getHandler().runWithScissors(() -> sInstance.quit(), 0 /* timeout */);
            sInstance = null;
        }
    }
}

// SystemServer.java

private void startOtherServices(@NonNull TimingsTraceAndSlog t) {

    ... 省略部分

    try {

        // 初始化准备
        wm.onInitReady();

        ... 省略部分

        try {
            wm.displayReady();
        } catch (Throwable e) {
            reportWtf("making display ready", e);
        }

        wm.systemReady();
    } /* 省略 catch */
}                    

// WindowManagerService.java

    // 当没有指定 Looper 就会依现在 Thread 的 Looper 
    final H mH = new H();        // 也就是 DisplayThread 的 Looper

    WindowManagerPolicy mPolicy;
    final WindowAnimator mAnimator;

    RootWindowContainer mRoot;

    final class H extends android.os.Handler {
        ...
    }

    private WindowManagerService(Context context, InputManagerService inputManager,
            boolean showBootMsgs, boolean onlyCore, WindowManagerPolicy policy,
            ActivityTaskManagerService atm, DisplayWindowSettingsProvider
            displayWindowSettingsProvider, Supplier<SurfaceControl.Transaction> transactionFactory,
            Supplier<Surface> surfaceFactory,
            Function<SurfaceSession, SurfaceControl.Builder> surfaceControlFactory) {

        ... 省略部分

        // WMS 持有 InputManagerService 引用
        mInputManager = inputManager; 
        
        ...
        
        // 取得 DisplayManagerService 代理
        mDisplayManager = (DisplayManager)context.getSystemService(Context.DISPLAY_SERVICE);

      
        mPolicy = policy;        // SystemServer 传进来的实例是PhoneWindowManager类
      
        // 取得 WMS 代理
        mActivityManager = ActivityManager.getService();
        mActivityTaskManager = ActivityTaskManager.getService();
        
        // Window 动画
        mAnimator = new WindowAnimator(this);
        
        // 所有 Window 的根节点 (RootWindowContainer 对象)
        mRoot = new RootWindowContainer(this);    
    }

// WindowManagerService.java

public class WindowManagerService extends IWindowManager.Stub
        implements Watchdog.Monitor, WindowManagerPolicy.WindowManagerFuncs {

    WindowManagerPolicy mPolicy;    // 实作是 PhoneWindowManager 类

    public void onInitReady() {
        // @重点分析 initPolicy 函数
        initPolicy();
        
        ... 省略部分
    }

    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);
    }

}

// ---------------------------------------------
// WindowManagerPolicy.java

public interface WindowManagerPolicy extends WindowManagerPolicyConstants {
    
    ... 省略部分
        
    public void init(Context context, IWindowManager windowManager,
        WindowManagerFuncs windowManagerFuncs);

    
// ----------------------------------------------
// PhoneWindowManager.java

public class PhoneWindowManager implements WindowManagerPolicy {
    
    ... 省略部分
    
    private class PolicyHandler extends Handler {
        ... 省略部分
    }
    
    public void init(Context context, IWindowManager windowManager,
        WindowManagerFuncs windowManagerFuncs) {
        
        // 省略部分…后面介绍
        
        mHandler = new PolicyHandler();    // 该 Handler 使用 UiThread's Looper
        
    }
}

// WindowManagerService.java

    WindowManagerPolicy mPolicy;
    final WindowAnimator mAnimator;

    // 在 WMS construct 被初始化
    RootWindowContainer mRoot;

    public void displayReady() {
        synchronized (mGlobalLock) {    // ActivityTaskManagerService 中的對象
            if (mMaxUiWidth > 0) {
                mRoot.forAllDisplays(displayContent -> displayContent.setMaxUiWidth(mMaxUiWidth));
            }
            applyForcedPropertiesForDefaultDisplay();
            
            // 1. 标识初始化完成
            mAnimator.ready();
            mDisplayReady = true;
            // Reconfigure all displays to make sure that forced properties and
            // DisplayWindowSettings are applied.
          
            // 2. 重新配置设定，保证 DisplayWindowSettings 设定都有被正常使用
            mRoot.forAllDisplays(DisplayContent::reconfigureDisplayLocked);
            
            // 硬件是否是可触控屏幕
            mIsTouchDevice = mContext.getPackageManager().hasSystemFeature(
                    PackageManager.FEATURE_TOUCHSCREEN);
            
            // 硬件是否是假的可触控屏幕
            mIsFakeTouchDevice = mContext.getPackageManager().hasSystemFeature(
                    PackageManager.FEATURE_FAKETOUCH);
        }
        
        try {
            // 3. 透过 ActivityTaskManager 来更新设置
            mActivityTaskManager.updateConfiguration(null);
        } catch (RemoteException e) {
        }
    }

// WindowManagerService.java

    public void systemReady() {
        mSystemReady = true;
        mPolicy.systemReady();
        mRoot.forAllDisplayPolicies(DisplayPolicy::systemReady);
        mTaskSnapshotController.systemReady();
        mHasWideColorGamutSupport = queryWideColorGamutSupport();
        mHasHdrSupport = queryHdrSupport();
        mPrimaryDisplayOrientation = queryPrimaryDisplayOrientation();
        mPrimaryDisplayPhysicalAddress =
            DisplayAddress.fromPhysicalDisplayId(SurfaceControl.getPrimaryPhysicalDisplayId());
        UiThread.getHandler().post(mSettingsObserver::loadSettings);
        IVrManager vrManager = IVrManager.Stub.asInterface(
                ServiceManager.getService(Context.VR_SERVICE));
        if (vrManager != null) {
            try {
                final boolean vrModeEnabled = vrManager.getVrModeState();
                synchronized (mGlobalLock) {
                    vrManager.registerListener(mVrStateCallbacks);
                    if (vrModeEnabled) {
                        mVrModeEnabled = vrModeEnabled;
                        mVrStateCallbacks.onVrStateChanged(vrModeEnabled);
                    }
                }
            } catch (RemoteException e) {
                // Ignore, we cannot do anything if we failed to register VR mode listener
            }
        }
    }

// WindowManagerPolicyConstants.java

// 保留給多 Window (相同 Layer)
int TYPE_LAYER_MULTIPLIER = 10000;

// 保留給多 Window (相同 Layer)，Z 轴偏移量
int TYPE_LAYER_OFFSET = 1000


// ---------------------------------------------------------------
// WindowState.java

final WindowManagerPolicy mPolicy;

WindowState(WindowManagerService service, Session s, IWindow c, WindowToken token,
        WindowState parentWindow, int appOp, WindowManager.LayoutParams a, 
       ... 省略部分入參) {

    // 复制 `WindowManager.LayoutParams`
    mAttrs.copyFrom(a);

    ...

    mPolicy = mWmService.mPolicy;

    ...

    // 判断目前 Window 是否是 SubWindow
    if (mAttrs.type >= FIRST_SUB_WINDOW && mAttrs.type <= LAST_SUB_WINDOW) {
        // 保留空间给多个相同 Layer 等级的 Window

        // @ 查看 getWindowLayerLw 方法
        mBaseLayer = mPolicy.getWindowLayerLw(parentWindow)    // 1.
                * TYPE_LAYER_MULTIPLIER + TYPE_LAYER_OFFSET;   // 2.

        // SubWindow 
        mSubLayer = mPolicy.getSubWindowLayerFromTypeLw(a.type);
        ...
    } else {
        // @ 查看 getWindowLayerLw 方法
        mBaseLayer = mPolicy.getWindowLayerLw(this)
                * TYPE_LAYER_MULTIPLIER + TYPE_LAYER_OFFSET;
        mSubLayer = 0;
        ...
    }

}

// WindowManagerPolicy.java

    default int getWindowLayerLw(WindowState win) {
        return getWindowLayerFromTypeLw(win.getBaseType(), win.canAddInternalSystemWindow());
    }

    default int getWindowLayerFromTypeLw(int type, boolean canAddInternalSystemWindow) {
        return getWindowLayerFromTypeLw(type, canAddInternalSystemWindow,
                false /* roundedCornerOverlay */);
    }

    default int getWindowLayerFromTypeLw(int type, boolean canAddInternalSystemWindow,
            boolean roundedCornerOverlay) {
        // Always put the rounded corner layer to the top most.
        if (roundedCornerOverlay && canAddInternalSystemWindow) {
            return getMaxWindowLayer();
        }

        // 1 ~ 99 之间
        if (type >= FIRST_APPLICATION_WINDOW && type <= LAST_APPLICATION_WINDOW) {
            return APPLICATION_LAYER;    // APPLICATION_LAYER 是 2
        }

        switch (type) {
            case TYPE_WALLPAPER:
                // wallpaper is at the bottom, though the window manager may move it.
                return  1;
            case TYPE_PRESENTATION:
            case TYPE_PRIVATE_PRESENTATION:
            case TYPE_DOCK_DIVIDER:
            case TYPE_QS_DIALOG:
            case TYPE_PHONE:
                return  3;
            case TYPE_SEARCH_BAR:
                return  4;
            case TYPE_INPUT_CONSUMER:
                return  5;
            case TYPE_SYSTEM_DIALOG:
                return  6;
            case TYPE_TOAST:
                // toasts and the plugged-in battery thing
                return  7;
            case TYPE_PRIORITY_PHONE:
                // SIM errors and unlock.  Not sure if this really should be in a high layer.
                return  8;
            case TYPE_SYSTEM_ALERT:
                // like the ANR / app crashed dialogs
                // Type is deprecated for non-system apps. For system apps, this type should be
                // in a higher layer than TYPE_APPLICATION_OVERLAY.
                return  canAddInternalSystemWindow ? 12 : 9;
            case TYPE_APPLICATION_OVERLAY:
                return  11;
            case TYPE_INPUT_METHOD:
                // on-screen keyboards and other such input method user interfaces go here.
                return  13;
            case TYPE_INPUT_METHOD_DIALOG:
                // on-screen keyboards and other such input method user interfaces go here.
                return  14;
            case TYPE_STATUS_BAR:
                return  15;

            ... 省略部分 case

            default:
                Slog.e("WindowManager", "Unknown window type: " + type);
                return 3;
        }
    }

// WindowManagerPolicy.java

    default int getSubWindowLayerFromTypeLw(int type) {
        switch (type) {
            case TYPE_APPLICATION_PANEL:
            case TYPE_APPLICATION_ATTACHED_DIALOG:
                return APPLICATION_PANEL_SUBLAYER;    // 1
                
            case TYPE_APPLICATION_MEDIA:
                return APPLICATION_MEDIA_SUBLAYER;    // -2
                
            case TYPE_APPLICATION_MEDIA_OVERLAY:
                return APPLICATION_MEDIA_OVERLAY_SUBLAYER;    // -1
                
            case TYPE_APPLICATION_SUB_PANEL:
                return APPLICATION_SUB_PANEL_SUBLAYER;    // 2
                
            case TYPE_APPLICATION_ABOVE_SUB_PANEL:
                return APPLICATION_ABOVE_SUB_PANEL_SUBLAYER;    // 3
        }
        Slog.e("WindowManager", "Unknown sub-window type: " + type);
        return 0;
    }