Android6.0 WMS（三） WMS窗口次序

原創 jiangnan2222 2020-02-25 10:12

這篇博客我們主要分析下，窗口位置排序的一些原理。


一、添加窗口的時候 調整窗口位置

上篇博客我們分析了WMS的addWindow函數，這裏我們就窗口的次序問題繼續分析。

  1.             boolean imMayMove = true;
  2.  
  3.             if (type == TYPE_INPUT_METHOD) {//如果窗口類是輸入法窗口
  4.                 win.mGivenInsetsPending = true;
  5.                 mInputMethodWindow = win;
  6.                 addInputMethodWindowToListLocked(win);//插入輸入法窗口到應用窗口上層
  7.                 imMayMove = false;
  8.             } else if (type == TYPE_INPUT_METHOD_DIALOG) {//如果窗口是輸入法對話框
  9.                 mInputMethodDialogs.add(win);
  10.                 addWindowToListInOrderLocked(win, true);//插入到正常位置
  11.                 moveInputMethodDialogsLocked(findDesiredInputMethodWindowIndexLocked(true));//調整對話框位置
  12.                 imMayMove = false;
  13.             } else {
  14.                 addWindowToListInOrderLocked(win, true);//插入正常位置
  15.                 if (type == TYPE_WALLPAPER) {
  16.                     mLastWallpaperTimeoutTime = 0;
  17.                     displayContent.pendingLayoutChanges |= FINISH_LAYOUT_REDO_WALLPAPER;
  18.                 } else if ((attrs.flags&FLAG_SHOW_WALLPAPER) != 0) {
  19.                     displayContent.pendingLayoutChanges |= FINISH_LAYOUT_REDO_WALLPAPER;
  20.                 } else if (mWallpaperTarget != null
  21.                         && mWallpaperTarget.mLayer >= win.mBaseLayer) {
  22.                     // If there is currently a wallpaper being shown, and
  23.                     // the base layer of the new window is below the current
  24.                     // layer of the target window, then adjust the wallpaper.
  25.                     // This is to avoid a new window being placed between the
  26.                     // wallpaper and its target.
  27.                     displayContent.pendingLayoutChanges |= FINISH_LAYOUT_REDO_WALLPAPER;
  28.                 }
  29.             }

DisplayContent類的mWindows列表按Z序保存了每個窗口，這段代碼就是在根據窗口類型把窗口加入到DisplayContent合適位置。

addInputMethodWindowToListLocked方法作用就是一個輸入法窗口放子啊需要顯示輸入法窗口的上面。

addWindowToListInOrderLocked將一個窗口插入到窗口堆棧的當前位置。


我們繼續看addWindow函數，

  1.             final WindowStateAnimator winAnimator = win.mWinAnimator;
  2.             winAnimator.mEnterAnimationPending = true;
  3.             winAnimator.mEnteringAnimation = true;
  4.  
  5.             if (displayContent.isDefaultDisplay) {
  6.                 mPolicy.getInsetHintLw(win.mAttrs, mRotation, outContentInsets, outStableInsets,//計算窗口大小
  7.                         outOutsets);
  8.             } else {
  9.                 outContentInsets.setEmpty();
  10.                 outStableInsets.setEmpty();
  11.             }
  12.  
  13.             if (mInTouchMode) {
  14.                 res |= WindowManagerGlobal.ADD_FLAG_IN_TOUCH_MODE;//加入支持觸屏的標誌
  15.             }
  16.             if (win.mAppToken == null || !win.mAppToken.clientHidden) {
  17.                 res |= WindowManagerGlobal.ADD_FLAG_APP_VISIBLE;//加入應用可用的標誌
  18.             }
  19.  
  20.             mInputMonitor.setUpdateInputWindowsNeededLw();//設置更新輸入法窗口的標誌
  21.  
  22.             boolean focusChanged = false;
  23.             if (win.canReceiveKeys()) {//如果窗口能接受輸入計算是否引起焦點變化
  24.                 focusChanged = updateFocusedWindowLocked(UPDATE_FOCUS_WILL_ASSIGN_LAYERS,
  25.                         false /*updateInputWindows*/);
  26.                 if (focusChanged) {
  27.                     imMayMove = false;
  28.                 }
  29.             }
  30.  
  31.             if (imMayMove) {
  32.                 moveInputMethodWindowsIfNeededLocked(false);//調整輸入法的窗口位置
  33.             }
  34.  
  35.             assignLayersLocked(displayContent.getWindowList());//重新計算z軸的位置
  36.             // Don't do layout here, the window must call
  37.             // relayout to be displayed, so we'll do it there.
  38.  
  39.             if (focusChanged) {
  40.                 mInputMonitor.setInputFocusLw(mCurrentFocus, false /*updateInputWindows*/);
  41.             }
  42.             mInputMonitor.updateInputWindowsLw(false /*force*/);//更新輸入法窗口的信息
  43.  
  44.             if (localLOGV || DEBUG_ADD_REMOVE) Slog.v(TAG, "addWindow: New client "
  45.                     + client.asBinder() + ": window=" + win + " Callers=" + Debug.getCallers(5));
  46.  
  47.             if (win.isVisibleOrAdding() && updateOrientationFromAppTokensLocked(false)) {
  48.                 reportNewConfig = true;//配置發生變化
  49.             }
  50.         }
  51.  
  52.         if (reportNewConfig) {
  53.             sendNewConfiguration();//發送新的配置
  54.         }
  55.  
  56.         Binder.restoreCallingIdentity(origId);
  57.  
  58.         return res;
  59.     }

