content: /*
   * Copyright (C) 2015 The Android Open Source Project
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package com.android.layoutlib.bridge.impl;
  
  import com.android.ide.common.rendering.api.HardwareConfig;
  import com.android.ide.common.rendering.api.RenderResources;
  import com.android.ide.common.rendering.api.ResourceNamespace;
  import com.android.ide.common.rendering.api.ResourceReference;
  import com.android.ide.common.rendering.api.ResourceValue;
  import com.android.ide.common.rendering.api.SessionParams;
  import com.android.layoutlib.bridge.Bridge;
  import com.android.layoutlib.bridge.android.BridgeContext;
  import com.android.layoutlib.bridge.android.RenderParamsFlags;
  import com.android.layoutlib.bridge.bars.AppCompatActionBar;
  import com.android.layoutlib.bridge.bars.BridgeActionBar;
  import com.android.layoutlib.bridge.bars.Config;
  import com.android.layoutlib.bridge.bars.FrameworkActionBar;
  import com.android.layoutlib.bridge.bars.NavigationBar;
  import com.android.layoutlib.bridge.bars.StatusBar;
  import com.android.layoutlib.bridge.bars.TitleBar;
  import com.android.resources.Density;
  import com.android.resources.ResourceType;
  import com.android.resources.ScreenOrientation;
  
  import android.annotation.NonNull;
  import android.annotation.Nullable;
  import android.graphics.Color;
  import android.graphics.drawable.Drawable;
  import android.util.DisplayMetrics;
  import android.util.TypedValue;
  import android.view.AttachInfo_Accessor;
  import android.view.View;
  import android.view.ViewRootImpl;
  import android.view.ViewRootImpl_Accessor;
  import android.widget.FrameLayout;
  import android.widget.LinearLayout;
  import android.widget.RelativeLayout;
  
  import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
  import static android.view.ViewGroup.LayoutParams.WRAP_CONTENT;
  import static android.widget.LinearLayout.VERTICAL;
  import static com.android.layoutlib.bridge.impl.ResourceHelper.getBooleanThemeFrameworkAttrValue;
  import static com.android.layoutlib.bridge.impl.ResourceHelper.getBooleanThemeValue;
  
  /**
   * The Layout used to create the system decor.
   * <p>
   * The layout inflated will contain a content frame where the user's layout can be inflated.
   * <pre>
   *  +-------------------------------------------------+---+
   *  | Status bar                                      | N |
   *  +-------------------------------------------------+ a |
   *  | Title/Framework Action bar (optional)           | v |
   *  +-------------------------------------------------+   |
   *  | AppCompat Action bar (optional)                 |   |
   *  +-------------------------------------------------+   |
   *  | Content, vertical extending                     | b |
   *  |                                                 | a |
   *  |                                                 | r |
   *  +-------------------------------------------------+---+
   * </pre>
   * or
   * <pre>
   *  +--------------------------------------+
   *  | Status bar                           |
   *  +--------------------------------------+
   *  | Title/Framework Action bar (optional)|
   *  +--------------------------------------+
   *  | AppCompat Action bar (optional)      |
   *  +--------------------------------------+
   *  | Content, vertical extending          |
   *  |                                      |
   *  |                                      |
   *  +--------------------------------------+
   *  | Nav bar                              |
   *  +--------------------------------------+
   * </pre>
   */
  class Layout extends FrameLayout {
  
      // Theme attributes used for configuring appearance of the system decor.
      private static final String ATTR_WINDOW_FLOATING = "windowIsFloating";
      private static final String ATTR_WINDOW_BACKGROUND = "windowBackground";
      private static final String ATTR_WINDOW_FULL_SCREEN = "windowFullscreen";
      private static final String ATTR_NAV_BAR_HEIGHT = "navigation_bar_height";
      private static final String ATTR_NAV_BAR_WIDTH = "navigation_bar_width";
      private static final String ATTR_STATUS_BAR_HEIGHT = "status_bar_height";
      private static final String ATTR_WINDOW_ACTION_BAR = "windowActionBar";
      private static final String ATTR_ACTION_BAR_SIZE = "actionBarSize";
      private static final String ATTR_WINDOW_NO_TITLE = "windowNoTitle";
      private static final String ATTR_WINDOW_TITLE_SIZE = "windowTitleSize";
      private static final String ATTR_WINDOW_TRANSLUCENT_STATUS = StatusBar.ATTR_TRANSLUCENT;
      private static final String ATTR_WINDOW_TRANSLUCENT_NAV = NavigationBar.ATTR_TRANSLUCENT;
  
      // Default sizes
      private static final int DEFAULT_STATUS_BAR_HEIGHT = 25;
      private static final int DEFAULT_TITLE_BAR_HEIGHT = 25;
      private static final int DEFAULT_NAV_BAR_SIZE = 48;
  
      // Ids assigned to components created. This is so that we can refer to other components in
      // layout params.
      private static final String ID_NAV_BAR = "navBar";
      private static final String ID_STATUS_BAR = "statusBar";
      private static final String ID_APP_COMPAT_ACTION_BAR = "appCompatActionBar";
      private static final String ID_FRAMEWORK_BAR = "frameworkBar";
      // Prefix used with the above ids in order to make them unique in framework namespace.
      private static final String ID_PREFIX = "android_layoutlib_";
  
      /**
       * Temporarily store the builder so that it doesn't have to be passed to all methods used
       * during inflation.
       */
      private Builder mBuilder;
  
      /**
       * SysUI layout
       */
      private RelativeLayout mSysUiRoot;
  
      /**
       * This holds user's layout.
       */
      private FrameLayout mContentRoot;
  
      public Layout(@NonNull Builder builder) {
          super(builder.mContext);
  
          mBuilder = builder;
          View frameworkActionBar = null;
          View appCompatActionBar = null;
          TitleBar titleBar = null;
          StatusBar statusBar = null;
          NavigationBar navBar = null;
  
          if (builder.mWindowBackground != null) {
              Drawable d = ResourceHelper.getDrawable(builder.mWindowBackground, builder.mContext);
              setBackground(d);
          }
  
          int simulatedPlatformVersion = getParams().getSimulatedPlatformVersion();
          HardwareConfig hwConfig = getParams().getHardwareConfig();
          Density density = hwConfig.getDensity();
          boolean isRtl = Bridge.isLocaleRtl(getParams().getLocale());
          setLayoutDirection(isRtl ? LAYOUT_DIRECTION_RTL : LAYOUT_DIRECTION_LTR);
  
          if (mBuilder.hasNavBar()) {
              navBar = createNavBar(getContext(), density, isRtl, getParams().isRtlSupported(),
                      simulatedPlatformVersion, false);
          }
  
          if (builder.hasStatusBar()) {
              statusBar = createStatusBar(getContext(), density, isRtl, getParams().isRtlSupported(),
                      simulatedPlatformVersion);
          }
  
          if (mBuilder.hasAppCompatActionBar()) {
              BridgeActionBar bar = createActionBar(getContext(), getParams(), true);
              mContentRoot = bar.getContentRoot();
              appCompatActionBar = bar.getRootView();
          }
  
          // Title bar must appear on top of the Action bar
          if (mBuilder.hasTitleBar()) {
              titleBar = createTitleBar(getContext(), getParams().getAppLabel(),
                      simulatedPlatformVersion);
          } else if (mBuilder.hasFrameworkActionBar()) {
              BridgeActionBar bar = createActionBar(getContext(), getParams(), false);
              if(mContentRoot == null) {
                  // We only set the content root if the AppCompat action bar did not already
                  // provide it
                  mContentRoot = bar.getContentRoot();
              }
              frameworkActionBar = bar.getRootView();
          }
  
          mSysUiRoot = new RelativeLayout(builder.mContext);
          addSystemUiViews(titleBar, mContentRoot == null ? (mContentRoot = createContentFrame()) : frameworkActionBar,
                  statusBar, navBar, appCompatActionBar);
          addView(mSysUiRoot);
          //addView(createSysUiOverlay(mBuilder.mContext));
          // Done with the builder. Don't hold a reference to it.
          mBuilder = null;
      }
  
      @NonNull
      private static View createSysUiOverlay(@NonNull BridgeContext context) {
          SysUiOverlay overlay =  new SysUiOverlay(context, 20, 10, 50, 40, 60);
          overlay.setNotchColor(Color.BLACK);
          overlay.setLayoutParams(new FrameLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT));
          return overlay;
      }
  
      @NonNull
      private FrameLayout createContentFrame() {
          FrameLayout contentRoot = new FrameLayout(getContext());
          RelativeLayout.LayoutParams params = createSysUiLayoutParams(MATCH_PARENT, MATCH_PARENT);
          int rule = mBuilder.isNavBarVertical() ? RelativeLayout.START_OF : RelativeLayout.ABOVE;
          if (mBuilder.hasSolidNavBar()) {
              params.addRule(rule, getId(ID_NAV_BAR));
          }
          int below = -1;
          if (mBuilder.mAppCompatActionBarSize > 0) {
              below = getId(ID_APP_COMPAT_ACTION_BAR);
          } else if (mBuilder.hasFrameworkActionBar() || mBuilder.hasTitleBar()) {
              below = getId(ID_FRAMEWORK_BAR);
          } else if (mBuilder.hasSolidStatusBar()) {
              below = getId(ID_STATUS_BAR);
          }
          if (below != -1) {
              params.addRule(RelativeLayout.BELOW, below);
          }
          contentRoot.setLayoutParams(params);
          return contentRoot;
      }
  
      @NonNull
      private RelativeLayout.LayoutParams createSysUiLayoutParams(int width, int height) {
          DisplayMetrics metrics = getContext().getResources().getDisplayMetrics();
          if (width > 0) {
              width = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, width, metrics);
          }
          if (height > 0) {
              height = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, height, metrics);
          }
          return new RelativeLayout.LayoutParams(width, height);
      }
  
      @NonNull
      public FrameLayout getContentRoot() {
          return mContentRoot;
      }
  
      @NonNull
      private SessionParams getParams() {
          return mBuilder.mParams;
      }
  
      @NonNull
      @Override
      public BridgeContext getContext() {
          return (BridgeContext) super.getContext();
      }
  
      /**
       * @param isRtl whether the current locale is an RTL locale.
       * @param isRtlSupported whether the applications supports RTL (i.e. has supportsRtl=true in the
       * manifest and targetSdkVersion >= 17.
       */
      @NonNull
      private StatusBar createStatusBar(BridgeContext context, Density density, boolean isRtl,
              boolean isRtlSupported, int simulatedPlatformVersion) {
          StatusBar statusBar =
                  new StatusBar(context, density, isRtl, isRtlSupported, simulatedPlatformVersion);
          RelativeLayout.LayoutParams params = createSysUiLayoutParams(MATCH_PARENT, mBuilder
                  .mStatusBarSize);
          if (mBuilder.isNavBarVertical()) {
              params.addRule(RelativeLayout.START_OF, getId(ID_NAV_BAR));
          }
          statusBar.setLayoutParams(params);
          statusBar.setId(getId(ID_STATUS_BAR));
          return statusBar;
      }
  
      private BridgeActionBar createActionBar(@NonNull BridgeContext context,
              @NonNull SessionParams params, boolean appCompatActionBar) {
          boolean isMenu = "menu".equals(params.getFlag(RenderParamsFlags.FLAG_KEY_ROOT_TAG));
          String id;
  
          // For the framework action bar, we set the height to MATCH_PARENT only if there is no
          // AppCompat ActionBar below it
          int heightRule = appCompatActionBar || !mBuilder.hasAppCompatActionBar() ? MATCH_PARENT :
            WRAP_CONTENT;
          RelativeLayout.LayoutParams layoutParams = createSysUiLayoutParams(MATCH_PARENT, heightRule);
          int rule = mBuilder.isNavBarVertical() ? RelativeLayout.START_OF : RelativeLayout.ABOVE;
          if (mBuilder.hasSolidNavBar()) {
              // If there
              if(rule == RelativeLayout.START_OF || appCompatActionBar || !mBuilder.hasAppCompatActionBar()) {
                  layoutParams.addRule(rule, getId(ID_NAV_BAR));
              }
          }
  
  
          BridgeActionBar actionBar;
          if (appCompatActionBar && !isMenu) {
              actionBar = new AppCompatActionBar(context, params);
              id = ID_APP_COMPAT_ACTION_BAR;
  
              if (mBuilder.hasTitleBar() || mBuilder.hasFrameworkActionBar()) {
                  layoutParams.addRule(RelativeLayout.BELOW, getId(ID_FRAMEWORK_BAR));
              } else if (mBuilder.hasSolidStatusBar()) {
                  layoutParams.addRule(RelativeLayout.BELOW, getId(ID_STATUS_BAR));
              }
          } else {
              actionBar = new FrameworkActionBar(context, params);
              id = ID_FRAMEWORK_BAR;
              if (mBuilder.hasSolidStatusBar()) {
                  layoutParams.addRule(RelativeLayout.BELOW, getId(ID_STATUS_BAR));
              }
          }
  
          actionBar.getRootView().setLayoutParams(layoutParams);
          actionBar.getRootView().setId(getId(id));
          actionBar.createMenuPopup();
          return actionBar;
      }
  
      @NonNull
      private TitleBar createTitleBar(BridgeContext context, String title,
              int simulatedPlatformVersion) {
          TitleBar titleBar = new TitleBar(context, title, simulatedPlatformVersion);
          RelativeLayout.LayoutParams params = createSysUiLayoutParams(MATCH_PARENT, mBuilder.mTitleBarSize);
          if (mBuilder.hasSolidStatusBar()) {
              params.addRule(RelativeLayout.BELOW, getId(ID_STATUS_BAR));
          }
          if (mBuilder.isNavBarVertical() && mBuilder.hasSolidNavBar()) {
              params.addRule(RelativeLayout.START_OF, getId(ID_NAV_BAR));
          }
          titleBar.setLayoutParams(params);
          titleBar.setId(getId(ID_FRAMEWORK_BAR));
          return titleBar;
      }
  
      /**
       * @param isRtl whether the current locale is an RTL locale.
       * @param isRtlSupported whether the applications supports RTL (i.e. has supportsRtl=true in the
       * manifest and targetSdkVersion >= 17.
       */
      @NonNull
      private NavigationBar createNavBar(BridgeContext context, Density density, boolean isRtl,
              boolean isRtlSupported, int simulatedPlatformVersion, boolean isQuickStepEnabled) {
          int orientation = mBuilder.mNavBarOrientation;
          int size = mBuilder.mNavBarSize;
          // Only allow quickstep in the latest version or >= 28
          isQuickStepEnabled = isQuickStepEnabled &&
                  (simulatedPlatformVersion == 0 || simulatedPlatformVersion >= 28);
          NavigationBar navBar =
                  new NavigationBar(context, density, orientation, isRtl, isRtlSupported,
                          simulatedPlatformVersion, isQuickStepEnabled);
          boolean isVertical = mBuilder.isNavBarVertical();
          int w = isVertical ? size : MATCH_PARENT;
          int h = isVertical ? MATCH_PARENT : size;
          RelativeLayout.LayoutParams params = createSysUiLayoutParams(w, h);
          params.addRule(isVertical ? RelativeLayout.ALIGN_PARENT_END : RelativeLayout.ALIGN_PARENT_BOTTOM);
          navBar.setLayoutParams(params);
          navBar.setId(getId(ID_NAV_BAR));
          return navBar;
      }
  
      private void addSystemUiViews(@NonNull View... views) {
          for (View view : views) {
              if (view != null) {
                  mSysUiRoot.addView(view);
              }
          }
      }
  
      private int getId(String name) {
          return Bridge.getResourceId(ResourceType.ID, ID_PREFIX + name);
      }
  
      @SuppressWarnings("deprecation")
      @Override
      public void requestFitSystemWindows() {
          // The framework call would usually bubble up to ViewRootImpl but, in layoutlib, Layout will
          // act as view root for most purposes. That way, we can also save going through the Handler
          // to dispatch the new applied insets.
          ViewRootImpl root = AttachInfo_Accessor.getRootView(this);
          if (root != null) {
              ViewRootImpl_Accessor.dispatchApplyInsets(root, this);
          }
      }
  
      /**
       * A helper class to help initialize the Layout.
       */
      static class Builder {
          @NonNull
          private final SessionParams mParams;
          @NonNull
          private final BridgeContext mContext;
          private final RenderResources mResources;
  
          private final boolean mWindowIsFloating;
          private ResourceValue mWindowBackground;
          private int mStatusBarSize;
          private int mNavBarSize;
          private int mNavBarOrientation;
          private int mAppCompatActionBarSize;
          private int mFrameworkActionBarSize;
          private int mTitleBarSize;
          private boolean mTranslucentStatus;
          private boolean mTranslucentNav;
  
          public Builder(@NonNull SessionParams params, @NonNull BridgeContext context) {
              mParams = params;
              mContext = context;
              mResources = mParams.getResources();
              mWindowIsFloating =
                      getBooleanThemeFrameworkAttrValue(mResources, ATTR_WINDOW_FLOATING, true);
  
              findBackground();
  
              if (!mParams.isForceNoDecor()) {
                  findStatusBar();
                  findFrameworkBar();
                  findAppCompatActionBar();
                  findNavBar();
              }
          }
  
          private void findBackground() {
              if (!mParams.isBgColorOverridden()) {
                  mWindowBackground = mResources.findItemInTheme(
                          BridgeContext.createFrameworkAttrReference(ATTR_WINDOW_BACKGROUND));
                  mWindowBackground = mResources.resolveResValue(mWindowBackground);
              }
          }
  
          private void findStatusBar() {
              boolean windowFullScreen =
                      getBooleanThemeFrameworkAttrValue(mResources, ATTR_WINDOW_FULL_SCREEN, false);
              if (!windowFullScreen && !mWindowIsFloating) {
                  mStatusBarSize =
                          getFrameworkAttrDimension(ATTR_STATUS_BAR_HEIGHT, DEFAULT_STATUS_BAR_HEIGHT);
                  mTranslucentStatus =
                          getBooleanThemeFrameworkAttrValue(
                                  mResources, ATTR_WINDOW_TRANSLUCENT_STATUS, false);
              }
          }
  
          /**
           * The behavior is different whether the App is using AppCompat or not.
           * <h1>With App compat :</h1>
           * <li> framework ("android:") attributes have to effect
           * <li> windowNoTile=true hides the AppCompatActionBar
           * <li> windowActionBar=false throws an exception
           */
          private void findAppCompatActionBar() {
              if (mWindowIsFloating || !mContext.isAppCompatTheme()) {
                  return;
              }
  
              boolean windowNoTitle =
                      getBooleanThemeValue(mResources,
                              mContext.createAppCompatAttrReference(ATTR_WINDOW_NO_TITLE), false);
  
              boolean windowActionBar =
                      getBooleanThemeValue(mResources,
                              mContext.createAppCompatAttrReference(ATTR_WINDOW_ACTION_BAR), true);
  
              if (!windowNoTitle && windowActionBar) {
                  mAppCompatActionBarSize =
                          getDimension(mContext.createAppCompatAttrReference(ATTR_ACTION_BAR_SIZE),
                                  DEFAULT_TITLE_BAR_HEIGHT);
              }
          }
  
          /**
           * Find if we should show either the titleBar or the framework ActionBar
           * <p>
           * <h1> Without App compat :</h1>
           * <li> windowNoTitle has no effect
           * <li> android:windowNoTile=true hides the <b>ActionBar</b>
           * <li> android:windowActionBar=true/false toggles between ActionBar/TitleBar
           * </ul>
           * <pre>
           * +------------------------------------------------------------+
           * |               |         android:windowNoTitle              |
           * |android:       |    TRUE             |      FALSE           |
           * |windowActionBar|---------------------+----------------------+
           * |    TRUE       | Nothing             | ActionBar (Default)  |
           * |    FALSE      | Nothing             | TitleBar             |
           * +---------------+--------------------------------------------+
           * </pre>
           *
           * @see #findAppCompatActionBar()
           */
          private void findFrameworkBar() {
              if (mWindowIsFloating) {
                  return;
              }
              boolean frameworkWindowNoTitle =
                      getBooleanThemeFrameworkAttrValue(mResources, ATTR_WINDOW_NO_TITLE, false);
  
              // Check if an actionbar is needed
              boolean isMenu = "menu".equals(mParams.getFlag(RenderParamsFlags.FLAG_KEY_ROOT_TAG));
  
              boolean windowActionBar =
                      getBooleanThemeFrameworkAttrValue(mResources, ATTR_WINDOW_ACTION_BAR, true);
  
              if (!frameworkWindowNoTitle || isMenu) {
                  if (isMenu || windowActionBar) {
                      mFrameworkActionBarSize =
                              getFrameworkAttrDimension(ATTR_ACTION_BAR_SIZE, DEFAULT_TITLE_BAR_HEIGHT);
                  } else {
                      mTitleBarSize = getDimension(
                              mContext.createAppCompatAttrReference(ATTR_WINDOW_TITLE_SIZE),
                              DEFAULT_TITLE_BAR_HEIGHT);
                  }
              }
          }
  
          private void findNavBar() {
              if (hasSoftwareButtons() && !mWindowIsFloating) {
                  // get orientation
                  HardwareConfig hwConfig = mParams.getHardwareConfig();
                  boolean barOnBottom = true;
  
                  if (hwConfig.getOrientation() == ScreenOrientation.LANDSCAPE) {
                      int shortSize = hwConfig.getScreenHeight();
                      int shortSizeDp = shortSize * DisplayMetrics.DENSITY_DEFAULT /
                              hwConfig.getDensity().getDpiValue();
  
                      // 0-599dp: "phone" UI with bar on the side
                      // 600+dp: "tablet" UI with bar on the bottom
                      barOnBottom = shortSizeDp >= 600;
                  }
  
                  mNavBarOrientation = barOnBottom ? LinearLayout.HORIZONTAL : VERTICAL;
                  mNavBarSize =
                          getFrameworkAttrDimension(
                                  barOnBottom ? ATTR_NAV_BAR_HEIGHT : ATTR_NAV_BAR_WIDTH,
                                  DEFAULT_NAV_BAR_SIZE);
                  mTranslucentNav =
                          getBooleanThemeFrameworkAttrValue(mResources, ATTR_WINDOW_TRANSLUCENT_NAV,
                                  false);
              }
          }
  
          @SuppressWarnings("SameParameterValue")
          private int getDimension(@NonNull ResourceReference attrRef, int defaultValue) {
              ResourceValue value = mResources.findItemInTheme(attrRef);
              value = mResources.resolveResValue(value);
              if (value != null) {
                  TypedValue typedValue = ResourceHelper.getValue(attrRef.getName(), value.getValue(),
                          true);
                  if (typedValue != null) {
                      return (int) typedValue.getDimension(mContext.getMetrics());
                  }
              }
              return defaultValue;
          }
  
          @SuppressWarnings("SameParameterValue")
          private int getFrameworkAttrDimension(@NonNull String attr, int defaultValue) {
              return getDimension(BridgeContext.createFrameworkAttrReference(attr), defaultValue);
          }
  
          private boolean hasSoftwareButtons() {
              return mParams.getHardwareConfig().hasSoftwareButtons();
          }
  
          /**
           * Returns true if the nav bar is present and not translucent.
           */
          private boolean hasSolidNavBar() {
              return hasNavBar() && !mTranslucentNav;
          }
  
          /**
           * Returns true if the status bar is present and not translucent.
           */
          private boolean hasSolidStatusBar() {
              return hasStatusBar() && !mTranslucentStatus;
          }
  
          private boolean hasNavBar() {
              return Config.showOnScreenNavBar(mParams.getSimulatedPlatformVersion()) &&
                      hasSoftwareButtons() && mNavBarSize > 0;
          }
  
          private boolean hasTitleBar() {
              return mTitleBarSize > 0;
          }
  
          private boolean hasStatusBar() {
              return mStatusBarSize > 0;
          }
  
          private boolean hasAppCompatActionBar() {
              return mAppCompatActionBarSize > 0;
          }
  
          /**
           * Return true if the nav bar is present and is vertical.
           */
          private boolean isNavBarVertical() {
              return hasNavBar() && mNavBarOrientation == VERTICAL;
          }
  
          private boolean hasFrameworkActionBar() {
              return mFrameworkActionBarSize > 0;
          }
  
          private boolean hasNotch() {
              return !mParams.isForceNoDecor();
          }
      }
  }
  