自拍偷在线精品自拍偷,亚洲欧美中文日韩v在线观看不卡

Wms 啟動流程分析和介紹

作者： Android開發(fā)編程
系統(tǒng) Windows
客戶端開發(fā)中并不是直接和 WindowManagerService 交互，而是直接和本地對象 WindowManager 交互，然后由 WindowManager 完成和 WindowManagerService 的交互。

[[433507]]

前言

客戶端開發(fā)中并不是直接和 WindowManagerService 交互，而是直接和本地對象 WindowManager 交互，然后由 WindowManager 完成和 WindowManagerService 的交互;

對于 Android 應(yīng)用來說這個交互是透明的，應(yīng)用感覺不到 WindowManagerService 的存在;

我們來介紹分析下窗口管理服務(wù) WindowManagerService 的啟動過程;

一、WindowManagerService的相關(guān)類

1、WindowManagerService概念

Framework層的窗口管理服務(wù)，職責(zé)是管理Android系統(tǒng)中所有window;窗口管理服務(wù)，繼承IWindowManager.Stub，Binder服務(wù)端，因此WM與WMS的交互也是一個IPC過程。WMS主要做的事情如下：

  • Z-ordered的維護函數(shù)
  • 輸入法管理
  • AddWindow/RemoveWindow
  • Layerout
  • Token管理，AppToken
  • 活動窗口管理(FocusWindow)
  • 活動應(yīng)用管理(FocusApp)
  • 轉(zhuǎn)場動畫
  • 系統(tǒng)消息收集線程
  • 系統(tǒng)消息分發(fā)線程

2、WindowManager

應(yīng)用與窗口管理服務(wù)WindowManagerService交互的接口

3、PhoneWindowManager

實現(xiàn)了窗口的各種策略，定義了窗口相關(guān)策略;

4、Choreographer

用戶控制窗口動畫、屏幕選擇等操作，它擁有從顯示子系統(tǒng)獲取Vsync同步事件的能力，從而可以在合適的時機通知渲染動作，避免在渲染的過程中因為發(fā)生屏幕重繪而導(dǎo)致的畫面撕裂。WMS使用Choreographer負(fù)責(zé)驅(qū)動所有的窗口動畫、屏幕旋轉(zhuǎn)動畫、墻紙動畫的渲染;

5、DisplayContent

  • 用于描述多屏輸出相關(guān)信息;
  • 根據(jù)窗口的顯示位置將其分組。隸屬于同一個DisplayContent的窗口將會被顯示在同一個屏幕中。每個DisplayContent都對應(yīng)著唯一ID，在添加窗口的時候可以通過指定這個ID決定其將顯示在哪個屏幕中;
  • DisplayContent是一個非常具有隔離性的一個概念。處于不同DisplayContent的兩個窗口在布局、顯示順序以及動畫處理上不會產(chǎn)生任何耦合;

6、WindowState

描述窗口的狀態(tài)信息以及和WindowManagerService進行通信，一般一個窗口對應(yīng)一個WindowState。它用來表示一個窗口的所有屬性;

7、WindowToken

  • 窗口Token，用來做Binder通信;同時也是一種標(biāo)識;
  • 在進行窗口Zorder排序時，屬于同一個WindowToken的窗口會被安排在一起，而且在其中定義的一些屬性將會影響所有屬于此WindowToken的窗口，這些都表明了屬于同一個WindowToken的窗口之間的緊密聯(lián)系;
  • 應(yīng)用組件在需要新的窗口時，必須提供WindowToken以表明自己的身份，并且窗口的類型必須與所持有的WindowToken的類型一致;
  • 在創(chuàng)建系統(tǒng)類型的窗口時不需要提供一個有效的Token，WMS會隱式地為其聲明一個WindowToken，看起來誰都可以添加個系統(tǒng)級的窗口。難道Android為了內(nèi)部使用方便而置安全于不顧嗎?非也，addWindow()函數(shù)一開始的mPolicy.checkAddPermission()的目的就是如此。它要求客戶端必須擁有SYSTEM_ALERT_WINDOW或INTERNAL_SYSTEM_WINDOW權(quán)限才能創(chuàng)建系;

8、Session

App進程通過建立Session代理對象和Session對象通信，進而和WMS建立連接;

9、SurfaceFlinger

