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. * *
The current suffixes are: * *
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 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 return canAddInternalSystemWindow ? 11 : 10; case TYPE_APPLICATION_OVERLAY: return 12; case TYPE_DREAM: // used for Dreams (screensavers with TYPE_DREAM windows) return 13; case TYPE_INPUT_METHOD: // on-screen keyboards and other such input method user interfaces go here. return 14; case TYPE_INPUT_METHOD_DIALOG: // on-screen keyboards and other such input method user interfaces go here. return 15; case TYPE_STATUS_BAR_SUB_PANEL: return 17; case TYPE_STATUS_BAR: return 18; case TYPE_STATUS_BAR_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; } } int APPLICATION_LAYER = 2; int APPLICATION_MEDIA_SUBLAYER = -2; int APPLICATION_MEDIA_OVERLAY_SUBLAYER = -1; int APPLICATION_PANEL_SUBLAYER = 1; int APPLICATION_SUB_PANEL_SUBLAYER = 2; int APPLICATION_ABOVE_SUB_PANEL_SUBLAYER = 3; /** * 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 the display width available after excluding any screen * decorations that could never be removed in Honeycomb. That is, system bar or * button bar. */ public int getNonDecorDisplayWidth(int fullWidth, int fullHeight, int rotation, int uiMode, int displayId); /** * Return the display height available after excluding any screen * decorations that could never be removed in Honeycomb. That is, system bar or * button bar. */ public int getNonDecorDisplayHeight(int fullWidth, int fullHeight, int rotation, int uiMode, int displayId); /** * Return the available screen width that we should report for the * configuration. This must be no larger than * {@link #getNonDecorDisplayWidth(int, int, int)}; it may be smaller than * that to account for more transient decoration like a status bar. */ public int getConfigDisplayWidth(int fullWidth, int fullHeight, int rotation, int uiMode, int displayId); /** * Return the available screen height that we should report for the * configuration. This must be no larger than * {@link #getNonDecorDisplayHeight(int, int, int)}; it may be smaller than * that to account for more transient decoration like a status bar. */ public int getConfigDisplayHeight(int fullWidth, int fullHeight, int rotation, int uiMode, int displayId); /** * 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); /** * Prepare for a window being added to the window manager. You can throw an * exception here to prevent the window being added, or do whatever setup * you need to keep track of the window. * * @param win The window being added. * @param attrs The window's LayoutParams. * * @return {@link WindowManagerGlobal#ADD_OKAY} if the add can proceed, else an * error code to abort the add. */ public int prepareAddWindowLw(WindowState win, WindowManager.LayoutParams attrs); /** * Called when a window is being removed from a window manager. Must not * throw an exception -- clean up as much as possible. * * @param win The window being removed. */ public void removeWindowLw(WindowState win); /** * Control the animation to run when a window's state changes. Return a * non-0 number to force the animation to a specific resource ID, or 0 * to use the default animation. * * @param win The window that is changing. * @param transit What is happening to the window: {@link #TRANSIT_ENTER}, * {@link #TRANSIT_EXIT}, {@link #TRANSIT_SHOW}, or * {@link #TRANSIT_HIDE}. * * @return Resource ID of the actual animation to use, or 0 for none. */ public int selectAnimationLw(WindowState win, int transit); /** * Determine the animation to run for a rotation transition based on the * top fullscreen windows {@link WindowManager.LayoutParams#rotationAnimation} * and whether it is currently fullscreen and frontmost. * * @param anim The exiting animation resource id is stored in anim[0], the * entering animation resource id is stored in anim[1]. */ public void selectRotationAnimationLw(int anim[]); /** * Validate whether the current top fullscreen has specified the same * {@link WindowManager.LayoutParams#rotationAnimation} value as that * being passed in from the previous top fullscreen window. * * @param exitAnimId exiting resource id from the previous window. * @param enterAnimId entering resource id from the previous window. * @param forceDefault For rotation animations only, if true ignore the * animation values and just return false. * @return true if the previous values are still valid, false if they * should be replaced with the default. */ public boolean validateRotationAnimationLw(int exitAnimId, int enterAnimId, boolean forceDefault); /** * Create and return an animation to re-display a window that was force hidden by Keyguard. */ public Animation createHiddenByKeyguardExit(boolean onWallpaper, boolean goingToNotificationShade); /** * 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. * *
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. * *
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 policyFlags The policy flags associated with the motion. * * @return Actions flags: may be {@link #ACTION_PASS_TO_USER}. */ public int interceptMotionBeforeQueueingNonInteractive(long whenNanos, int policyFlags); /** * Called from the input dispatcher thread before a key is dispatched to a window. * *
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. * *
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 layout of the windows is about to start. * * @param isDefaultDisplay true if window is on {@link Display#DEFAULT_DISPLAY}. * @param displayWidth The current full width of the screen. * @param displayHeight The current full height of the screen. * @param displayRotation The current rotation being applied to the base window. * @param uiMode The current uiMode in configuration. */ public void beginLayoutLw(boolean isDefaultDisplay, int displayWidth, int displayHeight, int displayRotation, int uiMode); /** * Returns the bottom-most layer of the system decor, above which no policy decor should * be applied. */ public int getSystemDecorLayerLw(); /** * Return the rectangle of the screen that is available for applications to run in. * This will be called immediately after {@link #beginLayoutLw}. * * @param r The rectangle to be filled with the boundaries available to applications. */ public void getContentRectLw(Rect r); /** * Called for each window attached to the window manager as layout is * proceeding. The implementation of this function must take care of * setting the window's frame, either here or in finishLayout(). * * @param win The window being positioned. * @param attached For sub-windows, the window it is attached to; this * window will already have had layoutWindow() called on it * so you can use its Rect. Otherwise null. */ public void layoutWindowLw(WindowState win, WindowState attached); /** * Return the insets for the areas covered by system windows. These values * are computed on the most recent layout, so they are not guaranteed to * be correct. * * @param attrs The LayoutParams of the window. * @param taskBounds The bounds of the task this window is on or {@code null} if no task is * associated with the window. * @param displayRotation Rotation of the display. * @param displayWidth The width of the display. * @param displayHeight The height of the display. * @param outContentInsets The areas covered by system windows, expressed as positive insets. * @param outStableInsets The areas covered by stable system windows irrespective of their * current visibility. Expressed as positive insets. * @param outOutsets The areas that are not real display, but we would like to treat as such. * @return Whether to always consume the navigation bar. * See {@link #isNavBarForcedShownLw(WindowState)}. */ public boolean getInsetHintLw(WindowManager.LayoutParams attrs, Rect taskBounds, int displayRotation, int displayWidth, int displayHeight, Rect outContentInsets, Rect outStableInsets, Rect outOutsets); /** * Called when layout of the windows is finished. After this function has * returned, all windows given to layoutWindow() must have had a * frame assigned. */ public void finishLayoutLw(); /** Layout state may have changed (so another layout will be performed) */ static final int FINISH_LAYOUT_REDO_LAYOUT = 0x0001; /** Configuration state may have changed */ static final int FINISH_LAYOUT_REDO_CONFIG = 0x0002; /** Wallpaper may need to move */ static final int FINISH_LAYOUT_REDO_WALLPAPER = 0x0004; /** Need to recompute animations */ static final int FINISH_LAYOUT_REDO_ANIM = 0x0008; /** * Called following layout of all windows before each window has policy applied. * * @param displayWidth The current full width of the screen. * @param displayHeight The current full height of the screen. */ public void beginPostLayoutPolicyLw(int displayWidth, int displayHeight); /** * Called following layout of all window to apply policy to each window. * * @param win The window being positioned. * @param attrs The LayoutParams of the window. * @param attached For sub-windows, the window it is attached to. Otherwise null. */ public void applyPostLayoutPolicyLw(WindowState win, WindowManager.LayoutParams attrs, WindowState attached, WindowState imeTarget); /** * Called following layout of all windows and after policy has been applied * to each window. If in this function you do * something that may have modified the animation state of another window, * be sure to return non-zero in order to perform another pass through layout. * * @return Return any bit set of {@link #FINISH_LAYOUT_REDO_LAYOUT}, * {@link #FINISH_LAYOUT_REDO_CONFIG}, {@link #FINISH_LAYOUT_REDO_WALLPAPER}, * or {@link #FINISH_LAYOUT_REDO_ANIM}. */ public int finishPostLayoutPolicyLw(); /** * Return true if it is okay to perform animations for an app transition * that is about to occur. You may return false for this if, for example, * the lock screen is currently displayed so the switch should happen * immediately. */ public boolean allowAppAnimationsLw(); /** * A new window has been focused. */ public int focusChangedLw(WindowState lastFocus, WindowState newFocus); /** * Called when the device has started waking up. */ public void startedWakingUp(); /** * Called when the device has finished waking up. */ public void finishedWakingUp(); /** * 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 WindowManagerPolicy#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. */ public void dismissKeyguardLw(@Nullable IKeyguardDismissCallback callback); /** * 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(); public boolean isShowingDreamLw(); /** * Given an orientation constant, returns the appropriate surface rotation, * taking into account sensors, docking mode, rotation lock, and other factors. * * @param orientation An orientation constant, such as * {@link android.content.pm.ActivityInfo#SCREEN_ORIENTATION_LANDSCAPE}. * @param lastRotation The most recently used rotation. * @return The surface rotation to use. */ public int rotationForOrientationLw(@ActivityInfo.ScreenOrientation int orientation, int lastRotation); /** * Given an orientation constant and a rotation, returns true if the rotation * has compatible metrics to the requested orientation. For example, if * the application requested landscape and got seascape, then the rotation * has compatible metrics; if the application requested portrait and got landscape, * then the rotation has incompatible metrics; if the application did not specify * a preference, then anything goes. * * @param orientation An orientation constant, such as * {@link android.content.pm.ActivityInfo#SCREEN_ORIENTATION_LANDSCAPE}. * @param rotation The rotation to check. * @return True if the rotation is compatible with the requested orientation. */ public boolean rotationHasCompatibleMetricsLw(@ActivityInfo.ScreenOrientation int orientation, int rotation); /** * Called by the window manager when the rotation changes. * * @param rotation The new rotation. */ public void setRotationLw(int rotation); /** * 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(); public void setCurrentOrientationLw(@ActivityInfo.ScreenOrientation int newOrientation); /** * Call from application to perform haptic feedback on its window. */ public boolean performHapticFeedbackLw(WindowState win, int effectId, boolean always); /** * 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(); /** * Gets the current user rotation mode. * * @return The rotation mode. * * @see WindowManagerPolicy#USER_ROTATION_LOCKED * @see WindowManagerPolicy#USER_ROTATION_FREE */ @UserRotationMode public int getUserRotationMode(); /** * Inform the policy that the user has chosen a preferred orientation ("rotation lock"). * * @param mode One of {@link WindowManagerPolicy#USER_ROTATION_LOCKED} or * {@link WindowManagerPolicy#USER_ROTATION_FREE}. * @param rotation One of {@link Surface#ROTATION_0}, {@link Surface#ROTATION_90}, * {@link Surface#ROTATION_180}, {@link Surface#ROTATION_270}. */ public void setUserRotationMode(@UserRotationMode int mode, @Surface.Rotation int rotation); /** * Called when a new system UI visibility is being reported, allowing * the policy to adjust what is actually reported. * @param visibility The raw visibility reported by the status bar. * @return The new desired visibility. */ public int adjustSystemUiVisibilityLw(int visibility); /** * 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); /** * 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); /** * Set the last used input method window state. This state is used to make IME transition * smooth. * @hide */ public void setLastInputMethodWindowLw(WindowState ime, WindowState target); /** * 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(boolean fromHome); /** * Show the global actions dialog. * @hide */ public void showGlobalActions(); /** * @return The current height of the input method window. */ public int getInputMethodWindowVisibleHeightLw(); /** * 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); /** * Returns whether a given window type can be magnified. * * @param windowType The window type. * @return True if the window can be magnified. */ public boolean canMagnifyWindow(int windowType); /** * 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); /** * Calculates the stable insets without running a layout. * * @param displayRotation the current display rotation * @param displayWidth the current display width * @param displayHeight the current display height * @param outInsets the insets to return */ public void getStableInsetsLw(int displayRotation, int displayWidth, int displayHeight, Rect outInsets); /** * @return true if the navigation bar is forced to stay visible */ public boolean isNavBarForcedShownLw(WindowState win); /** * @return The side of the screen where navigation bar is positioned. * @see #NAV_BAR_LEFT * @see #NAV_BAR_RIGHT * @see #NAV_BAR_BOTTOM */ int getNavBarPosition(); /** * Calculates the insets for the areas that could never be removed in Honeycomb, i.e. system * bar or button bar. See {@link #getNonDecorDisplayWidth}. * * @param displayRotation the current display rotation * @param displayWidth the current display width * @param displayHeight the current display height * @param outInsets the insets to return */ public void getNonDecorInsetsLw(int displayRotation, int displayWidth, int displayHeight, Rect outInsets); /** * @return True if a specified {@param dockSide} is allowed on the current device, or false * otherwise. It is guaranteed that at least one dock side for a particular orientation * is allowed, so for example, if DOCKED_RIGHT is not allowed, DOCKED_LEFT is allowed. */ public boolean isDockSideAllowed(int dockSide); /** * Called when the configuration has changed, and it's safe to load new values from resources. */ public void onConfigurationChanged(); public boolean shouldRotateSeamlessly(int oldRotation, int newRotation); /** * 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(); }