如果窗口顯示在缺省的顯示設備，調用mPolicy的getInsetHintLw函數來獲得除了狀態條、導航條所佔區域後的窗口大小。

接下來如果窗口能接受輸入，調用updateFocusedWindowLocked來重新確定系統的焦點位置。如果焦點發生變化，則將imMayMove置爲false。

新加入的窗口的位置在前面調用addWindowToListInOrderLocked的時候位置已經確定了，所以這裏調用assignLayersLocked只是重新計算Z軸的位置。如果調用updateOrientationFromAppTokensLocked函數計算窗口的配置發生變化，調用sendNewConfiguration函數發送配置。


二、確定窗口的mLayer值

顯示設備的水平方向，垂直方向作爲X軸Y軸，我們還可以想象有一個垂直於屏幕的Z軸，Z軸的值越來越靠近屏幕。系統中所有的窗口都按次序排列在Z軸上。窗口對象WindowState的成員變量mLayer表示窗口在Z軸的值，值越小越靠近底層。

WMS作用之一就是管理各個窗口Z軸位置，確保正確顯示。在所有窗口中輸入法和壁紙窗口比較特殊。輸入法窗口出現時，需要顯示在應用窗口的前面。壁紙窗口通常在底層，但是又不是位於所有窗口的底層，而是位於當前Activity窗口的下面。

因此，當系統調整某個應用窗口的位置時，如果需要也會調整輸入法和壁紙窗口，使當前Activity的窗口位於輸入法窗口和壁紙窗口之間。

WindowState的成員變量mLayer的值表示窗口在Z軸的位置，這個值越小，位置越靠下。mLayer是通過計算得到，會經常變化。WindowState的另一個成員變量mBaseLayer的值是固定不變的，只和窗口類型有關。mLayer的值是根據mBaseLayer的值計算而來。

下面我們先來看看mBaseLayer的值如何而來,在WindowState的構造函數中有如下代碼：

  1.         if ((mAttrs.type >= FIRST_SUB_WINDOW &&
  2.                 mAttrs.type <= LAST_SUB_WINDOW)) {//如果是子窗口
  3.             // The multiplier here is to reserve space for multiple
  4.             // windows in the same type layer.
  5.             mBaseLayer = mPolicy.windowTypeToLayerLw(//使用依附窗口的類型
  6.                     attachedWindow.mAttrs.type) * WindowManagerService.TYPE_LAYER_MULTIPLIER
  7.                     + WindowManagerService.TYPE_LAYER_OFFSET;
  8.             mSubLayer = mPolicy.subWindowTypeToLayerLw(a.type);//計算mSubLayer
  9.             ......
  10.         } else {//非子窗口
  11.             // The multiplier here is to reserve space for multiple
  12.             // windows in the same type layer.
  13.             mBaseLayer = mPolicy.windowTypeToLayerLw(a.type)
  14.                     * WindowManagerService.TYPE_LAYER_MULTIPLIER
  15.                     + WindowManagerService.TYPE_LAYER_OFFSET;
  16.             mSubLayer = 0;
  17.             ......
  18.         }