SurfaceFlinger負(fù)責(zé)管理Android系統(tǒng)的幀緩沖區(qū)(Frame Buffer)，Android設(shè)備的顯示屏被抽象為一個幀緩沖區(qū)，而Android系統(tǒng)中的SurfaceFlinger服務(wù)就是通過向這個幀緩沖區(qū)寫入內(nèi)容來繪制應(yīng)用程序中的用戶界面的;

10、InputManager

IMS實例。管理每個窗口的輸入事件通道(InputChannel)以及向通道上派發(fā)事件

11、Animator

所有窗口動畫的總管(WindowStateAnimator對象)。在Choreographer的驅(qū)動下，逐個渲染所有的動畫

二、WMS啟動流程

WMS的啟動，依然是由SystemServer進行啟動，在SystemServer的main函數(shù)中調(diào)用startOtherServices方法創(chuàng)建WMS;

1、SystemServer#startOtherServices

  1. private void startOtherServices() { 
  2.         ... 
  3.         try { 
  4.             ... 
  5.             // 創(chuàng)建WMS對象 
  6.             // 創(chuàng)建WMS對象需要依賴于InputManager、PhoneWindowManager、和AMS 
  7.             // IMS是用來管理每個窗口的輸入事件通道以及向通道上派發(fā)事件 
  8.             // PhoneWindowManager是實現(xiàn)了窗口的各種策略，定義了窗口相關(guān)策略 
  9.             // 比如：告訴WMS某一個類型Window的Z-Order的值是多少，幫助WMS矯正不合理的窗口屬性， 
  10.             // 為WMS監(jiān)聽屏幕旋轉(zhuǎn)的狀態(tài)，預(yù)處理一些系統(tǒng)按鍵事件（例如HOME、BACK鍵等的默認(rèn)行為就是在這里實現(xiàn)的）等 
  11.             wm = WindowManagerService.main(context, inputManager, !mFirstBoot, mOnlyCore, 
  12.                     new PhoneWindowManager(), mActivityManagerService.mActivityTaskManager); 
  13.             ServiceManager.addService(Context.WINDOW_SERVICE, wm, /* allowIsolated= */ false, 
  14.                     DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PROTO); 
  15.             ServiceManager.addService(Context.INPUT_SERVICE, inputManager, 
  16.                     /* allowIsolated= */ false, DUMP_FLAG_PRIORITY_CRITICAL); 
  17.             traceEnd(); 
  18.             traceBeginAndSlog("SetWindowManagerService"); 
  19.             // 將AMS與WMS做綁定 
  20.             mActivityManagerService.setWindowManager(wm); 
  21.             traceEnd(); 
  22.             traceBeginAndSlog("WindowManagerServiceOnInitReady"); 
  23.             // 這里主要是調(diào)用initPolicy用來初始化PhoneWindowManager 
  24.             wm.onInitReady(); 
  25.             traceEnd(); 
  26.             ... 
  27.         } 
  28.         ... 
  29.         traceBeginAndSlog("MakeDisplayReady"); 
  30.         try { 
  31.             // 主要是初始化UI尺寸 
  32.             wm.displayReady(); 
  33.         } catch (Throwable e) { 
  34.             reportWtf("making display ready", e); 
  35.         } 
  36.         traceEnd(); 
  37.         ... 
  38.         traceBeginAndSlog("MakeWindowManagerServiceReady"); 
  39.         try { 
  40.             // 準(zhǔn)備工作已經(jīng)完成 
  41.             wm.systemReady(); 
  42.         } catch (Throwable e) { 
  43.             reportWtf("making Window Manager Service ready", e); 
  44.         } 
  45.         traceEnd(); 
  46.         ... 
  47.     } 

