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