如果窗口類型是子窗口，則使用它所依附的窗口類型來計算mBaseLayer，否則使用窗口類型來計算mBaseLayer。計算的方法是先調用mPolicy.windowTypeToLayerLw方法將窗口的類型轉化成一個基數，然後再乘以TYPE_LAYER_MULTIPLIER（10000），最後加上TYPE_LAYER_OFFSET（1000），我們先來看看windowTypeToLayerLw函數是如果根據類型返回一個基數的。

  1.     public int windowTypeToLayerLw(int type) {
  2.         if (type >= FIRST_APPLICATION_WINDOW && type <= LAST_APPLICATION_WINDOW) {//應用窗口
  3.             return 2;
  4.         }
  5.         switch (type) {
  6.         case TYPE_PRIVATE_PRESENTATION:
  7.             return 2;
  8.         case TYPE_WALLPAPER:
  9.             // wallpaper is at the bottom, though the window manager may move it.
  10.             return 2;
  11.         case TYPE_PHONE:
  12.             return 3;
  13.         case TYPE_SEARCH_BAR:
  14.         case TYPE_VOICE_INTERACTION_STARTING:
  15.             return 4;
  16.         case TYPE_VOICE_INTERACTION:
  17.             // voice interaction layer is almost immediately above apps.
  18.             return 5;
  19.         case TYPE_INPUT_CONSUMER:
  20.             return 6;
  21.         case TYPE_SYSTEM_DIALOG:
  22.             return 7;
  23.         case TYPE_TOAST:
  24.             // toasts and the plugged-in battery thing
  25.             return 8;
  26.         case TYPE_PRIORITY_PHONE:
  27.             // SIM errors and unlock.  Not sure if this really should be in a high layer.
  28.             return 9;
  29.         case TYPE_DREAM:
  30.             // used for Dreams (screensavers with TYPE_DREAM windows)
  31.             return 10;
  32.         case TYPE_SYSTEM_ALERT:
  33.             // like the ANR / app crashed dialogs
  34.             return 11;
  35.         case TYPE_INPUT_METHOD:
  36.             // on-screen keyboards and other such input method user interfaces go here.
  37.             return 12;
  38.         case TYPE_INPUT_METHOD_DIALOG:
  39.             // on-screen keyboards and other such input method user interfaces go here.
  40.             return 13;
  41.         case TYPE_KEYGUARD_SCRIM:
  42.             // the safety window that shows behind keyguard while keyguard is starting
  43.             return 14;
  44.         case TYPE_STATUS_BAR_SUB_PANEL:
  45.             return 15;
  46.         case TYPE_STATUS_BAR:
  47.             return 16;
  48.         case TYPE_STATUS_BAR_PANEL:
  49.             return 17;
  50.         case TYPE_KEYGUARD_DIALOG:
  51.             return 18;
  52.         case TYPE_VOLUME_OVERLAY:
  53.             // the on-screen volume indicator and controller shown when the user
  54.             // changes the device volume
  55.             return 19;
  56.         case TYPE_SYSTEM_OVERLAY:
  57.             // the on-screen volume indicator and controller shown when the user
  58.             // changes the device volume
  59.             return 20;
  60.         case TYPE_NAVIGATION_BAR:
  61.             // the navigation bar, if available, shows atop most things
  62.             return 21;
  63.         case TYPE_NAVIGATION_BAR_PANEL:
  64.             // some panels (e.g. search) need to show on top of the navigation bar
  65.             return 22;
  66.         case TYPE_SYSTEM_ERROR:
  67.             // system-level error dialogs
  68.             return 23;
  69.         case TYPE_MAGNIFICATION_OVERLAY:
  70.             // used to highlight the magnified portion of a display
  71.             return 24;
  72.         case TYPE_DISPLAY_OVERLAY:
  73.             // used to simulate secondary display devices
  74.             return 25;
  75.         case TYPE_DRAG:
  76.             // the drag layer: input for drag-and-drop is associated with this window,
  77.             // which sits above all other focusable windows
  78.             return 26;
  79.         case TYPE_ACCESSIBILITY_OVERLAY:
  80.             // overlay put by accessibility services to intercept user interaction
  81.             return 27;
  82.         case TYPE_SECURE_SYSTEM_OVERLAY:
  83.             return 28;
  84.         case TYPE_BOOT_PROGRESS:
  85.             return 29;
  86.         case TYPE_POINTER:
  87.             // the (mouse) pointer layer
  88.             return 30;
  89.         }
  90.         Log.e(TAG, "Unknown window type: " + type);
  91.         return 2;
  92.     }

這個方法很簡單就是根據類型返回一個基數。

WindowState中的成員變量mSubLayer只有在窗口是子窗口的時候纔有作用，它表示在窗口和父窗口之間的相對位置。代碼如下

  1.     public int subWindowTypeToLayerLw(int type) {
  2.         switch (type) {
  3.         case TYPE_APPLICATION_PANEL:
  4.         case TYPE_APPLICATION_ATTACHED_DIALOG:
  5.             return APPLICATION_PANEL_SUBLAYER;//等於1
  6.         case TYPE_APPLICATION_MEDIA:
  7.             return APPLICATION_MEDIA_SUBLAYER;//等於-2
  8.         case TYPE_APPLICATION_MEDIA_OVERLAY:
  9.             return APPLICATION_MEDIA_OVERLAY_SUBLAYER;//等於-1
  10.         case TYPE_APPLICATION_SUB_PANEL:
  11.             return APPLICATION_SUB_PANEL_SUBLAYER;//等於2
  12.         case TYPE_APPLICATION_ABOVE_SUB_PANEL:
  13.             return APPLICATION_ABOVE_SUB_PANEL_SUBLAYER;//等於3
  14.         }
  15.         Log.e(TAG, "Unknown sub-window type: " + type);
  16.         return 0;
  17.     }