2、WindowManagerService#main

  • WMS的main方法：是運行在SystemServer進程的主線程，但是WMS的初始化是在DisplayThread線程構(gòu)建的;
  • DisplayThread其實就是一個HandlerThread;
  • Handler中有一個runWithScissors方法：這個方法其實就是Handler.post消息執(zhí)行之后能夠再繼續(xù)往下執(zhí)行;
  • 即runWithScissors后面的內(nèi)容，需要等待消息的處理完成之后才會繼續(xù)執(zhí)行。其實就是實現(xiàn)一個同步執(zhí)行的過程;
  • DisplayThread其實是android.display線程，這是系統(tǒng)共享的單例前臺線程，在該線程內(nèi)部創(chuàng)建了WMS;
  1. public static WindowManagerService main(final Context context, final InputManagerService im, 
  2.             final boolean showBootMsgs, final boolean onlyCore, WindowManagerPolicy policy, 
  3.             ActivityTaskManagerService atm) { 
  4.         return main(context, im, showBootMsgs, onlyCore, policy, atm, 
  5.                 SurfaceControl.Transaction::new); 
  6.     } 
  • WMS的main方法是在SystemServer進程的主線程調(diào)用的，然后在調(diào)用WMS的main方法的時候，通過DisplayThread這個HandlerThread，實現(xiàn)異步處理;
  • 這里的異步處理，其實是通過跨線程的一個同步，即通過DisplayThread中的Handler對象，調(diào)用runWithScissors方法;
  • 該方法其實是可以實現(xiàn)發(fā)送消息等待消息處理完成以后再繼續(xù)執(zhí)行runWithScissors方法調(diào)用位置之后的代碼，即等待消息處理完之后再進行return WMS對象的返回操作;
  1. @VisibleForTesting 
  2.     public static WindowManagerService main(final Context context, final InputManagerService im, 
  3.             final boolean showBootMsgs, final boolean onlyCore, WindowManagerPolicy policy, 
  4.             ActivityTaskManagerService atm, TransactionFactory transactionFactory) { 
  5.         // wms是運行在android.display線程 
  6.         DisplayThread.getHandler().runWithScissors(() -> 
  7.                 sInstance = new WindowManagerService(context, im, showBootMsgs, onlyCore, policy, 
  8.                         atm, transactionFactory), 0); 
  9.         return sInstance; 
  10.     } 

3、Handler#runWithScissors

上面的runWithScissors傳入的就是一個Runnable實例，只不過是采用了lambda表達(dá)式的做法，所以Runnable的run()方法的方法體是就是：

  1. sInstance = new WindowManagerService(context, im, showBootMsgs, onlyCore, policy, 
  2. atm, transactionFactory), 0); 
  3. public final boolean runWithScissors(@NonNull Runnable r, long timeout) { 
  4.     if (r == null) { 
  5.         throw new IllegalArgumentException("runnable must not be null"); 
  6.     } 
  7.     if (timeout < 0) { 
  8.         throw new IllegalArgumentException("timeout must be non-negative"); 
  9.     } 
  10.     // 如果調(diào)用runWithScissors方法的線程是與消息處理線程在同一個線程 
  11.     // 則直接執(zhí)行Runnable的run方法。 
  12.     if (Looper.myLooper() == mLooper) { 
  13.         r.run(); 
  14.         return true; 
  15.     } 
  16.     // 如果調(diào)用runWithScissors方法的線程與消息處理線程不是同一個，則創(chuàng)建一個BlockingRunnable 
  17.     BlockingRunnable br = new BlockingRunnable(r); 
  18.     return br.postAndWait(this, timeout); 
  19. } 
  • 則創(chuàng)建一個BlockingRunnable;
  • 調(diào)用BlockingRunnable.postAndWait方法;
  • 這里的返回值會先等待，等待DisplayThread線程中的Handler處理完;
  • 消息之后，然后喚醒BlockingRunnable;
  • 該Handler處理消息是在DisplayThread線程，而BlockingRunnable;
  • 而BlockingRunnable調(diào)用wait并不會讓DisplayThread線程中的;
  • Handler等待，Handler依然會處理消息，處理消息其實就是調(diào)用了;
  • BlockingRunnable.run()方法，當(dāng)BlockingRunnable.run()執(zhí)行完成;
  • 就會調(diào)用notifyAll喚醒BlockingRunnable，執(zhí)行postAndWait的return;

