devbox
笔触狂放9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

窗口大小计算之androidp Test_layoutwindowlw

作者：笔触狂放9 | 2024-03-27 21:36:16

赞

踩

layoutwindowlw

  1.  
  2.     /** {@inheritDoc} */
  3.     @Override
  4.     public void layoutWindowLw(WindowState win, WindowState attached, DisplayFrames displayFrames) {
  5.         // We've already done the navigation bar, status bar, and all screen decor windows. If the
  6.         // status bar can receive input, we need to layout it again to accommodate for the IME
  7.         // window. //不处理状态栏，NavigationBar，以及mScreenDecorWindows包含的装饰WindowState，因为在begin中已经处理了
  8.         if ((win == mStatusBar && !canReceiveInput(win)) || win == mNavigationBar
  9.                 || mScreenDecorWindows.contains(win)) {
  10.             return;
  11.         }
  12. 	  Slog.d("layoutWL:", "win  =" + win.mDisplayWidth + " =" + win.mDisplayHeight
  13.                + " =" + win.mRotation + " =" + win.mRotation);
  14.         final WindowManager.LayoutParams attrs = win.getAttrs();
  15.         final boolean isDefaultDisplay = win.isDefaultDisplay();
  16.         final boolean needsToOffsetInputMethodTarget = isDefaultDisplay &&
  17.                 (win == mLastInputMethodTargetWindow && mLastInputMethodWindow != null);
  18.         if (needsToOffsetInputMethodTarget) {
  19.             if (DEBUG_LAYOUT) Slog.i(TAG, "Offset ime target window by the last ime window state");
  20.             offsetInputMethodWindowLw(mLastInputMethodWindow, displayFrames);
  21.         }
  22.  
  23.         final int type = attrs.type;
  24.         final int fl = PolicyControl.getWindowFlags(win, attrs);
  25.         final int pfl = attrs.privateFlags;
  26.         final int sim = attrs.softInputMode;
  27.         final int requestedSysUiFl = PolicyControl.getSystemUiVisibility(null, attrs);
  28.         final int sysUiFl = requestedSysUiFl | getImpliedSysUiFlagsForLayout(attrs);
  29. // WindowManager: Compute frame com.coagent.launcher/com.coagent.launcher.MainActivity: 
  30. //sim=#120 attach=null type=1 flags=0x89810100 pf=[0,0][1280,480] df=[0,0][1280,480] of=[0,0][1280,480] 
  31. //cf=[96,0][1280,480] vf=[96,0][1280,480] dcf=[0,0][1280,480] sf=[96,0][1280,480] osf=null  
  32.         final Rect pf = mTmpParentFrame; //初始化当前的区域
  33.         final Rect df = mTmpDisplayFrame;
  34.         final Rect of = mTmpOverscanFrame;
  35.         final Rect cf = mTmpContentFrame;
  36.         final Rect vf = mTmpVisibleFrame;
  37.         final Rect dcf = mTmpDecorFrame;
  38.         final Rect sf = mTmpStableFrame;
  39.         Rect osf = null;
  40.         dcf.setEmpty();
  41.  
  42.         final boolean hasNavBar = (isDefaultDisplay && mHasNavigationBar
  43.                 && mNavigationBar != null && mNavigationBar.isVisibleLw());
  44.  
  45.         final int adjust = sim & SOFT_INPUT_MASK_ADJUST;
  46.  
  47.         final boolean requestedFullscreen = (fl & FLAG_FULLSCREEN) != 0
  48.                 || (requestedSysUiFl & View.SYSTEM_UI_FLAG_FULLSCREEN) != 0;
  49.  
  50.         final boolean layoutInScreen = (fl & FLAG_LAYOUT_IN_SCREEN) == FLAG_LAYOUT_IN_SCREEN;
  51.         final boolean layoutInsetDecor = (fl & FLAG_LAYOUT_INSET_DECOR) == FLAG_LAYOUT_INSET_DECOR;
  52.  
  53.         sf.set(displayFrames.mStable);
  54. 如果当前是输入法区域，所有区域先设置为输入对应的mDock区域
  55.         if (type == TYPE_INPUT_METHOD) {
  56.             vf.set(displayFrames.mDock);  //mDock=Rect(96, 0 - 1280, 480)
  57.             cf.set(displayFrames.mDock);
  58.             of.set(displayFrames.mDock);
  59.             df.set(displayFrames.mDock);
  60.             pf.set(displayFrames.mDock);
  61.             // IM dock windows layout below the nav bar...
  62.             pf.bottom = df.bottom = of.bottom = displayFrames.mUnrestricted.bottom;
  63.             // ...with content insets above the nav bar
  64.             cf.bottom = vf.bottom = displayFrames.mStable.bottom;
  65.             if (mStatusBar != null && mFocusedWindow == mStatusBar && canReceiveInput(mStatusBar)) {
  66.                 // The status bar forces the navigation bar while it's visible. Make sure the IME
  67.                 // avoids the navigation bar in that case. //状态栏上的输入法，需要减去导航在左、右的位置
  68.                 if (mNavigationBarPosition == NAV_BAR_RIGHT) {
  69.                     pf.right = df.right = of.right = cf.right = vf.right =
  70.                             displayFrames.mStable.right;
  71.                 } else if (mNavigationBarPosition == NAV_BAR_LEFT) {
  72.                     pf.left = df.left = of.left = cf.left = vf.left = displayFrames.mStable.left;
  73.                 }
  74.             }
  75.             // IM dock windows always go to the bottom of the screen.
  76.             attrs.gravity = Gravity.BOTTOM;
  77.             mDockLayer = win.getSurfaceLayer();
  78.         } else if (type == TYPE_VOICE_INTERACTION) {
  79.             of.set(displayFrames.mUnrestricted);
  80.             df.set(displayFrames.mUnrestricted);
  81.             pf.set(displayFrames.mUnrestricted);
  82.             if (adjust != SOFT_INPUT_ADJUST_RESIZE) {
  83.                 cf.set(displayFrames.mDock); // mDock=Rect(96, 0 - 1280, 480)
  84.             } else {
  85.                 cf.set(displayFrames.mContent); //mContent=Rect(96, 0 - 1280, 260)
  86.             }
  87.             if (adjust != SOFT_INPUT_ADJUST_NOTHING) {
  88.                 vf.set(displayFrames.mCurrent);   //mCurrent=Rect(96, 0 - 1280, 171)
  89.             } else {
  90.                 vf.set(cf);
  91.             }
  92.         } else if (type == TYPE_WALLPAPER) {
  93.            layoutWallpaper(displayFrames, pf, df, of, cf);
  94.         } else if (win == mStatusBar) {
  95.             of.set(displayFrames.mUnrestricted);
  96.             df.set(displayFrames.mUnrestricted);
  97.             pf.set(displayFrames.mUnrestricted);
  98.             cf.set(displayFrames.mStable);
  99.             vf.set(displayFrames.mStable);
  100.  
  101.             if (adjust == SOFT_INPUT_ADJUST_RESIZE) {
  102.                 cf.bottom = displayFrames.mContent.bottom;
  103.             } else {
  104.                 cf.bottom = displayFrames.mDock.bottom;
  105.                 vf.bottom = displayFrames.mContent.bottom;
  106.             }
  107.         } else { //其他(如Activity,Dialog对应的窗口(PhoneWindow),或者启动窗口等等。内容型窗口
  108.             dcf.set(displayFrames.mSystem);
  109.             final boolean inheritTranslucentDecor =
  110.                     (attrs.privateFlags & PRIVATE_FLAG_INHERIT_TRANSLUCENT_DECOR) != 0;
  111.             final boolean isAppWindow =
  112.                     type >= FIRST_APPLICATION_WINDOW && type <= LAST_APPLICATION_WINDOW;
  113.             final boolean topAtRest =
  114.                     win == mTopFullscreenOpaqueWindowState && !win.isAnimatingLw();
  115.             if (isAppWindow && !inheritTranslucentDecor && !topAtRest) {
  116.                 if ((sysUiFl & View.SYSTEM_UI_FLAG_FULLSCREEN) == 0
  117.                         && (fl & FLAG_FULLSCREEN) == 0
  118.                         && (fl & FLAG_TRANSLUCENT_STATUS) == 0
  119.                         && (fl & FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS) == 0  //沉浸式状态栏、导航栏
  120.                         && (pfl & PRIVATE_FLAG_FORCE_DRAW_STATUS_BAR_BACKGROUND) == 0) {
  121.                     // Ensure policy decor includes status bar
  122.                     dcf.top = displayFrames.mStable.top;
  123.                 }
  124.                 if ((fl & FLAG_TRANSLUCENT_NAVIGATION) == 0
  125.                         && (sysUiFl & View.SYSTEM_UI_FLAG_HIDE_NAVIGATION) == 0
  126.                         && (fl & FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS) == 0) {  //非沉浸式状态栏、导航栏
  127.                     // Ensure policy decor includes navigation bar  ，decor包括navicd 
  128.                     dcf.bottom = displayFrames.mStable.bottom; //mStable是不包括状态栏和navi的
  129.                     dcf.right = displayFrames.mStable.right;
  130.                 }
  131.             }
  132.  
  133.             if (layoutInScreen && layoutInsetDecor) { //非全屏窗口
  134.                 if (DEBUG_LAYOUT) Slog.v(TAG, "layoutWindowLw(" + attrs.getTitle()
  135.                             + "): IN_SCREEN, INSET_DECOR");
  136.                 // This is the case for a normal activity window: we want it to cover all of the
  137.                 // screen space, and it can take care of moving its contents to account for screen
  138.                 // decorations that intrude into that space.
  139.                 if (attached != null) { //win所描述的一个非全屏的Activity窗口附加在其它窗口上，有父窗口
  140.                     // If this window is attached to another, our display
  141.                     // frame is the same as the one we are attached to.
  142.                     setAttachedWindowFrames(win, fl, adjust, attached, true, pf, df, of, cf, vf,
  143.                             displayFrames);
  144.                 } else {
  145.                     if (type == TYPE_STATUS_BAR_PANEL || type == TYPE_STATUS_BAR_SUB_PANEL) {
  146.                         // Status bar panels are the only windows who can go on top of the status
  147.                         // bar. They are protected by the STATUS_BAR_SERVICE permission, so they
  148.                         // have the same privileges as the status bar itself.
  149.                         //
  150.                         // However, they should still dodge the navigation bar if it exists.
  151.  
  152.                         pf.left = df.left = of.left = hasNavBar
  153.                                 ? displayFrames.mDock.left : displayFrames.mUnrestricted.left;
  154.                         pf.top = df.top = of.top = displayFrames.mUnrestricted.top;  //top，没有Navi在顶部的，只能在左右下
  155.                         pf.right = df.right = of.right = hasNavBar
  156.                                 ? displayFrames.mRestricted.right
  157.                                 : displayFrames.mUnrestricted.right;
  158.                         pf.bottom = df.bottom = of.bottom = hasNavBar
  159.                                 ? displayFrames.mRestricted.bottom
  160.                                 : displayFrames.mUnrestricted.bottom;
  161.  
  162.                         if (DEBUG_LAYOUT) Slog.v(TAG, String.format(
  163.                                         "Laying out status bar window: (%d,%d - %d,%d)",
  164.                                         pf.left, pf.top, pf.right, pf.bottom));
  165.                     } else if ((fl & FLAG_LAYOUT_IN_OVERSCAN) != 0
  166.                             && type >= FIRST_APPLICATION_WINDOW && type <= LAST_SUB_WINDOW) {
  167.                         // Asking to layout into the overscan region, so give it that pure
  168.                         // unrestricted area.
  169.                         of.set(displayFrames.mOverscan);
  170.                         df.set(displayFrames.mOverscan);
  171.                         pf.set(displayFrames.mOverscan);
  172.                     } else if (canHideNavigationBar()
  173.                             && (sysUiFl & View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION) != 0
  174.                             && (type >= FIRST_APPLICATION_WINDOW && type <= LAST_SUB_WINDOW
  175.                             || type == TYPE_VOLUME_OVERLAY)) {
  176.                         // Asking for layout as if the nav bar is hidden, lets the application
  177.                         // extend into the unrestricted overscan screen area. We only do this for
  178.                         // application windows and certain system windows to ensure no window that
  179.                         // can be above the nav bar can do this.
  180.                         df.set(displayFrames.mOverscan);
  181.                         pf.set(displayFrames.mOverscan);
  182.                         // We need to tell the app about where the frame inside the overscan is, so
  183.                         // it can inset its content by that amount -- it didn't ask to actually
  184.                         // extend itself into the overscan region.
  185.                         of.set(displayFrames.mUnrestricted);
  186.                     } else {
  187.                         df.set(displayFrames.mRestrictedOverscan);
  188.                         pf.set(displayFrames.mRestrictedOverscan);
  189.                         // We need to tell the app about where the frame inside the overscan
  190.                         // is, so it can inset its content by that amount -- it didn't ask
  191.                         // to actually extend itself into the overscan region.
  192.                         of.set(displayFrames.mUnrestricted);
  193.                     }
  194.  
  195.                     if ((fl & FLAG_FULLSCREEN) == 0) {
  196.                         if (win.isVoiceInteraction()) {
  197.                             cf.set(displayFrames.mVoiceContent);
  198.                         } else {
  199.                             if (adjust != SOFT_INPUT_ADJUST_RESIZE) {  //不是缩小，要么被IME覆盖，要么向上移动PAN标志时
  200.                                 cf.set(displayFrames.mDock);
  201.                             } else {
  202.                                 cf.set(displayFrames.mContent);
  203.                             }
  204.                         }
  205.                     } else {
  206.                         // Full screen windows are always given a layout that is as if the status
  207.                         // bar and other transient decors are gone. This is to avoid bad states when
  208.                         // moving from a window that is not hiding the status bar to one that is.
  209.                         cf.set(displayFrames.mRestricted);
  210.                     }
  211.                     applyStableConstraints(sysUiFl, fl, cf, displayFrames);
  212.                     if (adjust != SOFT_INPUT_ADJUST_NOTHING) {
  213.                         vf.set(displayFrames.mCurrent);
  214.                     } else {
  215.                         vf.set(cf);
  216.                     }
  217.                 }
  218.             } else if (layoutInScreen || (sysUiFl
  219.                     & (View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
  220.                             | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION)) != 0) {
  221.                 if (DEBUG_LAYOUT) Slog.v(TAG, "layoutWindowLw(" + attrs.getTitle()
  222.                         + "): IN_SCREEN");
  223.                 // A window that has requested to fill the entire screen just
  224.                 // gets everything, period.
  225.                 if (type == TYPE_STATUS_BAR_PANEL || type == TYPE_STATUS_BAR_SUB_PANEL) {
  226.                     cf.set(displayFrames.mUnrestricted);
  227.                     of.set(displayFrames.mUnrestricted);
  228.                     df.set(displayFrames.mUnrestricted);
  229.                     pf.set(displayFrames.mUnrestricted);
  230.                     if (hasNavBar) {
  231.                         pf.left = df.left = of.left = cf.left = displayFrames.mDock.left;
  232.                         pf.right = df.right = of.right = cf.right = displayFrames.mRestricted.right;
  233.                         pf.bottom = df.bottom = of.bottom = cf.bottom =
  234.                                 displayFrames.mRestricted.bottom;
  235.                     }
  236.                     if (DEBUG_LAYOUT) Slog.v(TAG, String.format(
  237.                             "Laying out IN_SCREEN status bar window: (%d,%d - %d,%d)",
  238.                             pf.left, pf.top, pf.right, pf.bottom));
  239.                 } else if (type == TYPE_NAVIGATION_BAR || type == TYPE_NAVIGATION_BAR_PANEL) {
  240.                     // The navigation bar has Real Ultimate Power.
  241.                     of.set(displayFrames.mUnrestricted);
  242.                     df.set(displayFrames.mUnrestricted);
  243.                     pf.set(displayFrames.mUnrestricted);
  244.                     if (DEBUG_LAYOUT) Slog.v(TAG, String.format(
  245.                                     "Laying out navigation bar window: (%d,%d - %d,%d)",
  246.                                     pf.left, pf.top, pf.right, pf.bottom));
  247.                 } else if ((type == TYPE_SECURE_SYSTEM_OVERLAY || type == TYPE_SCREENSHOT)
  248.                         && ((fl & FLAG_FULLSCREEN) != 0)) {
  249.                     // Fullscreen secure system overlays get what they ask for. Screenshot region
  250.                     // selection overlay should also expand to full screen.
  251.                     cf.set(displayFrames.mOverscan);
  252.                     of.set(displayFrames.mOverscan);
  253.                     df.set(displayFrames.mOverscan);
  254.                     pf.set(displayFrames.mOverscan);
  255.                 } else if (type == TYPE_BOOT_PROGRESS) {
  256.                     // Boot progress screen always covers entire display.
  257.                     cf.set(displayFrames.mOverscan);
  258.                     of.set(displayFrames.mOverscan);
  259.                     df.set(displayFrames.mOverscan);
  260.                     pf.set(displayFrames.mOverscan);
  261.                 } else if ((fl & FLAG_LAYOUT_IN_OVERSCAN) != 0
  262.                         && type >= FIRST_APPLICATION_WINDOW && type <= LAST_SUB_WINDOW) {
  263.                     // Asking to layout into the overscan region, so give it that pure unrestricted
  264.                     // area.
  265.                     cf.set(displayFrames.mOverscan);
  266.                     of.set(displayFrames.mOverscan);
  267.                     df.set(displayFrames.mOverscan);
  268.                     pf.set(displayFrames.mOverscan);
  269.                 } else if (canHideNavigationBar()
  270.                         && (sysUiFl & View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION) != 0
  271.                         && (type == TYPE_STATUS_BAR
  272.                             || type == TYPE_TOAST
  273.                             || type == TYPE_DOCK_DIVIDER
  274.                             || type == TYPE_VOICE_INTERACTION_STARTING
  275.                             || (type >= FIRST_APPLICATION_WINDOW && type <= LAST_SUB_WINDOW))) {
  276.                     // Asking for layout as if the nav bar is hidden, lets the
  277.                     // application extend into the unrestricted screen area.  We
  278.                     // only do this for application windows (or toasts) to ensure no window that
  279.                     // can be above the nav bar can do this.
  280.                     // XXX This assumes that an app asking for this will also
  281.                     // ask for layout in only content.  We can't currently figure out
  282.                     // what the screen would be if only laying out to hide the nav bar.
  283.                     cf.set(displayFrames.mUnrestricted);
  284.                     of.set(displayFrames.mUnrestricted);
  285.                     df.set(displayFrames.mUnrestricted);
  286.                     pf.set(displayFrames.mUnrestricted);
  287.                 } else if ((sysUiFl & View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN) != 0) {
  288.                     of.set(displayFrames.mRestricted);
  289.                     df.set(displayFrames.mRestricted);
  290.                     pf.set(displayFrames.mRestricted);
  291.                     if (adjust != SOFT_INPUT_ADJUST_RESIZE) {
  292.                         cf.set(displayFrames.mDock);
  293.                     } else {
  294.                     }
  295.                 } else {
  296.                     cf.set(displayFrames.mRestricted);
  297.                     of.set(displayFrames.mRestricted);
  298.                     df.set(displayFrames.mRestricted);
  299.                     pf.set(displayFrames.mRestricted);
  300.                 }
  301.  
  302.                 applyStableConstraints(sysUiFl, fl, cf,displayFrames);
  303.  
  304.                 if (adjust != SOFT_INPUT_ADJUST_NOTHING) {
  305.                     vf.set(displayFrames.mCurrent);
  306.                 } else {
  307.                     vf.set(cf);
  308.                 }
  309.             } else if (attached != null) {
  310.                 if (DEBUG_LAYOUT) Slog.v(TAG, "layoutWindowLw(" + attrs.getTitle()
  311.                         + "): attached to " + attached);
  312.                 // A child window should be placed inside of the same visible
  313.                 // frame that its parent had.
  314.                 setAttachedWindowFrames(win, fl, adjust, attached, false, pf, df, of, cf, vf,
  315.                         displayFrames);
  316.             } else {
  317.                 if (DEBUG_LAYOUT) Slog.v(TAG, "layoutWindowLw(" + attrs.getTitle() +
  318.                         "): normal window");
  319.                 // Otherwise, a normal window must be placed inside the content
  320.                 // of all screen decorations.
  321.                 if (type == TYPE_STATUS_BAR_PANEL) {
  322.                     // Status bar panels can go on
  323.                     // top of the status bar. They are protected by the STATUS_BAR_SERVICE
  324.                     // permission, so they have the same privileges as the status bar itself.
  325.                     cf.set(displayFrames.mRestricted);
  326.                     of.set(displayFrames.mRestricted);
  327.                     df.set(displayFrames.mRestricted);
  328.                     pf.set(displayFrames.mRestricted);
  329.                 } else if (type == TYPE_TOAST || type == TYPE_SYSTEM_ALERT) {
  330.                     // These dialogs are stable to interim decor changes.
  331.                     cf.set(displayFrames.mStable);
  332.                     of.set(displayFrames.mStable);
  333.                     df.set(displayFrames.mStable);
  334.                     pf.set(displayFrames.mStable);
  335.                 } else {
  336.                     pf.set(displayFrames.mContent);
  337.                     if (win.isVoiceInteraction()) {
  338.                         cf.set(displayFrames.mVoiceContent);
  339.                         of.set(displayFrames.mVoiceContent);
  340.                         df.set(displayFrames.mVoiceContent);
  341.                     } else if (adjust != SOFT_INPUT_ADJUST_RESIZE
  342.                         cf.set(displayFrames.mContent);) {
  343.                         cf.set(displayFrames.mDock);
  344.                         of.set(displayFrames.mDock);  //包括IME区域，以被IME遮挡
  345.                         df.set(displayFrames.mDock);
  346.                     } else {
  347.                         cf.set(displayFrames.mContent); 
  348.                         of.set(displayFrames.mContent);
  349.                         df.set(displayFrames.mContent);
  350.                     }
  351.                     if (adjust != SOFT_INPUT_ADJUST_NOTHING) {
  352.                         vf.set(displayFrames.mCurrent); //不包括IME
  353.                     } else {
  354.                         vf.set(cf);
  355.                     }
  356.                 }
  357.             }
  358.         }
  359.  
  360.         boolean parentFrameWasClippedByDisplayCutout = false;
  361.         final int cutoutMode = attrs.layoutInDisplayCutoutMode;
  362.         final boolean attachedInParent = attached != null && !layoutInScreen;
  363.         final boolean requestedHideNavigation =
  364.                 (requestedSysUiFl & View.SYSTEM_UI_FLAG_HIDE_NAVIGATION) != 0;
  365.  
  366.         // TYPE_BASE_APPLICATION windows are never considered floating here because they don't get
  367.         // cropped / shifted to the displayFrame in WindowState.
  368.         final boolean floatingInScreenWindow = !attrs.isFullscreen() && layoutInScreen
  369.                 && type != TYPE_BASE_APPLICATION;
  370.  
  371.         // Ensure that windows with a DEFAULT or NEVER display cutout mode are laid out in
  372.         // the cutout safe zone.
  373.         if (cutoutMode != LAYOUT_IN_DISPLAY_CUTOUT_MODE_ALWAYS) {
  374.             final Rect displayCutoutSafeExceptMaybeBars = mTmpDisplayCutoutSafeExceptMaybeBarsRect;
  375.             displayCutoutSafeExceptMaybeBars.set(displayFrames.mDisplayCutoutSafe);
  376.             if (layoutInScreen && layoutInsetDecor && !requestedFullscreen
  377.                     && cutoutMode == LAYOUT_IN_DISPLAY_CUTOUT_MODE_DEFAULT) {
  378.                 // At the top we have the status bar, so apps that are
  379.                 // LAYOUT_IN_SCREEN | LAYOUT_INSET_DECOR but not FULLSCREEN
  380.                 // already expect that there's an inset there and we don't need to exclude
  381.                 // the window from that area.
  382.                 displayCutoutSafeExceptMaybeBars.top = Integer.MIN_VALUE;
  383.             }
  384.             if (layoutInScreen && layoutInsetDecor && !requestedHideNavigation
  385.                     && cutoutMode == LAYOUT_IN_DISPLAY_CUTOUT_MODE_DEFAULT) {
  386.                 // Same for the navigation bar.
  387.                 switch (mNavigationBarPosition) {
  388.                     case NAV_BAR_BOTTOM:
  389.                         displayCutoutSafeExceptMaybeBars.bottom = Integer.MAX_VALUE;
  390.                         break;
  391.                     case NAV_BAR_RIGHT:
  392.                         displayCutoutSafeExceptMaybeBars.right = Integer.MAX_VALUE;
  393.                         break;
  394.                     case NAV_BAR_LEFT:
  395.                         displayCutoutSafeExceptMaybeBars.left = Integer.MIN_VALUE;
  396.                         break;
  397.                 }
  398.             }
  399.             if (type == TYPE_INPUT_METHOD && mNavigationBarPosition == NAV_BAR_BOTTOM) {
  400.                 // The IME can always extend under the bottom cutout if the navbar is there.
  401.                 displayCutoutSafeExceptMaybeBars.bottom = Integer.MAX_VALUE;
  402.             }
  403.             // Windows that are attached to a parent and laid out in said parent already avoid
  404.             // the cutout according to that parent and don't need to be further constrained.
  405.             // Floating IN_SCREEN windows get what they ask for and lay out in the full screen.
  406.             // They will later be cropped or shifted using the displayFrame in WindowState,
  407.             // which prevents overlap with the DisplayCutout.
  408.             if (!attachedInParent && !floatingInScreenWindow) {
  409.                 mTmpRect.set(pf);
  410.                 pf.intersectUnchecked(displayCutoutSafeExceptMaybeBars);
  411.                 parentFrameWasClippedByDisplayCutout |= !mTmpRect.equals(pf);
  412.             }
  413.             // Make sure that NO_LIMITS windows clipped to the display don't extend under the
  414.             // cutout.
  415.             df.intersectUnchecked(displayCutoutSafeExceptMaybeBars);
  416.         }
  417.  
  418.         // Content should never appear in the cutout.
  419.         cf.intersectUnchecked(displayFrames.mDisplayCutoutSafe);
  420.  
  421.         // TYPE_SYSTEM_ERROR is above the NavigationBar so it can't be allowed to extend over it.
  422.         // Also, we don't allow windows in multi-window mode to extend out of the screen.
  423.         if ((fl & FLAG_LAYOUT_NO_LIMITS) != 0 && type != TYPE_SYSTEM_ERROR  //范围无限制FLAG_LAYOUT_NO_LIMITS
  424.                 && !win.isInMultiWindowMode()) {
  425.             df.left = df.top = -10000;
  426.             df.right = df.bottom = 10000;
  427.             if (type != TYPE_WALLPAPER) {
  428.                 of.left = of.top = cf.left = cf.top = vf.left = vf.top = -10000;
  429.                 of.right = of.bottom = cf.right = cf.bottom = vf.right = vf.bottom = 10000;
  430.             }
  431.         }
  432.  
  433.         // If the device has a chin (e.g. some watches), a dead area at the bottom of the screen we
  434.         // need to provide information to the clients that want to pretend that you can draw there.
  435.         // We only want to apply outsets to certain types of windows. For example, we never want to
  436.         // apply the outsets to floating dialogs, because they wouldn't make sense there.
  437.         final boolean useOutsets = shouldUseOutsets(attrs, fl);
  438.         if (isDefaultDisplay && useOutsets) {
  439.             osf = mTmpOutsetFrame;
  440.             osf.set(cf.left, cf.top, cf.right, cf.bottom);
  441.             int outset = ScreenShapeHelper.getWindowOutsetBottomPx(mContext.getResources());
  442.             if (outset > 0) {
  443.                 int rotation = displayFrames.mRotation;
  444.                 if (rotation == Surface.ROTATION_0) {
  445.                     osf.bottom += outset;
  446.                 } else if (rotation == Surface.ROTATION_90) {
  447.                     osf.right += outset;
  448.                 } else if (rotation == Surface.ROTATION_180) {
  449.                     osf.top -= outset;
  450.                 } else if (rotation == Surface.ROTATION_270) {
  451.                     osf.left -= outset;
  452.                 }
  453.                 if (DEBUG_LAYOUT) Slog.v(TAG, "applying bottom outset of " + outset
  454.                         + " with rotation " + rotation + ", result: " + osf);
  455.             }
  456.         }
  457. //logcat | grep -e mNavigationBar  -e "Status bar" -e "mDock rect" -e  "Compute frame"
  458. 		Printer printer = new LogPrinter(Log.ERROR, “tag”);  
  459. 		displayFrames.dump("layoutWL:", printer);
  460.  
  461.         if (DEBUG_LAYOUT) Slog.v(TAG, "Compute frame " + attrs.getTitle()
  462.                 + ": sim=#" + Integer.toHexString(sim)
  463.                 + " attach=" + attached + " type=" + type
  464.                 + String.format(" flags=0x%08x", fl)
  465.                 + " pf=" + pf.toShortString() + " df=" + df.toShortString()
  466.                 + " of=" + of.toShortString()
  467.                 + " cf=" + cf.toShortString() + " vf=" + vf.toShortString()
  468.                 + " dcf=" + dcf.toShortString()
  469.                 + " sf=" + sf.toShortString()
  470.                 + " osf=" + (osf == null ? "null" : osf.toShortString()));
  471.  
  472.         win.computeFrameLw(pf, df, of, cf, vf, dcf, sf, osf, displayFrames.mDisplayCutout,
  473.                 parentFrameWasClippedByDisplayCutout);
  474.         // Dock windows carve out the bottom of the screen, so normal windows
  475.         // can't appear underneath them.
  476.         if (type == TYPE_INPUT_METHOD && win.isVisibleLw()
  477.                 && !win.getGivenInsetsPendingLw()) {  //不是正在addWindow IME没有更新setInsetWindow
  478.             setLastInputMethodWindowLw(null, null);
  479.             offsetInputMethodWindowLw(win, displayFrames);
  480.         }
  481.         if (type == TYPE_VOICE_INTERACTION && win.isVisibleLw()
  482.                 && !win.getGivenInsetsPendingLw()) {
  483.             offsetVoiceInputWindowLw(win, displayFrames);
  484.         }
  485.     }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/327118
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号