理解了mBaseLayer和mSubLayer後，我們再來看看mLayer是如何計算出來的，是通過assignLayersLocked方法：

  1.     private final void assignLayersLocked(WindowList windows) {
  2.         int N = windows.size();
  3.         int curBaseLayer = 0;
  4.         int curLayer = 0;
  5.         int i;
  6.  
  7.         boolean anyLayerChanged = false;
  8.  
  9.         for (i=0; i<N; i++) {
  10.             final WindowState w = windows.get(i);
  11.             final WindowStateAnimator winAnimator = w.mWinAnimator;
  12.             boolean layerChanged = false;
  13.             int oldLayer = w.mLayer;
  14.             if (w.mBaseLayer == curBaseLayer || w.mIsImWindow
  15.                     || (i > 0 && w.mIsWallpaper)) {//如果窗口的mBaseLayer和前一個相同、或者是輸入法和壁紙窗口
  16.                 curLayer += WINDOW_LAYER_MULTIPLIER;
  17.                 w.mLayer = curLayer;
  18.             } else {
  19.                 curBaseLayer = curLayer = w.mBaseLayer;
  20.                 w.mLayer = curLayer;
  21.             }
  22.             if (w.mLayer != oldLayer) {//層級發生改變
  23.                 layerChanged = true;
  24.                 anyLayerChanged = true;
  25.             }
  26.             final AppWindowToken wtoken = w.mAppToken;
  27.             oldLayer = winAnimator.mAnimLayer;//後面都是調整mAnimLayerd的值
  28.             if (w.mTargetAppToken != null) {
  29.                 winAnimator.mAnimLayer =
  30.                         w.mLayer + w.mTargetAppToken.mAppAnimator.animLayerAdjustment;
  31.             } else if (wtoken != null) {
  32.                 winAnimator.mAnimLayer =
  33.                         w.mLayer + wtoken.mAppAnimator.animLayerAdjustment;
  34.             } else {
  35.                 winAnimator.mAnimLayer = w.mLayer;
  36.             }
  37.             if (w.mIsImWindow) {
  38.                 winAnimator.mAnimLayer += mInputMethodAnimLayerAdjustment;
  39.             } else if (w.mIsWallpaper) {
  40.                 winAnimator.mAnimLayer += mWallpaperAnimLayerAdjustment;
  41.             }
  42.             if (winAnimator.mAnimLayer != oldLayer) {
  43.                 layerChanged = true;
  44.                 anyLayerChanged = true;
  45.             }
  46.             final TaskStack stack = w.getStack();
  47.             if (layerChanged && stack != null && stack.isDimming(winAnimator)) {
  48.                 // Force an animation pass just to update the mDimLayer layer.
  49.                 scheduleAnimationLocked();
  50.             }
  51.         }
  52.  
  53.         if (mAccessibilityController != null && anyLayerChanged
  54.                 && windows.get(windows.size() - 1).getDisplayId() == Display.DEFAULT_DISPLAY) {
  55.             mAccessibilityController.onWindowLayersChangedLocked();
  56.         }
  57.     }

在調用assignLayersLocked函數之前，WindowList中的窗口其實已經排好序了，前面調用的函數addWindowToListInOrderLocked就是插入窗口到合適的位置，assignLayersLocked函數並不會改變窗口的位置，只是根據窗口的位置計算mLayer的值。

調整方法是從最底層的窗口開始，具有相同的mBaseLayer的值作爲一組，每組窗口的mLayer的值從mBaseLayer的值開始，依次加上WINDOW_LAYER_MULTIPLIER（等於5），這樣做的目的是在同層的窗口中每隔一個窗口就留下4個空位，方便下次插入新窗口。

這個方法還對輸入法和壁紙窗口做了特殊處理。這兩類窗口和它插入位置前面的窗口處於一個層級，而不是根據他們的mBaseLayer值計算。（就是前面說的當輸入法和壁紙出現是在當前Activity的窗口之間的）。

三、插入窗口的位置

在addWindow函數中我們會調用addAppWindowToListLocked來確定窗口的位置，現在我們來看下這個函數。

  1.     private void addWindowToListInOrderLocked(final WindowState win, boolean addToToken) {
  2.         if (win.mAttachedWindow == null) {//非子窗口
  3.             final WindowToken token = win.mToken;
  4.             int tokenWindowsPos = 0;
  5.             if (token.appWindowToken != null) {//應用窗口的頂層窗口
  6.                 tokenWindowsPos = addAppWindowToListLocked(win);
  7.             } else {
  8.                 addFreeWindowToListLocked(win);//系統窗口
  9.             }
  10.             if (addToToken) {
  11.                 if (DEBUG_ADD_REMOVE) Slog.v(TAG, "Adding " + win + " to " + token);
  12.                 token.windows.add(tokenWindowsPos, win);
  13.             }
  14.         } else {
  15.             addAttachedWindowToListLocked(win, addToToken);//添加子窗口
  16.         }
  17.  
  18.         if (win.mAppToken != null && addToToken) {
  19.             win.mAppToken.allAppWindows.add(win);
  20.         }
  21.     }