4、BlockingRunnable方法介紹

  1. private static final class BlockingRunnable implements Runnable { 
  2.     private final Runnable mTask; 
  3.     private boolean mDone; 
  4.     public BlockingRunnable(Runnable task) { 
  5.         mTask = task; 
  6.     } 
  7.     @Override 
  8.     public void run() { 
  9.         try { 
  10.             mTask.run(); 
  11.         } finally { 
  12.             synchronized (this) { 
  13.                 mDone = true; 
  14.                 notifyAll(); 
  15.             } 
  16.         } 
  17.     } 
  18.     public boolean postAndWait(Handler handler, long timeout) { 
  19.         // 調(diào)用postAndWait的時候，先調(diào)用handler對象的post將消息發(fā)送出 
  20.         // 如果入隊成功，則為true，則開始阻塞 
  21.         if (!handler.post(this)) { 
  22.             return false; 
  23.         } 
  24.         // 在上面的方法調(diào)用中，timeout=0，則阻塞。 
  25.         synchronized (this) { 
  26.             if (timeout > 0) { 
  27.                 final long expirationTime = SystemClock.uptimeMillis() + timeout; 
  28.                 // 如果mDone為false的時候，則會等待，只有為true的時候，會執(zhí)行 
  29.                 while (!mDone) { 
  30.                     long delay = expirationTime - SystemClock.uptimeMillis(); 
  31.                     if (delay <= 0) { 
  32.                         return false; // timeout 
  33.                     } 
  34.                     try { 
  35.                         wait(delay); 
  36.                     } catch (InterruptedException ex) { 
  37.                     } 
  38.                 } 
  39.             } else { 
  40.                 while (!mDone) { 
  41.                     try { 
  42.                         wait(); 
  43.                     } catch (InterruptedException ex) { 
  44.                     } 
  45.                 } 
  46.             } 
  47.         } 
  48.         return true; 
  49.     } 
  50. } 
  • mTask其實就是runWithScissors中傳入的Runnable對象;
  • BlockingRunnable的run方法的執(zhí)行，其實就是需要Handler遍歷到消息處理的時候;
  • 然后處理這個BlockingRunnable消息，在處理BlockingRunnable消息的時候;
  • 就會處理runWithScissors的參數(shù)中的Runnable這個mTask;
  • 處理完成之后，就會調(diào)用notifyAll喚醒等待線程，然后執(zhí)行postAndWait的return;
  • 因為BlockingRunnable的run方法是由Handler處理消息;
  • 這個消息的處理與BlockingRunnable是在不同的線程;
  • 所以BlockingRunnable等待的時候，其run方法是可以由handler消息處理;

