content: /*
   * Copyright (C) 2017 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.server.policy;
  
  import static android.view.WindowManager.LayoutParams.FIRST_APPLICATION_WINDOW;
  import static android.view.WindowManager.LayoutParams.LAST_APPLICATION_WINDOW;
  import static android.view.WindowManager.LayoutParams.TYPE_ACCESSIBILITY_OVERLAY;
  import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_ABOVE_SUB_PANEL;
  import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_ATTACHED_DIALOG;
  import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_MEDIA;
  import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_MEDIA_OVERLAY;
  import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY;
  import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_PANEL;
  import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_SUB_PANEL;
  import static android.view.WindowManager.LayoutParams.TYPE_BOOT_PROGRESS;
  import static android.view.WindowManager.LayoutParams.TYPE_DISPLAY_OVERLAY;
  import static android.view.WindowManager.LayoutParams.TYPE_DOCK_DIVIDER;
  import static android.view.WindowManager.LayoutParams.TYPE_DRAG;
  import static android.view.WindowManager.LayoutParams.TYPE_DREAM;
  import static android.view.WindowManager.LayoutParams.TYPE_INPUT_CONSUMER;
  import static android.view.WindowManager.LayoutParams.TYPE_INPUT_METHOD;
  import static android.view.WindowManager.LayoutParams.TYPE_INPUT_METHOD_DIALOG;
  import static android.view.WindowManager.LayoutParams.TYPE_KEYGUARD_DIALOG;
  import static android.view.WindowManager.LayoutParams.TYPE_MAGNIFICATION_OVERLAY;
  import static android.view.WindowManager.LayoutParams.TYPE_NAVIGATION_BAR;
  import static android.view.WindowManager.LayoutParams.TYPE_NAVIGATION_BAR_PANEL;
  import static android.view.WindowManager.LayoutParams.TYPE_PHONE;
  import static android.view.WindowManager.LayoutParams.TYPE_POINTER;
  import static android.view.WindowManager.LayoutParams.TYPE_PRESENTATION;
  import static android.view.WindowManager.LayoutParams.TYPE_PRIORITY_PHONE;
  import static android.view.WindowManager.LayoutParams.TYPE_PRIVATE_PRESENTATION;
  import static android.view.WindowManager.LayoutParams.TYPE_QS_DIALOG;
  import static android.view.WindowManager.LayoutParams.TYPE_SCREENSHOT;
  import static android.view.WindowManager.LayoutParams.TYPE_SEARCH_BAR;
  import static android.view.WindowManager.LayoutParams.TYPE_SECURE_SYSTEM_OVERLAY;
  import static android.view.WindowManager.LayoutParams.TYPE_STATUS_BAR;
  import static android.view.WindowManager.LayoutParams.TYPE_STATUS_BAR_PANEL;
  import static android.view.WindowManager.LayoutParams.TYPE_STATUS_BAR_SUB_PANEL;
  import static android.view.WindowManager.LayoutParams.TYPE_SYSTEM_ALERT;
  import static android.view.WindowManager.LayoutParams.TYPE_SYSTEM_DIALOG;
  import static android.view.WindowManager.LayoutParams.TYPE_SYSTEM_ERROR;
  import static android.view.WindowManager.LayoutParams.TYPE_SYSTEM_OVERLAY;
  import static android.view.WindowManager.LayoutParams.TYPE_TOAST;
  import static android.view.WindowManager.LayoutParams.TYPE_VOICE_INTERACTION;
  import static android.view.WindowManager.LayoutParams.TYPE_VOICE_INTERACTION_STARTING;
  import static android.view.WindowManager.LayoutParams.TYPE_VOLUME_OVERLAY;
  import static android.view.WindowManager.LayoutParams.TYPE_WALLPAPER;
  import static android.view.WindowManager.LayoutParams.isSystemAlertWindowType;
  
  import static java.lang.annotation.RetentionPolicy.SOURCE;
  
  import android.annotation.IntDef;
  import android.annotation.NonNull;
  import android.annotation.Nullable;
  import android.app.WindowConfiguration;
  import android.content.Context;
  import android.content.res.CompatibilityInfo;
  import android.content.res.Configuration;
  import android.graphics.Rect;
  import android.os.Bundle;
  import android.os.IBinder;
  import android.os.Looper;
  import android.os.RemoteException;
  import android.util.Slog;
  import android.util.proto.ProtoOutputStream;
  import android.view.Display;
  import android.view.IApplicationToken;
  import android.view.IDisplayFoldListener;
  import android.view.IWindowManager;
  import android.view.InputEventReceiver;
  import android.view.KeyEvent;
  import android.view.WindowManager;
  import android.view.WindowManagerGlobal;
  import android.view.WindowManagerPolicyConstants;
  import android.view.animation.Animation;
  
  import com.android.internal.policy.IKeyguardDismissCallback;
  import com.android.internal.policy.IShortcutService;
  import com.android.server.wm.DisplayRotation;
  import com.android.server.wm.WindowFrames;
  
  import java.io.PrintWriter;
  import java.lang.annotation.Retention;
  import java.lang.annotation.RetentionPolicy;
  
  /**
   * This interface supplies all UI-specific behavior of the window manager.  An
   * instance of it is created by the window manager when it starts up, and allows
   * customization of window layering, special window types, key dispatching, and
   * layout.
   *
   * <p>Because this provides deep interaction with the system window manager,
   * specific methods on this interface can be called from a variety of contexts
   * with various restrictions on what they can do.  These are encoded through
   * a suffixes at the end of a method encoding the thread the method is called
   * from and any locks that are held when it is being called; if no suffix
   * is attached to a method, then it is not called with any locks and may be
   * called from the main window manager thread or another thread calling into
   * the window manager.
   *
   * <p>The current suffixes are:
   *
   * <dl>
   * <dt> Ti <dd> Called from the input thread.  This is the thread that
   * collects pending input events and dispatches them to the appropriate window.
   * It may block waiting for events to be processed, so that the input stream is
   * properly serialized.
   * <dt> Tq <dd> Called from the low-level input queue thread.  This is the
   * thread that reads events out of the raw input devices and places them
   * into the global input queue that is read by the <var>Ti</var> thread.
   * This thread should not block for a long period of time on anything but the
   * key driver.
   * <dt> Lw <dd> Called with the main window manager lock held.  Because the
   * window manager is a very low-level system service, there are few other
   * system services you can call with this lock held.  It is explicitly okay to
   * make calls into the package manager and power manager; it is explicitly not
   * okay to make calls into the activity manager or most other services.  Note that
   * {@link android.content.Context#checkPermission(String, int, int)} and
   * variations require calling into the activity manager.
   * <dt> Li <dd> Called with the input thread lock held.  This lock can be
   * acquired by the window manager while it holds the window lock, so this is
   * even more restrictive than <var>Lw</var>.
   * </dl>
   */
  public interface WindowManagerPolicy extends WindowManagerPolicyConstants {
      @Retention(SOURCE)
      @IntDef({NAV_BAR_LEFT, NAV_BAR_RIGHT, NAV_BAR_BOTTOM})
      @interface NavigationBarPosition {}
  
      /**
       * Pass this event to the user / app.  To be returned from
       * {@link #interceptKeyBeforeQueueing}.
       */
      int ACTION_PASS_TO_USER = 0x00000001;
      /** Layout state may have changed (so another layout will be performed) */
      int FINISH_LAYOUT_REDO_LAYOUT = 0x0001;
      /** Configuration state may have changed */
      int FINISH_LAYOUT_REDO_CONFIG = 0x0002;
      /** Wallpaper may need to move */
      int FINISH_LAYOUT_REDO_WALLPAPER = 0x0004;
      /** Need to recompute animations */
      int FINISH_LAYOUT_REDO_ANIM = 0x0008;
      /** Layer for the screen off animation */
      int COLOR_FADE_LAYER = 0x40000001;
  
      /**
       * Register shortcuts for window manager to dispatch.
       * Shortcut code is packed as (metaState << Integer.SIZE) | keyCode
       * @hide
       */
      void registerShortcutKey(long shortcutCode, IShortcutService shortcutKeyReceiver)
              throws RemoteException;
  
      /**
       * Called when the Keyguard occluded state changed.
       * @param occluded Whether Keyguard is currently occluded or not.
       */
      void onKeyguardOccludedChangedLw(boolean occluded);
  
      /**
       * Interface to the Window Manager state associated with a particular
       * window.  You can hold on to an instance of this interface from the call
       * to prepareAddWindow() until removeWindow().
       */
      public interface WindowState {
          /**
           * Return the uid of the app that owns this window.
           */
          int getOwningUid();
  
          /**
           * Return the package name of the app that owns this window.
           */
          String getOwningPackage();
  
          /**
           * Perform standard frame computation.  The result can be obtained with
           * getFrame() if so desired.  Must be called with the window manager
           * lock held.
           *
           */
          public void computeFrameLw();
  
          /**
           * Retrieve the current frame of the window that has been assigned by
           * the window manager.  Must be called with the window manager lock held.
           *
           * @return Rect The rectangle holding the window frame.
           */
          public Rect getFrameLw();
  
          /**
           * Retrieve the frame of the display that this window was last
           * laid out in.  Must be called with the
           * window manager lock held.
           *
           * @return Rect The rectangle holding the display frame.
           */
          public Rect getDisplayFrameLw();
  
          /**
           * Retrieve the frame of the area inside the overscan region of the
           * display that this window was last laid out in.  Must be called with the
           * window manager lock held.
           *
           * @return Rect The rectangle holding the display overscan frame.
           */
          public Rect getOverscanFrameLw();
  
          /**
           * Retrieve the frame of the content area that this window was last
           * laid out in.  This is the area in which the content of the window
           * should be placed.  It will be smaller than the display frame to
           * account for screen decorations such as a status bar or soft
           * keyboard.  Must be called with the
           * window manager lock held.
           *
           * @return Rect The rectangle holding the content frame.
           */
          public Rect getContentFrameLw();
  
          /**
           * Retrieve the frame of the visible area that this window was last
           * laid out in.  This is the area of the screen in which the window
           * will actually be fully visible.  It will be smaller than the
           * content frame to account for transient UI elements blocking it
           * such as an input method's candidates UI.  Must be called with the
           * window manager lock held.
           *
           * @return Rect The rectangle holding the visible frame.
           */
          public Rect getVisibleFrameLw();
  
          /**
           * Returns true if this window is waiting to receive its given
           * internal insets from the client app, and so should not impact the
           * layout of other windows.
           */
          public boolean getGivenInsetsPendingLw();
  
          /**
           * Retrieve the insets given by this window's client for the content
           * area of windows behind it.  Must be called with the
           * window manager lock held.
           *
           * @return Rect The left, top, right, and bottom insets, relative
           * to the window's frame, of the actual contents.
           */
          public Rect getGivenContentInsetsLw();
  
          /**
           * Retrieve the insets given by this window's client for the visible
           * area of windows behind it.  Must be called with the
           * window manager lock held.
           *
           * @return Rect The left, top, right, and bottom insets, relative
           * to the window's frame, of the actual visible area.
           */
          public Rect getGivenVisibleInsetsLw();
  
          /**
           * Retrieve the current LayoutParams of the window.
           *
           * @return WindowManager.LayoutParams The window's internal LayoutParams
           *         instance.
           */
          public WindowManager.LayoutParams getAttrs();
  
          /**
           * Return whether this window needs the menu key shown.  Must be called
           * with window lock held, because it may need to traverse down through
           * window list to determine the result.
           * @param bottom The bottom-most window to consider when determining this.
           */
          public boolean getNeedsMenuLw(WindowState bottom);
  
          /**
           * Retrieve the current system UI visibility flags associated with
           * this window.
           */
          public int getSystemUiVisibility();
  
          /**
           * Get the layer at which this window's surface will be Z-ordered.
           */
          public int getSurfaceLayer();
  
          /**
           * Retrieve the type of the top-level window.
           *
           * @return the base type of the parent window if attached or its own type otherwise
           */
          public int getBaseType();
  
          /**
           * Return the token for the application (actually activity) that owns
           * this window.  May return null for system windows.
           *
           * @return An IApplicationToken identifying the owning activity.
           */
          public IApplicationToken getAppToken();
  
          /**
           * Return true if this window is participating in voice interaction.
           */
          public boolean isVoiceInteraction();
  
          /**
           * Return true if, at any point, the application token associated with
           * this window has actually displayed any windows.  This is most useful
           * with the "starting up" window to determine if any windows were
           * displayed when it is closed.
           *
           * @return Returns true if one or more windows have been displayed,
           *         else false.
           */
          public boolean hasAppShownWindows();
  
          /**
           * Is this window visible?  It is not visible if there is no
           * surface, or we are in the process of running an exit animation
           * that will remove the surface.
           */
          boolean isVisibleLw();
  
          /**
           * Is this window currently visible to the user on-screen?  It is
           * displayed either if it is visible or it is currently running an
           * animation before no longer being visible.  Must be called with the
           * window manager lock held.
           */
          boolean isDisplayedLw();
  
          /**
           * Return true if this window (or a window it is attached to, but not
           * considering its app token) is currently animating.
           */
          boolean isAnimatingLw();
  
          /**
           * @return Whether the window can affect SystemUI flags, meaning that SystemUI (system bars,
           *         for example) will be  affected by the flags specified in this window. This is the
           *         case when the surface is on screen but not exiting.
           */
          boolean canAffectSystemUiFlags();
  
          /**
           * Is this window considered to be gone for purposes of layout?
           */
          boolean isGoneForLayoutLw();
  
          /**
           * Returns true if the window has a surface that it has drawn a
           * complete UI in to. Note that this is different from {@link #hasDrawnLw()}
           * in that it also returns true if the window is READY_TO_SHOW, but was not yet
           * promoted to HAS_DRAWN.
           */
          boolean isDrawnLw();
  
          /**
           * Returns true if this window has been shown on screen at some time in
           * the past.  Must be called with the window manager lock held.
           *
           * @deprecated Use {@link #isDrawnLw} or any of the other drawn/visibility methods.
           */
          @Deprecated
          public boolean hasDrawnLw();
  
          /**
           * Can be called by the policy to force a window to be hidden,
           * regardless of whether the client or window manager would like
           * it shown.  Must be called with the window manager lock held.
           * Returns true if {@link #showLw} was last called for the window.
           */
          public boolean hideLw(boolean doAnimation);
  
          /**
           * Can be called to undo the effect of {@link #hideLw}, allowing a
           * window to be shown as long as the window manager and client would
           * also like it to be shown.  Must be called with the window manager
           * lock held.
           * Returns true if {@link #hideLw} was last called for the window.
           */
          public boolean showLw(boolean doAnimation);
  
          /**
           * Check whether the process hosting this window is currently alive.
           */
          public boolean isAlive();
  
          /**
           * Check if window is on {@link Display#DEFAULT_DISPLAY}.
           * @return true if window is on default display.
           */
          public boolean isDefaultDisplay();
  
          /**
           * Check whether the window is currently dimming.
           */
          public boolean isDimming();
  
          /**
           * Returns true if the window is letterboxed for the display cutout.
           */
          default boolean isLetterboxedForDisplayCutoutLw() {
              return false;
          }
  
          /**
           * Returns true if the window has a letterbox and any part of that letterbox overlaps with
           * the given {@code rect}.
           */
          default boolean isLetterboxedOverlappingWith(Rect rect) {
              return false;
          }
  
          /** @return the current windowing mode of this window. */
          int getWindowingMode();
  
          /**
           * Returns the {@link WindowConfiguration.ActivityType} associated with the configuration
           * of this window.
           */
          default int getActivityType() {
              return WindowConfiguration.WINDOWING_MODE_UNDEFINED;
          }
  
          /**
           * Returns true if the window is current in multi-windowing mode. i.e. it shares the
           * screen with other application windows.
           */
          boolean inMultiWindowMode();
  
          public int getRotationAnimationHint();
  
          public boolean isInputMethodWindow();
  
          public boolean isInputMethodTarget();
  
          public int getDisplayId();
  
          /**
           * Returns true if the window owner can add internal system windows.
           * That is, they have {@link Manifest.permission#INTERNAL_SYSTEM_WINDOW}.
           */
          default boolean canAddInternalSystemWindow() {
              return false;
          }
  
          /**
           * Returns true if the window owner has the permission to acquire a sleep token when it's
           * visible. That is, they have the permission {@link Manifest.permission#DEVICE_POWER}.
           */
          boolean canAcquireSleepToken();
  
          /** @return true if this window desires key events. */
          boolean canReceiveKeys();
  
          /** @return true if the window can show over keyguard. */
          boolean canShowWhenLocked();
  
          /**
           * Writes {@link com.android.server.wm.IdentifierProto} to stream.
           */
          void writeIdentifierToProto(ProtoOutputStream proto, long fieldId);
  
          /**
           * @return The {@link WindowFrames} associated with this {@link WindowState}
           */
          WindowFrames getWindowFrames();
      }
  
      /**
       * Representation of a input consumer that the policy has added to the
       * window manager to consume input events going to windows below it.
       */
      public interface InputConsumer {
          /**
           * Remove the input consumer from the window manager.
           */
          void dismiss();
      }
  
      /**
       * Holds the contents of a starting window. {@link #addSplashScreen} needs to wrap the
       * contents of the starting window into an class implementing this interface, which then will be
       * held by WM and released with {@link #remove} when no longer needed.
       */
      interface StartingSurface {
  
          /**
           * Removes the starting window surface. Do not hold the window manager lock when calling
           * this method!
           */
          void remove();
      }
  
      /**
       * Interface for calling back in to the window manager that is private
       * between it and the policy.
       */
      public interface WindowManagerFuncs {
          public static final int LID_ABSENT = -1;
          public static final int LID_CLOSED = 0;
          public static final int LID_OPEN = 1;
  
          public static final int LID_BEHAVIOR_NONE = 0;
          public static final int LID_BEHAVIOR_SLEEP = 1;
          public static final int LID_BEHAVIOR_LOCK = 2;
  
          public static final int CAMERA_LENS_COVER_ABSENT = -1;
          public static final int CAMERA_LENS_UNCOVERED = 0;
          public static final int CAMERA_LENS_COVERED = 1;
  
          /**
           * Add a input consumer which will consume all input events going to any window below it.
           */
          public InputConsumer createInputConsumer(Looper looper, String name,
                  InputEventReceiver.Factory inputEventReceiverFactory, int displayId);
  
          /**
           * Returns a code that describes the current state of the lid switch.
           */
          public int getLidState();
  
          /**
           * Lock the device now.
           */
          public void lockDeviceNow();
  
          /**
           * Returns a code that descripbes whether the camera lens is covered or not.
           */
          public int getCameraLensCoverState();
  
          /**
           * Switch the keyboard layout for the given device.
           * Direction should be +1 or -1 to go to the next or previous keyboard layout.
           */
          public void switchKeyboardLayout(int deviceId, int direction);
  
          public void shutdown(boolean confirm);
          public void reboot(boolean confirm);
          public void rebootSafeMode(boolean confirm);
  
          /**
           * Return the window manager lock needed to correctly call "Lw" methods.
           */
          public Object getWindowManagerLock();
  
          /** Register a system listener for touch events */
          void registerPointerEventListener(PointerEventListener listener, int displayId);
  
          /** Unregister a system listener for touch events */
          void unregisterPointerEventListener(PointerEventListener listener, int displayId);
  
          /**
           * Retrieves the {@param outBounds} from the stack matching the {@param windowingMode} and
           * {@param activityType}.
           */
          void getStackBounds(int windowingMode, int activityType, Rect outBounds);
  
          /**
           * @return The currently active input method window.
           */
          WindowState getInputMethodWindowLw();
  
          /**
           * Notifies window manager that {@link #isKeyguardTrustedLw} has changed.
           */
          void notifyKeyguardTrustedChanged();
  
          /**
           * Notifies the window manager that screen is being turned off.
           *
           * @param listener callback to call when display can be turned off
           */
          void screenTurningOff(ScreenOffListener listener);
  
          /**
           * Convert the lid state to a human readable format.
           */
          static String lidStateToString(int lid) {
              switch (lid) {
                  case LID_ABSENT:
                      return "LID_ABSENT";
                  case LID_CLOSED:
                      return "LID_CLOSED";
                  case LID_OPEN:
                      return "LID_OPEN";
                  default:
                      return Integer.toString(lid);
              }
          }
  
          /**
           * Convert the camera lens state to a human readable format.
           */
          static String cameraLensStateToString(int lens) {
              switch (lens) {
                  case CAMERA_LENS_COVER_ABSENT:
                      return "CAMERA_LENS_COVER_ABSENT";
                  case CAMERA_LENS_UNCOVERED:
                      return "CAMERA_LENS_UNCOVERED";
                  case CAMERA_LENS_COVERED:
                      return "CAMERA_LENS_COVERED";
                  default:
                      return Integer.toString(lens);
              }
          }
  
          /**
           * Hint to window manager that the user has started a navigation action that should
           * abort animations that have no timeout, in case they got stuck.
           */
          void triggerAnimationFailsafe();
  
          /**
           * The keyguard showing state has changed
           */
          void onKeyguardShowingAndNotOccludedChanged();
  
          /**
           * Notifies window manager that power key is being pressed.
           */
          void onPowerKeyDown(boolean isScreenOn);
  
          /**
           * Notifies window manager that user is switched.
           */
          void onUserSwitched();
  
          /**
           * Hint to window manager that the user is interacting with a display that should be treated
           * as the top display.
           */
          void moveDisplayToTop(int displayId);
      }
  
      /**
       * Provides the rotation of a device.
       *
       * @see com.android.server.policy.WindowOrientationListener
       */
      public interface RotationSource {
          int getProposedRotation();
  
          void setCurrentRotation(int rotation);
      }
  
      /**
       * Interface to get public information of a display content.
       */
      public interface DisplayContentInfo {
          DisplayRotation getDisplayRotation();
          Display getDisplay();
      }
  
      /** Window has been added to the screen. */
      public static final int TRANSIT_ENTER = 1;
      /** Window has been removed from the screen. */
      public static final int TRANSIT_EXIT = 2;
      /** Window has been made visible. */
      public static final int TRANSIT_SHOW = 3;
      /** Window has been made invisible.
       * TODO: Consider removal as this is unused. */
      public static final int TRANSIT_HIDE = 4;
      /** The "application starting" preview window is no longer needed, and will
       * animate away to show the real window. */
      public static final int TRANSIT_PREVIEW_DONE = 5;
  
      // NOTE: screen off reasons are in order of significance, with more
      // important ones lower than less important ones.
  
      /** @hide */
      @IntDef({USER_ROTATION_FREE, USER_ROTATION_LOCKED})
      @Retention(RetentionPolicy.SOURCE)
      public @interface UserRotationMode {}
  
      /** When not otherwise specified by the activity's screenOrientation, rotation should be
       * determined by the system (that is, using sensors). */
      public final int USER_ROTATION_FREE = 0;
      /** When not otherwise specified by the activity's screenOrientation, rotation is set by
       * the user. */
      public final int USER_ROTATION_LOCKED = 1;
  
      /**
       * Set the default display content to provide basic functions for the policy.
       */
      public void setDefaultDisplay(DisplayContentInfo displayContentInfo);
  
      /**
       * Perform initialization of the policy.
       *
       * @param context The system context we are running in.
       */
      public void init(Context context, IWindowManager windowManager,
              WindowManagerFuncs windowManagerFuncs);
  
      /**
       * Check permissions when adding a window.
       *
       * @param attrs The window's LayoutParams.
       * @param outAppOp First element will be filled with the app op corresponding to
       *                 this window, or OP_NONE.
       *
       * @return {@link WindowManagerGlobal#ADD_OKAY} if the add can proceed;
       *      else an error code, usually
       *      {@link WindowManagerGlobal#ADD_PERMISSION_DENIED}, to abort the add.
       */
      public int checkAddPermission(WindowManager.LayoutParams attrs, int[] outAppOp);
  
      /**
       * Check permissions when adding a window.
       *
       * @param attrs The window's LayoutParams.
       *
       * @return True if the window may only be shown to the current user, false if the window can
       * be shown on all users' windows.
       */
      public boolean checkShowToOwnerOnly(WindowManager.LayoutParams attrs);
  
      /**
       * After the window manager has computed the current configuration based
       * on its knowledge of the display and input devices, it gives the policy
       * a chance to adjust the information contained in it.  If you want to
       * leave it as-is, simply do nothing.
       *
       * <p>This method may be called by any thread in the window manager, but
       * no internal locks in the window manager will be held.
       *
       * @param config The Configuration being computed, for you to change as
       * desired.
       * @param keyboardPresence Flags that indicate whether internal or external
       * keyboards are present.
       * @param navigationPresence Flags that indicate whether internal or external
       * navigation devices are present.
       */
      public void adjustConfigurationLw(Configuration config, int keyboardPresence,
              int navigationPresence);
  
      /**
       * Returns the layer assignment for the window state. Allows you to control how different
       * kinds of windows are ordered on-screen.
       *
       * @param win The window state
       * @return int An arbitrary integer used to order windows, with lower numbers below higher ones.
       */
      default int getWindowLayerLw(WindowState win) {
          return getWindowLayerFromTypeLw(win.getBaseType(), win.canAddInternalSystemWindow());
      }
  
      /**
       * Returns the layer assignment for the window type. Allows you to control how different
       * kinds of windows are ordered on-screen.
       *
       * @param type The type of window being assigned.
       * @return int An arbitrary integer used to order windows, with lower numbers below higher ones.
       */
      default int getWindowLayerFromTypeLw(int type) {
          if (isSystemAlertWindowType(type)) {
              throw new IllegalArgumentException("Use getWindowLayerFromTypeLw() or"
                      + " getWindowLayerLw() for alert window types");
          }
          return getWindowLayerFromTypeLw(type, false /* canAddInternalSystemWindow */);
      }
  
      /**
       * Returns the layer assignment for the window type. Allows you to control how different
       * kinds of windows are ordered on-screen.
       *
       * @param type The type of window being assigned.
       * @param canAddInternalSystemWindow If the owner window associated with the type we are
       *        evaluating can add internal system windows. I.e they have
       *        {@link Manifest.permission#INTERNAL_SYSTEM_WINDOW}. If true, alert window
       *        types {@link android.view.WindowManager.LayoutParams#isSystemAlertWindowType(int)}
       *        can be assigned layers greater than the layer for
       *        {@link android.view.WindowManager.LayoutParams#TYPE_APPLICATION_OVERLAY} Else, their
       *        layers would be lesser.
       * @return int An arbitrary integer used to order windows, with lower numbers below higher ones.
       */
      default int getWindowLayerFromTypeLw(int type, boolean canAddInternalSystemWindow) {
          if (type >= FIRST_APPLICATION_WINDOW && type <= LAST_APPLICATION_WINDOW) {
              return APPLICATION_LAYER;
          }
  
          switch (type) {
              case TYPE_WALLPAPER:
                  // wallpaper is at the bottom, though the window manager may move it.
                  return  1;
              case TYPE_PRESENTATION:
              case TYPE_PRIVATE_PRESENTATION:
                  return  APPLICATION_LAYER;
              case TYPE_DOCK_DIVIDER:
                  return  APPLICATION_LAYER;
              case TYPE_QS_DIALOG:
                  return  APPLICATION_LAYER;
              case TYPE_PHONE:
                  return  3;
              case TYPE_SEARCH_BAR:
              case TYPE_VOICE_INTERACTION_STARTING:
                  return  4;
              case TYPE_VOICE_INTERACTION:
                  // voice interaction layer is almost immediately above apps.
                  return  5;
              case TYPE_INPUT_CONSUMER:
                  return  6;
              case TYPE_SYSTEM_DIALOG:
                  return  7;
              case TYPE_TOAST:
                  // toasts and the plugged-in battery thing
                  return  8;
              case TYPE_PRIORITY_PHONE:
                  // SIM errors and unlock.  Not sure if this really should be in a high layer.
                  return  9;
              case TYPE_SYSTEM_ALERT:
                  // like the ANR / app crashed dialogs
                  // Type is deprecated for non-system apps. For system apps, this type should be
                  // in a higher layer than TYPE_APPLICATION_OVERLAY.
                  return  canAddInternalSystemWindow ? 13 : 10;
              case TYPE_APPLICATION_OVERLAY:
                  return  12;
              case TYPE_DREAM:
                  // used for Dreams (screensavers with TYPE_DREAM windows)
                  return  14;
              case TYPE_INPUT_METHOD:
                  // on-screen keyboards and other such input method user interfaces go here.
                  return  15;
              case TYPE_INPUT_METHOD_DIALOG:
                  // on-screen keyboards and other such input method user interfaces go here.
                  return  16;
              case TYPE_STATUS_BAR:
                  return  17;
              case TYPE_STATUS_BAR_PANEL:
                  return  18;
              case TYPE_STATUS_BAR_SUB_PANEL:
                  return  19;
              case TYPE_KEYGUARD_DIALOG:
                  return  20;
              case TYPE_VOLUME_OVERLAY:
                  // the on-screen volume indicator and controller shown when the user
                  // changes the device volume
                  return  21;
              case TYPE_SYSTEM_OVERLAY:
                  // the on-screen volume indicator and controller shown when the user
                  // changes the device volume
                  return  canAddInternalSystemWindow ? 22 : 11;
              case TYPE_NAVIGATION_BAR:
                  // the navigation bar, if available, shows atop most things
                  return  23;
              case TYPE_NAVIGATION_BAR_PANEL:
                  // some panels (e.g. search) need to show on top of the navigation bar
                  return  24;
              case TYPE_SCREENSHOT:
                  // screenshot selection layer shouldn't go above system error, but it should cover
                  // navigation bars at the very least.
                  return  25;
              case TYPE_SYSTEM_ERROR:
                  // system-level error dialogs
                  return  canAddInternalSystemWindow ? 26 : 10;
              case TYPE_MAGNIFICATION_OVERLAY:
                  // used to highlight the magnified portion of a display
                  return  27;
              case TYPE_DISPLAY_OVERLAY:
                  // used to simulate secondary display devices
                  return  28;
              case TYPE_DRAG:
                  // the drag layer: input for drag-and-drop is associated with this window,
                  // which sits above all other focusable windows
                  return  29;
              case TYPE_ACCESSIBILITY_OVERLAY:
                  // overlay put by accessibility services to intercept user interaction
                  return  30;
              case TYPE_SECURE_SYSTEM_OVERLAY:
                  return  31;
              case TYPE_BOOT_PROGRESS:
                  return  32;
              case TYPE_POINTER:
                  // the (mouse) pointer layer
                  return  33;
              default:
                  Slog.e("WindowManager", "Unknown window type: " + type);
                  return APPLICATION_LAYER;
          }
      }
  
      /**
       * Return how to Z-order sub-windows in relation to the window they are attached to.
       * Return positive to have them ordered in front, negative for behind.
       *
       * @param type The sub-window type code.
       *
       * @return int Layer in relation to the attached window, where positive is
       *         above and negative is below.
       */
      default int getSubWindowLayerFromTypeLw(int type) {
          switch (type) {
              case TYPE_APPLICATION_PANEL:
              case TYPE_APPLICATION_ATTACHED_DIALOG:
                  return APPLICATION_PANEL_SUBLAYER;
              case TYPE_APPLICATION_MEDIA:
                  return APPLICATION_MEDIA_SUBLAYER;
              case TYPE_APPLICATION_MEDIA_OVERLAY:
                  return APPLICATION_MEDIA_OVERLAY_SUBLAYER;
              case TYPE_APPLICATION_SUB_PANEL:
                  return APPLICATION_SUB_PANEL_SUBLAYER;
              case TYPE_APPLICATION_ABOVE_SUB_PANEL:
                  return APPLICATION_ABOVE_SUB_PANEL_SUBLAYER;
          }
          Slog.e("WindowManager", "Unknown sub-window type: " + type);
          return 0;
      }
  
      /**
       * Get the highest layer (actually one more than) that the wallpaper is
       * allowed to be in.
       */
      public int getMaxWallpaperLayer();
  
      /**
       * Return whether the given window can become the Keyguard window. Typically returns true for
       * the StatusBar.
       */
      public boolean isKeyguardHostWindow(WindowManager.LayoutParams attrs);
  
      /**
       * @return whether {@param win} can be hidden by Keyguard
       */
      public boolean canBeHiddenByKeyguardLw(WindowState win);
  
      /**
       * Called when the system would like to show a UI to indicate that an
       * application is starting.  You can use this to add a
       * APPLICATION_STARTING_TYPE window with the given appToken to the window
       * manager (using the normal window manager APIs) that will be shown until
       * the application displays its own window.  This is called without the
       * window manager locked so that you can call back into it.
       *
       * @param appToken Token of the application being started.
       * @param packageName The name of the application package being started.
       * @param theme Resource defining the application's overall visual theme.
       * @param nonLocalizedLabel The default title label of the application if
       *        no data is found in the resource.
       * @param labelRes The resource ID the application would like to use as its name.
       * @param icon The resource ID the application would like to use as its icon.
       * @param windowFlags Window layout flags.
       * @param overrideConfig override configuration to consider when generating
       *        context to for resources.
       * @param displayId Id of the display to show the splash screen at.
       *
       * @return The starting surface.
       *
       */
      public StartingSurface addSplashScreen(IBinder appToken, String packageName, int theme,
              CompatibilityInfo compatInfo, CharSequence nonLocalizedLabel, int labelRes, int icon,
              int logo, int windowFlags, Configuration overrideConfig, int displayId);
  
      /**
       * Set or clear a window which can behave as the keyguard.
       *
       * @param win The window which can behave as the keyguard.
       */
      void setKeyguardCandidateLw(@Nullable WindowState win);
  
      /**
       * Create and return an animation to re-display a window that was force hidden by Keyguard.
       */
      public Animation createHiddenByKeyguardExit(boolean onWallpaper,
              boolean goingToNotificationShade, boolean subtleAnimation);
  
      /**
       * Create and return an animation to let the wallpaper disappear after being shown behind
       * Keyguard.
       */
      public Animation createKeyguardWallpaperExit(boolean goingToNotificationShade);
  
      /**
       * Called from the input reader thread before a key is enqueued.
       *
       * <p>There are some actions that need to be handled here because they
       * affect the power state of the device, for example, the power keys.
       * Generally, it's best to keep as little as possible in the queue thread
       * because it's the most fragile.
       * @param event The key event.
       * @param policyFlags The policy flags associated with the key.
       *
       * @return Actions flags: may be {@link #ACTION_PASS_TO_USER}.
       */
      public int interceptKeyBeforeQueueing(KeyEvent event, int policyFlags);
  
      /**
       * Called from the input reader thread before a motion is enqueued when the device is in a
       * non-interactive state.
       *
       * <p>There are some actions that need to be handled here because they
       * affect the power state of the device, for example, waking on motions.
       * Generally, it's best to keep as little as possible in the queue thread
       * because it's the most fragile.
       * @param displayId The display ID of the motion event.
       * @param policyFlags The policy flags associated with the motion.
       *
       * @return Actions flags: may be {@link #ACTION_PASS_TO_USER}.
       */
      int interceptMotionBeforeQueueingNonInteractive(int displayId, long whenNanos,
              int policyFlags);
  
      /**
       * Called from the input dispatcher thread before a key is dispatched to a window.
       *
       * <p>Allows you to define
       * behavior for keys that can not be overridden by applications.
       * This method is called from the input thread, with no locks held.
       *
       * @param win The window that currently has focus.  This is where the key
       *            event will normally go.
       * @param event The key event.
       * @param policyFlags The policy flags associated with the key.
       * @return 0 if the key should be dispatched immediately, -1 if the key should
       * not be dispatched ever, or a positive value indicating the number of
       * milliseconds by which the key dispatch should be delayed before trying
       * again.
       */
      public long interceptKeyBeforeDispatching(WindowState win, KeyEvent event, int policyFlags);
  
      /**
       * Called from the input dispatcher thread when an application did not handle
       * a key that was dispatched to it.
       *
       * <p>Allows you to define default global behavior for keys that were not handled
       * by applications.  This method is called from the input thread, with no locks held.
       *
       * @param win The window that currently has focus.  This is where the key
       *            event will normally go.
       * @param event The key event.
       * @param policyFlags The policy flags associated with the key.
       * @return Returns an alternate key event to redispatch as a fallback, or null to give up.
       * The caller is responsible for recycling the key event.
       */
      public KeyEvent dispatchUnhandledKey(WindowState win, KeyEvent event, int policyFlags);
  
      /**
       * Called when the top focused display is changed.
       *
       * @param displayId The ID of the top focused display.
       */
      void setTopFocusedDisplay(int displayId);
  
      /**
       * Apply the keyguard policy to a specific window.
       *
       * @param win The window to apply the keyguard policy.
       * @param imeTarget The current IME target window.
       */
      void applyKeyguardPolicyLw(WindowState win, WindowState imeTarget);
  
      /**
       * Called when the state of allow-lockscreen-when-on of the display is changed. See
       * {@link WindowManager.LayoutParams#FLAG_ALLOW_LOCK_WHILE_SCREEN_ON}
       *
       * @param displayId The ID of the display.
       * @param allow Whether the display allows showing lockscreen when it is on.
       */
      void setAllowLockscreenWhenOn(int displayId, boolean allow);
  
      /**
       * Called when the device has started waking up.
       */
      void startedWakingUp(@OnReason int reason);
  
      /**
       * Called when the device has finished waking up.
       */
      void finishedWakingUp(@OnReason int reason);
  
      /**
       * Called when the device has started going to sleep.
       *
       * @param why {@link #OFF_BECAUSE_OF_USER}, {@link #OFF_BECAUSE_OF_ADMIN},
       * or {@link #OFF_BECAUSE_OF_TIMEOUT}.
       */
      public void startedGoingToSleep(int why);
  
      /**
       * Called when the device has finished going to sleep.
       *
       * @param why {@link #OFF_BECAUSE_OF_USER}, {@link #OFF_BECAUSE_OF_ADMIN},
       * or {@link #OFF_BECAUSE_OF_TIMEOUT}.
       */
      public void finishedGoingToSleep(int why);
  
      /**
       * Called when the device is about to turn on the screen to show content.
       * When waking up, this method will be called once after the call to wakingUp().
       * When dozing, the method will be called sometime after the call to goingToSleep() and
       * may be called repeatedly in the case where the screen is pulsing on and off.
       *
       * Must call back on the listener to tell it when the higher-level system
       * is ready for the screen to go on (i.e. the lock screen is shown).
       */
      public void screenTurningOn(ScreenOnListener screenOnListener);
  
      /**
       * Called when the device has actually turned on the screen, i.e. the display power state has
       * been set to ON and the screen is unblocked.
       */
      public void screenTurnedOn();
  
      /**
       * Called when the display would like to be turned off. This gives policy a chance to do some
       * things before the display power state is actually changed to off.
       *
       * @param screenOffListener Must be called to tell that the display power state can actually be
       *                          changed now after policy has done its work.
       */
      public void screenTurningOff(ScreenOffListener screenOffListener);
  
      /**
       * Called when the device has turned the screen off.
       */
      public void screenTurnedOff();
  
      public interface ScreenOnListener {
          void onScreenOn();
      }
  
      /**
       * See {@link #screenTurnedOff}
       */
      public interface ScreenOffListener {
          void onScreenOff();
      }
  
      /**
       * Return whether the default display is on and not blocked by a black surface.
       */
      public boolean isScreenOn();
  
      /**
       * @return whether the device is currently allowed to animate.
       *
       * Note: this can be true even if it is not appropriate to animate for reasons that are outside
       *       of the policy's authority.
       */
      boolean okToAnimate();
  
      /**
       * Tell the policy that the lid switch has changed state.
       * @param whenNanos The time when the change occurred in uptime nanoseconds.
       * @param lidOpen True if the lid is now open.
       */
      public void notifyLidSwitchChanged(long whenNanos, boolean lidOpen);
  
      /**
       * Tell the policy that the camera lens has been covered or uncovered.
       * @param whenNanos The time when the change occurred in uptime nanoseconds.
       * @param lensCovered True if the lens is covered.
       */
      public void notifyCameraLensCoverSwitchChanged(long whenNanos, boolean lensCovered);
  
      /**
       * Tell the policy if anyone is requesting that keyguard not come on.
       *
       * @param enabled Whether keyguard can be on or not.  does not actually
       * turn it on, unless it was previously disabled with this function.
       *
       * @see android.app.KeyguardManager.KeyguardLock#disableKeyguard()
       * @see android.app.KeyguardManager.KeyguardLock#reenableKeyguard()
       */
      @SuppressWarnings("javadoc")
      public void enableKeyguard(boolean enabled);
  
      /**
       * Callback used by {@link #exitKeyguardSecurely}
       */
      interface OnKeyguardExitResult {
          void onKeyguardExitResult(boolean success);
      }
  
      /**
       * Tell the policy if anyone is requesting the keyguard to exit securely
       * (this would be called after the keyguard was disabled)
       * @param callback Callback to send the result back.
       * @see android.app.KeyguardManager#exitKeyguardSecurely(android.app.KeyguardManager.OnKeyguardExitResult)
       */
      @SuppressWarnings("javadoc")
      void exitKeyguardSecurely(OnKeyguardExitResult callback);
  
      /**
       * isKeyguardLocked
       *
       * Return whether the keyguard is currently locked.
       *
       * @return true if in keyguard is locked.
       */
      public boolean isKeyguardLocked();
  
      /**
       * isKeyguardSecure
       *
       * Return whether the keyguard requires a password to unlock.
       * @param userId
       *
       * @return true if in keyguard is secure.
       */
      public boolean isKeyguardSecure(int userId);
  
      /**
       * Return whether the keyguard is currently occluded.
       *
       * @return true if in keyguard is occluded, false otherwise
       */
      public boolean isKeyguardOccluded();
  
      /**
       * @return true if in keyguard is on and not occluded.
       */
      public boolean isKeyguardShowingAndNotOccluded();
  
      /**
       * @return whether Keyguard is in trusted state and can be dismissed without credentials
       */
      public boolean isKeyguardTrustedLw();
  
      /**
       * inKeyguardRestrictedKeyInputMode
       *
       * If keyguard screen is showing or in restricted key input mode (i.e. in
       * keyguard password emergency screen). When in such mode, certain keys,
       * such as the Home key and the right soft keys, don't work.
       *
       * @return true if in keyguard restricted input mode.
       */
      public boolean inKeyguardRestrictedKeyInputMode();
  
      /**
       * Ask the policy to dismiss the keyguard, if it is currently shown.
       *
       * @param callback Callback to be informed about the result.
       * @param message A message that should be displayed in the keyguard.
       */
      public void dismissKeyguardLw(@Nullable IKeyguardDismissCallback callback,
              CharSequence message);
  
      /**
       * Ask the policy whether the Keyguard has drawn. If the Keyguard is disabled, this method
       * returns true as soon as we know that Keyguard is disabled.
       *
       * @return true if the keyguard has drawn.
       */
      public boolean isKeyguardDrawnLw();
  
      /**
       * Called when the system is mostly done booting to set whether
       * the system should go into safe mode.
       */
      public void setSafeMode(boolean safeMode);
  
      /**
       * Called when the system is mostly done booting.
       */
      public void systemReady();
  
      /**
       * Called when the system is done booting to the point where the
       * user can start interacting with it.
       */
      public void systemBooted();
  
      /**
       * Show boot time message to the user.
       */
      public void showBootMessage(final CharSequence msg, final boolean always);
  
      /**
       * Hide the UI for showing boot messages, never to be displayed again.
       */
      public void hideBootMessages();
  
      /**
       * Called when userActivity is signalled in the power manager.
       * This is safe to call from any thread, with any window manager locks held or not.
       */
      public void userActivity();
  
      /**
       * Called when we have finished booting and can now display the home
       * screen to the user.  This will happen after systemReady(), and at
       * this point the display is active.
       */
      public void enableScreenAfterBoot();
  
      /**
       * Call from application to perform haptic feedback on its window.
       */
      public boolean performHapticFeedback(int uid, String packageName, int effectId,
              boolean always, String reason);
  
      /**
       * Called when we have started keeping the screen on because a window
       * requesting this has become visible.
       */
      public void keepScreenOnStartedLw();
  
      /**
       * Called when we have stopped keeping the screen on because the last window
       * requesting this is no longer visible.
       */
      public void keepScreenOnStoppedLw();
  
      /**
       * Called by System UI to notify of changes to the visibility of Recents.
       */
      public void setRecentsVisibilityLw(boolean visible);
  
      /**
       * Called by System UI to notify of changes to the visibility of PIP.
       */
      void setPipVisibilityLw(boolean visible);
  
      /**
       * Called by System UI to enable or disable haptic feedback on the navigation bar buttons.
       */
      void setNavBarVirtualKeyHapticFeedbackEnabledLw(boolean enabled);
  
      /**
       * Specifies whether there is an on-screen navigation bar separate from the status bar.
       */
      public boolean hasNavigationBar();
  
      /**
       * Lock the device now.
       */
      public void lockNow(Bundle options);
  
      /**
       * An internal callback (from InputMethodManagerService) to notify a state change regarding
       * whether the back key should dismiss the software keyboard (IME) or not.
       *
       * @param newValue {@code true} if the software keyboard is shown and the back key is expected
       *                 to dismiss the software keyboard.
       * @hide
       */
      default void setDismissImeOnBackKeyPressed(boolean newValue) {
          // Default implementation does nothing.
      }
  
      /**
       * Show the recents task list app.
       * @hide
       */
      public void showRecentApps();
  
      /**
       * Show the global actions dialog.
       * @hide
       */
      public void showGlobalActions();
  
      /**
       * Returns whether the user setup is complete.
       */
      boolean isUserSetupComplete();
  
      /**
       * Returns the current UI mode.
       */
      int getUiMode();
  
      /**
       * Called when the current user changes. Guaranteed to be called before the broadcast
       * of the new user id is made to all listeners.
       *
       * @param newUserId The id of the incoming user.
       */
      public void setCurrentUserLw(int newUserId);
  
      /**
       * For a given user-switch operation, this will be called once with switching=true before the
       * user-switch and once with switching=false afterwards (or if the user-switch was cancelled).
       * This gives the policy a chance to alter its behavior for the duration of a user-switch.
       *
       * @param switching true if a user-switch is in progress
       */
      void setSwitchingUser(boolean switching);
  
      /**
       * Print the WindowManagerPolicy's state into the given stream.
       *
       * @param prefix Text to print at the front of each line.
       * @param writer The PrintWriter to which you should dump your state.  This will be
       * closed for you after you return.
       * @param args additional arguments to the dump request.
       */
      public void dump(String prefix, PrintWriter writer, String[] args);
  
      /**
       * Write the WindowManagerPolicy's state into the protocol buffer.
       * The message is described in {@link com.android.server.wm.WindowManagerPolicyProto}
       *
       * @param proto The protocol buffer output stream to write to.
       */
      void writeToProto(ProtoOutputStream proto, long fieldId);
  
      /**
       * Returns whether a given window type is considered a top level one.
       * A top level window does not have a container, i.e. attached window,
       * or if it has a container it is laid out as a top-level window, not
       * as a child of its container.
       *
       * @param windowType The window type.
       * @return True if the window is a top level one.
       */
      public boolean isTopLevelWindow(int windowType);
  
      /**
       * Notifies the keyguard to start fading out.
       *
       * @param startTime the start time of the animation in uptime milliseconds
       * @param fadeoutDuration the duration of the exit animation, in milliseconds
       */
      public void startKeyguardExitAnimation(long startTime, long fadeoutDuration);
  
      /**
       * Called when System UI has been started.
       */
      void onSystemUiStarted();
  
      /**
       * Checks whether the policy is ready for dismissing the boot animation and completing the boot.
       *
       * @return true if ready; false otherwise.
       */
      boolean canDismissBootAnimation();
  
      /**
       * Convert the user rotation mode to a human readable format.
       */
      static String userRotationModeToString(int mode) {
          switch(mode) {
              case USER_ROTATION_FREE:
                  return "USER_ROTATION_FREE";
              case USER_ROTATION_LOCKED:
                  return "USER_ROTATION_LOCKED";
              default:
                  return Integer.toString(mode);
          }
      }
  
      /**
       * Requests that the WindowManager sends
       * WindowManagerPolicyConstants#ACTION_USER_ACTIVITY_NOTIFICATION on the next user activity.
       */
      public void requestUserActivityNotification();
  
      /**
       * Registers an IDisplayFoldListener.
       */
      default void registerDisplayFoldListener(IDisplayFoldListener listener) {}
  
      /**
       * Unregisters an IDisplayFoldListener.
       */
      default void unregisterDisplayFoldListener(IDisplayFoldListener listener) {}
  
      /**
       * Overrides the folded area.
       *
       * @param area the overriding folded area or an empty {@code Rect} to clear the override.
       */
      default void setOverrideFoldedArea(@NonNull Rect area) {}
  
      /**
       * Get the display folded area.
       */
      default @NonNull Rect getFoldedArea() {
          return new Rect();
      }
  
      /**
       * A new window on default display has been focused.
       */
      default void onDefaultDisplayFocusChangedLw(WindowState newFocus) {}
  
      /**
       * Updates the flag about whether AOD is showing.
       *
       * @return whether the value was changed.
       */
      boolean setAodShowing(boolean aodShowing);
  }
  