上面這個函數根據窗口的類型，應用頂層窗口，系統窗口，子窗口。

我們現在分別對這三類窗口的處理方法進行解析，先來看插入Activity頂層窗口的addAppWindowToListLocked

1.插入Activity頂層方法的addAppWindowToListLocked方法

addAppWindowToListLocked方法先判斷系統中是否存在和待插入的窗口是否有相同的Token,如果有代表它不是Activity的第一個窗口，因此再判斷這個窗口的類型是不是TYPE_BASE_APPLICATION，如果是這類窗口需要放在所有和它相同Token的窗口下面，否則在判斷這個應用的啓動窗口是否位於最前面（說明正在啓動），如果是放在啓動窗口的下面。如果不是下面兩種情況，則尋找同一應用中位置最高的窗口，然後插在它上面，這表示加入的窗口將覆蓋在前面的窗口之上。

下面是部分代碼，

  1.     private int addAppWindowToListLocked(final WindowState win) {
  2.         final IWindow client = win.mClient;
  3.         final WindowToken token = win.mToken;
  4.         final DisplayContent displayContent = win.getDisplayContent();
  5.         if (displayContent == null) {
  6.             // It doesn't matter this display is going away.
  7.             return 0;
  8.         }
  9.  
  10.         final WindowList windows = win.getWindowList();
  11.         final int N = windows.size();
  12.         WindowList tokenWindowList = getTokenWindowsOnDisplay(token, displayContent);
  13.         int tokenWindowsPos = 0;
  14.         int windowListPos = tokenWindowList.size();
  15.         if (!tokenWindowList.isEmpty()) {//如果有，說明它不是第一個窗口
  16.             // If this application has existing windows, we
  17.             // simply place the new window on top of them... but
  18.             // keep the starting window on top.
  19.             if (win.mAttrs.type == TYPE_BASE_APPLICATION) {//放在和它相同Token的窗口下面
  20.                 // Base windows go behind everything else.
  21.                 WindowState lowestWindow = tokenWindowList.get(0);//第一個0，代表最底層的window
  22.                 placeWindowBefore(lowestWindow, win);//放在這個window前面
  23.                 tokenWindowsPos = indexOfWinInWindowList(lowestWindow, token.windows);
  24.             } else {
  25.                 AppWindowToken atoken = win.mAppToken;
  26.                 WindowState lastWindow = tokenWindowList.get(windowListPos - 1);
  27.                 if (atoken != null && lastWindow == atoken.startingWindow) {
  28.                     placeWindowBefore(lastWindow, win);
  29.                     tokenWindowsPos = indexOfWinInWindowList(lastWindow, token.windows);
  30.                 } else {
  31.                     int newIdx = findIdxBasedOnAppTokens(win);//尋找同一token位置最前面的window
  32.                     //there is a window above this one associated with the same
  33.                     //apptoken note that the window could be a floating window
  34.                     //that was created later or a window at the top of the list of
  35.                     //windows associated with this token.
  36.                     windows.add(newIdx + 1, win);//插在它前面
  37.                     if (newIdx < 0) {
  38.                         // No window from token found on win's display.
  39.                         tokenWindowsPos = 0;
  40.                     } else {
  41.                         tokenWindowsPos = indexOfWinInWindowList(
  42.                                 windows.get(newIdx), token.windows) + 1;
  43.                     }
  44.                     mWindowsChanged = true;
  45.                 }
  46.             }
  47.             return tokenWindowsPos;
  48.         }

我們再來看幾個函數

placeWindowBefore函數就是插入到windows這個位置前

  1.     private void placeWindowBefore(WindowState pos, WindowState window) {
  2.         final WindowList windows = pos.getWindowList();
  3.         int i = windows.indexOf(pos);
  4.         if (i < 0) {
  5.             Slog.w(TAG, "placeWindowBefore: Unable to find " + pos + " in " + windows);
  6.             i = 0;
  7.         }
  8.         windows.add(i, window);
  9.         mWindowsChanged = true;
  10.     }

findIdxBasedOnAppTokens函數就是尋找相同token的最前面的window，所以要注意遍歷循環的時候是從window的size最大的時候反過來遍歷的。

  1.     private int findIdxBasedOnAppTokens(WindowState win) {
  2.         WindowList windows = win.getWindowList();
  3.         for(int j = windows.size() - 1; j >= 0; j--) {
  4.             WindowState wentry = windows.get(j);
  5.             if(wentry.mAppToken == win.mAppToken) {
  6.                 return j;
  7.             }
  8.         }
  9.         return -1;
  10.     }


繼續看這個函數，如果系統中不存在和窗口具有相同token的窗口（說明Activity剛啓動，第一個窗口還沒有創建完成），這時就會遍歷系統所有的task以及task中包含的AppWindowToken，找到窗口的位置，再在task中排在本窗口前面的窗口中，找出離自己最近的，並且APPWindowToken的窗口列表不爲NULL的窗口，插入到它的最後一個子窗口後面。如果前面的窗口的列表也都爲NULL，則尋找排在本窗口後面的第一個包含有窗口對象的APPWindowToken，把本窗口插在前面。

  1.         WindowState pos = null;
  2.  
  3.         final ArrayList<Task> tasks = displayContent.getTasks();
  4.         int taskNdx;
  5.         int tokenNdx = -1;
  6.         for (taskNdx = tasks.size() - 1; taskNdx >= 0; --taskNdx) {
  7.             AppTokenList tokens = tasks.get(taskNdx).mAppTokens;
  8.             for (tokenNdx = tokens.size() - 1; tokenNdx >= 0; --tokenNdx) {
  9.                 final AppWindowToken t = tokens.get(tokenNdx);
  10.                 if (t == token) {
  11.                     --tokenNdx;
  12.                     if (tokenNdx < 0) {
  13.                         --taskNdx;
  14.                         if (taskNdx >= 0) {
  15.                             tokenNdx = tasks.get(taskNdx).mAppTokens.size() - 1;
  16.                         }
  17.                     }
  18.                     break;
  19.                 }
  20.  
  21.                 // We haven't reached the token yet; if this token
  22.                 // is not going to the bottom and has windows on this display, we can
  23.                 // use it as an anchor for when we do reach the token.
  24.                 tokenWindowList = getTokenWindowsOnDisplay(t, displayContent);
  25.                 if (!t.sendingToBottom && tokenWindowList.size() > 0) {
  26.                     pos = tokenWindowList.get(0);
  27.                 }
  28.             }
  29.             if (tokenNdx >= 0) {
  30.                 // early exit
  31.                 break;
  32.             }
  33.         }
  34.  
  35.         // We now know the index into the apps.  If we found
  36.         // an app window above, that gives us the position; else
  37.         // we need to look some more.
  38.         if (pos != null) {
  39.             // Move behind any windows attached to this one.
  40.             WindowToken atoken = mTokenMap.get(pos.mClient.asBinder());
  41.             if (atoken != null) {
  42.                 tokenWindowList =
  43.                         getTokenWindowsOnDisplay(atoken, displayContent);
  44.                 final int NC = tokenWindowList.size();
  45.                 if (NC > 0) {
  46.                     WindowState bottom = tokenWindowList.get(0);
  47.                     if (bottom.mSubLayer < 0) {
  48.                         pos = bottom;
  49.                     }
  50.                 }
  51.             }
  52.             placeWindowBefore(pos, win);
  53.             return tokenWindowsPos;
  54.         }
  55.  
  56.         // Continue looking down until we find the first
  57.         // token that has windows on this display.
  58.         for ( ; taskNdx >= 0; --taskNdx) {
  59.             AppTokenList tokens = tasks.get(taskNdx).mAppTokens;
  60.             for ( ; tokenNdx >= 0; --tokenNdx) {
  61.                 final AppWindowToken t = tokens.get(tokenNdx);
  62.                 tokenWindowList = getTokenWindowsOnDisplay(t, displayContent);
  63.                 final int NW = tokenWindowList.size();
  64.                 if (NW > 0) {
  65.                     pos = tokenWindowList.get(NW-1);
  66.                     break;
  67.                 }
  68.             }
  69.             if (tokenNdx >= 0) {
  70.                 // found
  71.                 break;
  72.             }
  73.         }
  74.  
  75.         if (pos != null) {
  76.             // Move in front of any windows attached to this
  77.             // one.
  78.             WindowToken atoken = mTokenMap.get(pos.mClient.asBinder());
  79.             if (atoken != null) {
  80.                 final int NC = atoken.windows.size();
  81.                 if (NC > 0) {
  82.                     WindowState top = atoken.windows.get(NC-1);
  83.                     if (top.mSubLayer >= 0) {
  84.                         pos = top;
  85.                     }
  86.                 }
  87.             }
  88.             placeWindowAfter(pos, win);
  89.             return tokenWindowsPos;
  90.         }
  91.  
  92.         ......

如果前面窗口的APPWindowToken的窗口列表也爲空，則重新遍歷整個窗口，然後根據mBaseLayer的值來確定窗口的位置。

  1.         final int myLayer = win.mBaseLayer;
  2.         int i;
  3.         for (i = N - 1; i >= 0; --i) {
  4.             WindowState w = windows.get(i);
  5.             if (w.mBaseLayer <= myLayer) {
  6.                 break;
  7.             }
  8.         }
  9.         if (DEBUG_FOCUS_LIGHT || DEBUG_WINDOW_MOVEMENT || DEBUG_ADD_REMOVE) Slog.v(TAG,
  10.                 "Based on layer: Adding window " + win + " at " + (i + 1) + " of " + N);
  11.         windows.add(i + 1, win);
  12.         mWindowsChanged = true;
  13.         return tokenWindowsPos;


2. 插入子窗口的addAttachedWindowToListLocked函數

addAttachedWindowToListLocked方法，如果mSubLayer大於0的子窗口，按mSubLayer的值大小插入到有相同WindowToken的子窗口的合適位置中，如果mSubLayer相同，插入已插入窗口的下層位置，如果mSubLayer小於0，如果還存在mSubLayer小於0，並且大於等於該窗口的mSubLayer的值的子窗口，則插入到該子窗口之下，否則插入到子窗口所依附的窗口下面。

  1.     private void addAttachedWindowToListLocked(final WindowState win, boolean addToToken) {
  2.         final WindowToken token = win.mToken;
  3.         final DisplayContent displayContent = win.getDisplayContent();
  4.         if (displayContent == null) {
  5.             return;
  6.         }
  7.         final WindowState attached = win.mAttachedWindow;
  8.  
  9.         WindowList tokenWindowList = getTokenWindowsOnDisplay(token, displayContent);
  10.  
  11.         // Figure out this window's ordering relative to the window
  12.         // it is attached to.
  13.         final int NA = tokenWindowList.size();
  14.         final int sublayer = win.mSubLayer;
  15.         int largestSublayer = Integer.MIN_VALUE;
  16.         WindowState windowWithLargestSublayer = null;
  17.         int i;
  18.         for (i = 0; i < NA; i++) {
  19.             WindowState w = tokenWindowList.get(i);
  20.             final int wSublayer = w.mSubLayer;
  21.             if (wSublayer >= largestSublayer) {
  22.                 largestSublayer = wSublayer;
  23.                 windowWithLargestSublayer = w;
  24.             }
  25.             if (sublayer < 0) {
  26.                 // For negative sublayers, we go below all windows
  27.                 // in the same sublayer.
  28.                 if (wSublayer >= sublayer) {
  29.                     if (addToToken) {
  30.                         if (DEBUG_ADD_REMOVE) Slog.v(TAG, "Adding " + win + " to " + token);
  31.                         token.windows.add(i, win);
  32.                     }
  33.                     placeWindowBefore(wSublayer >= 0 ? attached : w, win);
  34.                     break;
  35.                 }
  36.             } else {
  37.                 // For positive sublayers, we go above all windows
  38.                 // in the same sublayer.
  39.                 if (wSublayer > sublayer) {
  40.                     if (addToToken) {
  41.                         if (DEBUG_ADD_REMOVE) Slog.v(TAG, "Adding " + win + " to " + token);
  42.                         token.windows.add(i, win);
  43.                     }
  44.                     placeWindowBefore(w, win);
  45.                     break;
  46.                 }
  47.             }
  48.         }
  49.         if (i >= NA) {
  50.             if (addToToken) {
  51.                 if (DEBUG_ADD_REMOVE) Slog.v(TAG, "Adding " + win + " to " + token);
  52.                 token.windows.add(win);
  53.             }
  54.             if (sublayer < 0) {
  55.                 placeWindowBefore(attached, win);
  56.             } else {
  57.                 placeWindowAfter(largestSublayer >= 0
  58.                                  ? windowWithLargestSublayer
  59.                                  : attached,
  60.                                  win);
  61.             }
  62.         }
  63.     }


3.插入系統窗口的addFreeWindowToListLocked

addFreeWindowToListLocked方法簡單，只是遍歷同一顯示設備上的Windows，比較mBaseLayer值的大小，插入合適位置。

  1.     private void addFreeWindowToListLocked(final WindowState win) {
  2.         final WindowList windows = win.getWindowList();
  3.  
  4.         // Figure out where window should go, based on layer.
  5.         final int myLayer = win.mBaseLayer;
  6.         int i;
  7.         for (i = windows.size() - 1; i >= 0; i--) {
  8.             if (windows.get(i).mBaseLayer <= myLayer) {
  9.                 break;
  10.             }
  11.         }
  12.         i++;
  13.         if (DEBUG_FOCUS_LIGHT || DEBUG_WINDOW_MOVEMENT || DEBUG_ADD_REMOVE) Slog.v(TAG,
  14.                 "Free window: Adding window " + win + " at " + i + " of " + windows.size());
  15.         windows.add(i, win);
  16.         mWindowsChanged = true;
  17.     }



這篇博客我們分析了window插入到什麼位置，以及mLayer的計算。但是具體裏面有很多變量，stack task windows等，不是很熟悉，下篇博客我們主要分析這。




發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

golang調用python實戰

簡介 go-python Python提供了豐富的C-API。而C和Go又可以通過cgo無縫集成。所以，直接通過Golang調用libpython，就可以實現Go調Python的功能了。但是過程比較複雜，而go-python提供了針對CPy

雲棲號資訊小編 2020-09-03 11:13:56

iOS中製作動態鏈接庫Framework

這幾天在做個SDK遇到了很多問題，現在做完了想把製作Framework的過程分享出來（我這個SDK中也包含了其他的第三方很多Framework,所以踩了很多坑） 首先需要創建個Framework工程： 然後會有個“工程名.h”文件,有這

一步一迹 2020-07-07 12:41:01

Android 7.1 APP 啓動流程分析

本文是基於 Android 7.1 系統進行探討的. 我們都知道Launcher 其實也是一個APP ,安裝好的應用的快捷方式都被放在了Launcher中.很多的廠家或者廠商都在定製自己的Launcher,目前我們知道Android現在使

ChaoLi_Chen 2020-07-06 11:14:13

Android 7.1 系統 部分功能修改 彙總

1.修改藍牙爲從端  device/qcom/msmxxx/system.prop //設置成從模式 persist.service.bt.a2dp.sink=true persist.service.bt.hfp.client=tru

ChaoLi_Chen 2020-07-06 11:14:13

Android權限系統（二）：開機授予運行時權限

DefaultPermissionGrantPolicy簡介 .  Android開機後，除了根據上次開機的記錄（runtime-permissions.xml）授予運行時權限外，一些系統重要的組件也需要提前授予運行時權限。例如，

Invoker123 2020-07-03 13:00:21

Android權限系統（一）：開機獲取權限信息

一.SystemConfig的整機權限信息   Android在SystemConfig的構造函數中會通過讀取相關的文件來加載整機的權限信息。這些文件是{partition}/etc/permissions下面的文件。其中{par

Invoker123 2020-07-03 13:00:21

XMPP通信

IOS開發，OC和Swift語言對照，XMPP通信的實現： 一、導入XMPP框架 下載 XMPPFramework 框架  GitHub: XMPPFramework 導入依賴框架  CocoaLumberjack :

邵楠1990 2020-07-03 08:17:09

Android 加載鍵盤佈局文件過程

Andriod啓動過程中是如何正確加載.kl和.kcm的鍵盤佈局文件？本文就從Honeycomb代碼入手，詳細介紹開機啓動時鍵盤佈局文件的加載過程。 Honeycom相較與之前的版本，加入了一個.idc後綴的配置文件，使在不修改系統代碼

lininglive 2020-07-03 00:51:53

Android6.0 旋轉屏幕（二）旋轉設備

上篇博客中我們一直提到updateRotationUnchecked函數，這篇博客我們就來分析下這個函數，這個函數可以說是旋轉屏幕的一個核心函數，我們主要看下updateRotationUncheckedLocked和sendN

jiangnan2222 2020-06-29 07:28:53

Android6.0 WMS（五） WMS計算Activity窗口大小的過程分析（一）應用進程

這篇文章很多參考博客：http://blog.csdn.net/luoshengyang/article/details/8479101/ 一、窗口簡介  在Android系統中，Activity窗口的大小是由WindowM

jiangnan2222 2020-06-29 07:28:53

Android6.0 WMS（四） WMS中常用變量分析

這篇博客我們分析WMS的一些常用變量，我們依然從主線addWindow開始分析，碰到一些常用的變量再進行分析。 DisplayContent 我們再來看如下DisplayContent 類 final

jiangnan2222 2020-06-29 07:28:53

Android6.0 WMS（二） WMS創建窗口與創建Surface的關係

在上篇博客我們知道ViewRootImpl的setView函數會調用WindowSession的addToDisplay函數，這個函數通過Binder最終會調用WMS的addWindow函數，增加窗口。在http://blog.

jiangnan2222 2020-06-29 07:28:53

Android6.0 WMS（一） WMS和應用進程的關係

之前在分析Activity的時候有很多和WMS相關的，我們這裏再簡單總結下和WMS相關的那部分。 一、appToken在WMS中創建 在博客http://blog.csdn.net/kc58236582/article/det

jiangnan2222 2020-06-29 07:28:53

Intelhaxm安裝失敗

Android模擬器啓動不了了？AS識別不了Genymotion了？   網上對這些問題有各種各樣的處理方法，我都試過但是沒有用。後來發現，最根本的原因是intelhaxm-android.exe（Hardware Acceler

jiejingguo 2020-06-26 10:00:18

ActivityRecord、ActivityClientRecord、Activity的關係

  在閱讀Activity啓動流程的源碼時遇到了ActivityRecord和ActivityClientRecord，那麼它們兩個和Activity有什麼關係呢？ 結論   ActivityRecord、ActivityClie

jiejingguo 2020-06-26 10:00:15