5、WindowManagerService構(gòu)造器

  1. private WindowManagerService(Context context, InputManagerService inputManager, 
  2.         boolean showBootMsgs, boolean onlyCore, WindowManagerPolicy policy, 
  3.         ActivityTaskManagerService atm, TransactionFactory transactionFactory) { 
  4.     installLock(this, INDEX_WINDOW); 
  5.     mGlobalLock = atm.getGlobalLock(); 
  6.     mAtmService = atm; 
  7.     mContext = context; 
  8.     mAllowBootMessages = showBootMsgs; 
  9.     mOnlyCore = onlyCore; 
  10.     // 各種變量讀取 
  11.     mLimitedAlphaCompositing = context.getResources().getBoolean( 
  12.             com.android.internal.R.bool.config_sf_limitedAlpha); 
  13.     mHasPermanentDpad = context.getResources().getBoolean( 
  14.             com.android.internal.R.bool.config_hasPermanentDpad); 
  15.     mInTouchMode = context.getResources().getBoolean( 
  16.             com.android.internal.R.bool.config_defaultInTouchMode); 
  17.     ...... 
  18.     mInputManager = inputManager; 
  19.     mDisplayManagerInternal = 
  20.         LocalServices.getService(DisplayManagerInternal.class); 
  21.     // Display設(shè)置 
  22.     mDisplayWindowSettings = new DisplayWindowSettings(this); 
  23.     mTransactionFactory = transactionFactory; 
  24.     mTransaction = mTransactionFactory.make(); 
  25.     //PhoneWindowManager(繼承于WindowManagerPolicy, 用來提供UI相關(guān)的一些行為) 
  26.     mPolicy = policy; 
  27.     // 在一個單獨的task中執(zhí)行動畫和Surface操作的類 
  28.     mAnimator = new WindowAnimator(this); 
  29.     // 根Window容器 
  30.     mRoot = new RootWindowContainer(this); 
  31.     // 用來確定Window和Surface的位置 
  32.     mWindowPlacerLocked = new WindowSurfacePlacer(this); 
  33.     // 任務(wù)快照管理器(當(dāng)App不可見時, 會將Task的快照以Bitmap形式存在緩存中) 
  34.     mTaskSnapshotController = new TaskSnapshotController(this); 
  35.     LocalServices.addService(WindowManagerPolicy.class, mPolicy); 
  36.     mDisplayManager =  
  37.     (DisplayManager)context.getSystemService(Context.DISPLAY_SERVICE); 
  38.     // Keyguard處理器 
  39.     mKeyguardDisableHandler = 
  40.         KeyguardDisableHandler.create(mContext, mPolicy, mH); 
  41.     // PowerManager是控制設(shè)備電池狀態(tài)的管理器 
  42.     mPowerManager =  
  43.         (PowerManager)context.getSystemService(Context.POWER_SERVICE); 
  44.     // PowerManagerInternal是PowerMananger的本地服務(wù) 
  45.     mPowerManagerInternal = 
  46.         LocalServices.getService(PowerManagerInternal.class); 
  47.     if (mPowerManagerInternal != null) { 
  48.         mPowerManagerInternal.registerLowPowerModeObserver( 
  49.                 new PowerManagerInternal.LowPowerModeListener() { 
  50.             @Override 
  51.             public int getServiceType() { 
  52.                 return ServiceType.ANIMATION; 
  53.             } 
  54.             @Override 
  55.             public void onLowPowerModeChanged(PowerSaveState result) { 
  56.                 synchronized (mGlobalLock) { 
  57.                     // 低電量模式發(fā)生變化時, 需要調(diào)整對應(yīng)的動畫 
  58.                     final boolean enabled = result.batterySaverEnabled; 
  59. if (mAnimationsDisabled != enabled && !mAllowAnimationsInLowPowerMode) { 
  60.                         mAnimationsDisabled = enabled; 
  61.                         dispatchNewAnimatorScaleLocked(null); 
  62.                     } 
  63.                 } 
  64.             } 
  65.         }); 
  66.         // 獲取是否允許動畫 
  67.         mAnimationsDisabled = 
  68.             mPowerManagerInternal.getLowPowerState( 
  69.             ServiceType.ANIMATION).batterySaverEnabled; 
  70.     } 
  71.     mScreenFrozenLock = 
  72.     mPowerManager.newWakeLock( 
  73.         PowerManager.PARTIAL_WAKE_LOCK, "SCREEN_FROZEN"); 
  74.     mScreenFrozenLock.setReferenceCounted(false); 
  75.     // 獲取IActivity.Stub.Proxy(new BinderProxy()) 
  76.     mActivityManager = ActivityManager.getService(); 
  77.     // 獲取IActivityTaskManager.Stub.Proxy 
  78.     mActivityTaskManager = ActivityTaskManager.getService(); 
  79.     // ActivityManagerInternal是ActivityManager的本地服務(wù) 
  80.     mAmInternal = 
  81.         LocalServices.getService(ActivityManagerInternal.class); 
  82.     // ActivityTaskManagerInternal是ActivityTaskManager的本地服務(wù) 
  83.     mAtmInternal = 
  84.         LocalServices.getService(ActivityTaskManagerInternal.class); 
  85.     mAppOps =  
  86.     (AppOpsManager)context.getSystemService(Context.APP_OPS_SERVICE); 
  87.     AppOpsManager.OnOpChangedInternalListener opListener = 
  88.             new AppOpsManager.OnOpChangedInternalListener() { 
  89.                 @Override  
  90.                 public void onOpChanged(int op, String packageName) { 
  91.                     updateAppOpsState(); 
  92.                 } 
  93.             }; 
  94.     mAppOps.startWatchingMode(OP_SYSTEM_ALERT_WINDOW, null, opListener); 
  95.     mAppOps.startWatchingMode(AppOpsManager.OP_TOAST_WINDOW, 
  96.         null, opListener); 
  97.     // PackageManagerInternal是PackageManager的本地服務(wù) 
  98.     mPmInternal = LocalServices.getService(PackageManagerInternal.class); 
  99.     // 注冊Package suspend/unsuspend廣播 
  100.     final IntentFilter suspendPackagesFilter = new IntentFilter(); 
  101.     suspendPackagesFilter.addAction(Intent.ACTION_PACKAGES_SUSPENDED); 
  102.     suspendPackagesFilter.addAction(Intent.ACTION_PACKAGES_UNSUSPENDED); 
  103.     context.registerReceiverAsUser(new BroadcastReceiver() { 
  104.         @Override 
  105.         public void onReceive(Context context, Intent intent) { 
  106.             final String[] affectedPackages = 
  107.             intent.getStringArrayExtra(Intent.EXTRA_CHANGED_PACKAGE_LIST); 
  108.             final boolean suspended = 
  109.             Intent.ACTION_PACKAGES_SUSPENDED.equals(intent.getAction()); 
  110.             updateHiddenWhileSuspendedState( 
  111.             new ArraySet<>(Arrays.asList(affectedPackages)), suspended); 
  112.         } 
  113.     }, UserHandle.ALL, suspendPackagesFilter, null, null); 
  114.     // 獲取并設(shè)置window scale設(shè)置 
  115.     final ContentResolver resolver = context.getContentResolver(); 
  116.     mWindowAnimationScaleSetting = Settings.Global.getFloat(resolver, 
  117. Settings.Global.WINDOW_ANIMATION_SCALE, mWindowAnimationScaleSetting); 
  118.     ...... 
  119.     // 注冊廣播, 當(dāng)DevicePolicyManager狀態(tài)發(fā)生變化時設(shè)置keyguard屬性是否可用 
  120.     IntentFilter filter = new IntentFilter(); 
  121.     filter.addAction(ACTION_DEVICE_POLICY_MANAGER_STATE_CHANGED); 
  122.     mContext.registerReceiverAsUser(mBroadcastReceiver, 
  123.         UserHandle.ALL, filter, null, null); 
  124.     mLatencyTracker = LatencyTracker.getInstance(context); 
  125.     mSettingsObserver = new SettingsObserver();  
  126.     ......  
  127.     mSurfaceAnimationRunner = new SurfaceAnimationRunner(mPowerManagerInternal); 
  128.     mAllowTheaterModeWakeFromLayout = context.getResources().getBoolean( 
  129. com.android.internal.R.bool.config_allowTheaterModeWakeFromWindowLayout); 
  130.     // Task定位控制器 
  131.     mTaskPositioningController = new TaskPositioningController(this, 
  132.         mInputManager, mActivityTaskManager, mH.getLooper()); 
  133.     // View的拖/拉操作控制器 
  134.     mDragDropController = new DragDropController(this, mH.getLooper());  
  135.     ...... 
  136.     // 注冊WindowManager的本地服務(wù)WindowManagerInternal 
  137.     LocalServices.addService(WindowManagerInternal.class, new LocalService()); 
  138. } 

