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 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) { return getWindowLayerFromTypeLw(type, canAddInternalSystemWindow, false /* roundedCornerOverlay */); } /** * 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. * @param roundedCornerOverlay {#code true} to indicate that the owner window is rounded corner * overlay. * @return int An arbitrary integer used to order windows, with lower numbers below higher ones. */ default int getWindowLayerFromTypeLw(int type, boolean canAddInternalSystemWindow, boolean roundedCornerOverlay) { // Always put the rounded corner layer to the top most. if (roundedCornerOverlay && canAddInternalSystemWindow) { return getMaxWindowLayer(); } 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: case TYPE_DOCK_DIVIDER: case TYPE_QS_DIALOG: case TYPE_PHONE: return 3; case TYPE_SEARCH_BAR: return 4; case TYPE_INPUT_CONSUMER: return 5; case TYPE_SYSTEM_DIALOG: return 6; case TYPE_TOAST: if (Flags.bugToastsOnTopOfBubble()) { // system added toasts must be on top of any always-on-top windows. // toasts and the plugged-in battery thing // canAddInternalSystemWindow is to distinguish between legacy toasts and ones // managed by the system. A legacy toast can have an arbitrary view and tap jack // other views. Toasts are given low priority to prevent this. Toasts added by // the system are safe and can have higher visibility. return canAddInternalSystemWindow ? 27 : 7; } else { // toasts and the plugged-in battery thing return 7; } case TYPE_PRIORITY_PHONE: // SIM errors and unlock. Not sure if this really should be in a high layer. return 8; 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 ? 12 : 9; case TYPE_APPLICATION_OVERLAY: return 11; case TYPE_INPUT_METHOD: // on-screen keyboards and other such input method user interfaces go here. return 13; case TYPE_INPUT_METHOD_DIALOG: // on-screen keyboards and other such input method user interfaces go here. return 14; case TYPE_STATUS_BAR: return 15; case TYPE_STATUS_BAR_ADDITIONAL: return 16; case TYPE_NOTIFICATION_SHADE: return 17; case TYPE_STATUS_BAR_SUB_PANEL: return 18; case TYPE_KEYGUARD_DIALOG: return 19; case TYPE_VOICE_INTERACTION_STARTING: return 20; case TYPE_VOICE_INTERACTION: // voice interaction layer should show above the lock screen. return 21; case TYPE_VOLUME_OVERLAY: // the on-screen volume indicator and controller shown when the user // changes the device volume return 22; case TYPE_SYSTEM_OVERLAY: // the on-screen volume indicator and controller shown when the user // changes the device volume return canAddInternalSystemWindow ? 23 : 10; case TYPE_NAVIGATION_BAR: // the navigation bar, if available, shows atop most things return 24; case TYPE_NAVIGATION_BAR_PANEL: // some panels (e.g. search) need to show on top of the navigation bar return 25; case TYPE_SCREENSHOT: // screenshot selection layer shouldn't go above system error, but it should cover // navigation bars at the very least. return 26; case TYPE_SYSTEM_ERROR: // system-level error dialogs return canAddInternalSystemWindow ? 27 : 9; case TYPE_MAGNIFICATION_OVERLAY: // used to highlight the magnified portion of a display return 28; case TYPE_DISPLAY_OVERLAY: // used to simulate secondary display devices return 29; case TYPE_DRAG: // the drag layer: input for drag-and-drop is associated with this window, // which sits above all other focusable windows return 30; case TYPE_ACCESSIBILITY_OVERLAY: // overlay put by accessibility services to intercept user interaction return 31; case TYPE_ACCESSIBILITY_MAGNIFICATION_OVERLAY: return 32; case TYPE_SECURE_SYSTEM_OVERLAY: return 33; case TYPE_BOOT_PROGRESS: return 34; case TYPE_POINTER: // the (mouse) pointer layer return 35; default: Slog.e("WindowManager", "Unknown window type: " + type); return 3; } } // TODO(b/155340867): consider to remove the logic after using pure Surface for rounded corner // overlay. /** * Returns the max window layer. *
Note that the max window layer should be higher that the maximum value which reported * by {@link #getWindowLayerFromTypeLw(int, boolean)} to contain rounded corner overlay.
* * @see WindowManager.LayoutParams#PRIVATE_FLAG_IS_ROUNDED_CORNERS_OVERLAY */ default int getMaxWindowLayer() { return 36; } /** * 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; } /** * Return whether the given window can become the Keyguard window. Typically returns true for * the StatusBar. */ public boolean isKeyguardHostWindow(WindowManager.LayoutParams attrs); /** * 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. * *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); /** * Return the set of applicaition launch keyboard shortcuts the system supports. * * @param deviceId The id of the {@link InputDevice} that will trigger the shortcut. * * @return {@link KeyboardShortcutGroup} containing the shortcuts. */ KeyboardShortcutGroup getApplicationLaunchKeyboardShortcuts(int deviceId); /** * 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 displayId The display ID of the motion event. * @param source the {@link InputDevice} source that caused the motion. * @param action the {@link MotionEvent} action for the motion. * @param policyFlags The policy flags associated with the motion. * * @return Actions flags: may be {@link #ACTION_PASS_TO_USER}. */ int interceptMotionBeforeQueueingNonInteractive(int displayId, int source, int action, 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 focusedToken Client window token that currently has focus. This is where the key * event will normally go. * @param event The key event. * @return {@code true} if consumed, and {@code false} otherwise. */ boolean interceptKeyBeforeDispatching(IBinder focusedToken, KeyEvent event); /** * 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 focusedToken Client window token that currently has focus. This is where the key * event will normally go. * @param event The key event. * @return true if the unhandled key is intercepted by the policy. */ boolean interceptUnhandledKey(KeyEvent event, IBinder focusedToken); /** * Called when the top focused display is changed. * * @param displayId The ID of the top focused display. */ void setTopFocusedDisplay(int displayId); /** * 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 global wakefulness is becoming awake. * * @param reason One of PowerManager.WAKE_REASON_*, detailing the reason for the change. */ void startedWakingUpGlobal(@PowerManager.WakeReason int reason); /** * Called when the global wakefulness has finished becoming awake. * * @param reason One of PowerManager.WAKE_REASON_*, detailing the reason for the change. */ void finishedWakingUpGlobal(@PowerManager.WakeReason int reason); /** * Called when the global wakefulness has started going to sleep. * * @param reason One of PowerManager.WAKE_REASON_*, detailing the reason for the change. */ void startedGoingToSleepGlobal(@PowerManager.GoToSleepReason int reason); /** * Called when the global wakefulness has finished going to sleep. * * @param reason One of PowerManager.WAKE_REASON_*, detailing the reason for the change. */ void finishedGoingToSleepGlobal(@PowerManager.GoToSleepReason int reason); /** * Called when the device has started waking up. * * @param displayGroupId The id of the display group that has started waking up. This will often * be {@link Display#DEFAULT_DISPLAY_GROUP}, but it is possible for other * display groups to exist, for example when there is a * {@link VirtualDevice} with one or more {@link VirtualDisplay}s. * @param pmWakeReason One of PowerManager.WAKE_REASON_*, detailing the specific reason this * display group is waking up, such as WAKE_REASON_POWER_BUTTON or * WAKE_REASON_GESTURE. */ void startedWakingUp(int displayGroupId, @PowerManager.WakeReason int pmWakeReason); /** * Called when the device has finished waking up. * * @param displayGroupId The id of the display group that has finished waking. This will often * be {@link Display#DEFAULT_DISPLAY_GROUP}, but it is possible for other * display groups to exist, for example when there is a * {@link VirtualDevice} with one or more {@link VirtualDisplay}s. * @param pmWakeReason One of PowerManager.WAKE_REASON_*, detailing the specific reason this * display group is waking up, such as WAKE_REASON_POWER_BUTTON or * WAKE_REASON_GESTURE. */ void finishedWakingUp(int displayGroupId, @PowerManager.WakeReason int pmWakeReason); /** * Called when the device has started going to sleep. * * @param displayGroupId The id of the display group that has started going to sleep. This * will often be {@link Display#DEFAULT_DISPLAY_GROUP}, but it is * possible for other display groups to exist, for example when there is a * {@link VirtualDevice} with one or more {@link VirtualDisplay}s. * @param pmSleepReason One of PowerManager.GO_TO_SLEEP_REASON_*, detailing the specific reason * this display group is going to sleep, such as * GO_TO_SLEEP_REASON_POWER_BUTTON or GO_TO_SLEEP_REASON_TIMEOUT. */ void startedGoingToSleep(int displayGroupId, @PowerManager.GoToSleepReason int pmSleepReason); /** * Called when the device has finished going to sleep. * * @param displayGroupId The id of the display group that has finished going to sleep. This * will often be {@link Display#DEFAULT_DISPLAY_GROUP}, but it is * possible for other display groups to exist, for example when there is a * {@link VirtualDevice} with one or more {@link VirtualDisplay}s. * @param pmSleepReason One of PowerManager.GO_TO_SLEEP_REASON_*, detailing the specific reason * we're going to sleep, such as GO_TO_SLEEP_REASON_POWER_BUTTON or * GO_TO_SLEEP_REASON_TIMEOUT. */ void finishedGoingToSleep(int displayGroupId, @PowerManager.GoToSleepReason int pmSleepReason); /** * Called when the display is about to turn on 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(int displayId, ScreenOnListener screenOnListener); /** * Called when the display has actually turned on, i.e. the display power state has been set to * ON and the screen is unblocked. */ public void screenTurnedOn(int displayId); /** * 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(int displayId, ScreenOffListener screenOffListener); /** * Called when the display has turned off. * @param displayId The display to apply to. * @param isSwappingDisplay Whether the display is swapping to another physical display. */ void screenTurnedOff(int displayId, boolean isSwappingDisplay); public interface ScreenOnListener { void onScreenOn(); } /** * See {@link #screenTurnedOff} */ public interface ScreenOffListener { void onScreenOff(); } /** Called when the physical display starts to switch, e.g. fold/unfold. */ void onDisplaySwitchStart(int displayId); /** * Return whether the default display is on and not blocked by a black surface. * * @deprecated Use {@link #isScreenOn(int)} instead, to better support multi-display. */ @Deprecated default boolean isScreenOn() { return isScreenOn(Display.DEFAULT_DISPLAY); } /** * Return whether the specified display is on and not blocked by a black surface. */ boolean isScreenOn(int displayId); /** * @param ignoreScreenOn {@code true} if screen state should be ignored. * @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(boolean ignoreScreenOn); /** * 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. */ boolean isKeyguardShowing(); /** * @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. */ void userActivity(int displayGroupId, int event); /** * 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(); /** * 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 android.internal.perfetto.protos.Windowmanagerservice.WindowManagerPolicyProto} * * @param proto The protocol buffer output stream to write to. */ void dumpDebug(ProtoOutputStream proto, long fieldId); /** * Notifies the keyguard to start fading out. * @param startTime the start time of the animation in uptime milliseconds * */ void startKeyguardExitAnimation(long startTime); /** * 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); } } /** * 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) {} /** * Returns {@code true} if the key will be handled globally and not forwarded to all apps. * * @param keyCode the key code to check * @return {@code true} if the key will be handled globally. */ boolean isGlobalKey(int keyCode); }