LocalServices與ServiceManager類似，但是LocalServices只能是在同一個進程中使用;

并且LocalServices中注冊的并不是一個Binder對象，注冊進的都是對應(yīng)的Service的靜態(tài)內(nèi)部類;

也就是LocalService，比如WMS有一個WindowManagerInternal，LocalService就是其子類實現(xiàn);

6、onInitReady

  1. public void onInitReady() { 
  2.     // 初始化PhoneWindowManager 
  3.     initPolicy(); 
  4.     // 添加Watchdog monitor 
  5.     Watchdog.getInstance().addMonitor(this);  
  6.     // 調(diào)用SurfaceControl.openTransaction(), 啟動一個事務(wù) 
  7.     openSurfaceTransaction(); 
  8.     // 創(chuàng)建水印 
  9.     createWatermarkInTransaction(); 
  10.     // 結(jié)束事務(wù) 
  11. closeSurfaceTransaction("createWatermarkInTransaction");  
  12.     // 顯示模擬器顯示層 
  13.     showEmulatorDisplayOverlayIfNeeded(); 
  14. } 

7、 initPolicy

  1. private void initPolicy() { 
  2.         UiThread.getHandler().runWithScissors(new Runnable() { 
  3.             @Override 
  4.             public void run() { 
  5.                 WindowManagerPolicyThread.set(Thread.currentThread(), 
  6.                     Looper.myLooper()); 
  7.                 mPolicy.init(mContext, WindowManagerService.this, 
  8.                     WindowManagerService.this); 
  9.             } 
  10.         }, 0); 
  11.     } 

PhoneWindowManager 的初始化運行在 “android.ui” 線程;

8、 displayReady

  1. public void displayReady() { 
  2.     synchronized (mGlobalLock) { 
  3.         // 設(shè)置RootWindowContainer的Window列表的最大寬度 
  4.         if (mMaxUiWidth > 0) { 
  5.             mRoot.forAllDisplays( 
  6.             displayContent -> displayContent.setMaxUiWidth(mMaxUiWidth)); 
  7.         } 
  8.         final boolean changed = applyForcedPropertiesForDefaultDisplay(); 
  9.         mAnimator.ready(); 
  10.         mDisplayReady = true; 
  11.         if (changed) { 
  12.             // 重新配置DiaplayContent屬性 
  13.             reconfigureDisplayLocked(getDefaultDisplayContentLocked()); 
  14.         } 
  15.         mIsTouchDevice = mContext.getPackageManager().hasSystemFeature( 
  16.         PackageManager.FEATURE_TOUCHSCREEN); 
  17.     } 
  18.     // 1.修改當(dāng)前configuration 2.確保當(dāng)前Activity正在運行當(dāng)前configuration 
  19.     mActivityTaskManager.updateConfiguration(null); 
  20.     // 更新CircularDisplayMask 
  21.     updateCircularDisplayMaskIfNeeded(); 
  22. } 

9、systemReady

  1. public void systemReady() { 
  2.     mSystemReady = true; 
  3.     mPolicy.systemReady(); 
  4.     mRoot.forAllDisplayPolicies(DisplayPolicy::systemReady); 
  5.     mTaskSnapshotController.systemReady(); 
  6.     // 是否支持色域 
  7.     mHasWideColorGamutSupport = queryWideColorGamutSupport(); 
  8.     // 是否支持HDR渲染 
  9.     mHasHdrSupport = queryHdrSupport(); 
  10.     UiThread.getHandler().post(mSettingsObserver::updateSystemUiSettings); 
  11.     UiThread.getHandler().post(mSettingsObserver::updatePointerLocation); 
  12.     // 獲取IVrManager.Stub.Proxy, 并注冊狀態(tài)變化listener 
  13.     IVrManager vrManager = IVrManager.Stub.asInterface( 
  14.             ServiceManager.getService(Context.VR_SERVICE)); 
  15.     if (vrManager != null) { 
  16.         final boolean vrModeEnabled = vrManager.getVrModeState(); 
  17.         synchronized (mGlobalLock) { 
  18.             vrManager.registerListener(mVrStateCallbacks); 
  19.             if (vrModeEnabled) { 
  20.                 mVrModeEnabled = vrModeEnabled; 
  21.                 mVrStateCallbacks.onVrStateChanged(vrModeEnabled); 
  22.             } 
  23.         } 
  24.     } 
  25. } 

整個啟動過程涉及3個線程: system_server主線程, “android.display”, “android.ui”;

整個過程是采用阻塞方式(利用Handler.runWithScissors)執(zhí)行的;

其中WindowManagerService.mH的Looper運行在 “android.display”進程，也就意味著WMS.H.handleMessage()在該線程執(zhí)行;

WMS 主要用于窗口的添加和移除操作，其對應(yīng)的方法是 addWindow 和 removeWindow，關(guān)于窗口的添加和刪除過程

總結(jié)

快年底了，一起加油努力

 

責(zé)任編輯：武曉燕 來源： Android開發(fā)編程
網(wǎng)絡(luò)流程Window
相關(guān)推薦

2016-12-27 19:10:38

Linux命令啟動流程

2021-10-29 16:36:53

AMSAndroidActivityMan

2021-09-18 14:26:49

Linux Linux 啟動流程Linux 系統(tǒng)

2022-08-29 17:34:05

鴻蒙操作系統(tǒng)

2021-10-20 10:04:47

鴻蒙HarmonyOS應(yīng)用

2010-07-14 17:38:47

MIME協(xié)議

2012-07-04 10:31:54

BIOSEFI光盤制作

2021-09-22 08:51:34

Android

2012-12-27 14:37:39

2021-08-10 20:41:33

AndroidApp流程

2012-06-18 16:50:34

云計算服務(wù)

2009-09-10 09:53:40

CCNA考試流程CCNA

2023-09-15 07:39:44

分布式數(shù)據(jù)庫系統(tǒng)高并發(fā)

2010-07-08 15:18:06

SSH協(xié)議

2023-04-26 15:29:35

NAPI模塊鴻蒙

2009-12-14 13:56:12

Ruby特點

2023-04-28 08:43:46

2021-04-14 15:23:34

鴻蒙HarmonyOS應(yīng)用

2024-12-16 08:10:00

Spring開發(fā)

2011-07-08 14:33:02

Cocos2d iphone
點贊
收藏

51CTO技術(shù)棧公眾號