1 /* 2 * Copyright (C) 2006 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package android.view; 18 19 import android.content.Context; 20 import android.content.res.CompatibilityInfo; 21 import android.content.res.Configuration; 22 import android.graphics.Rect; 23 import android.graphics.RectF; 24 import android.os.IBinder; 25 import android.os.LocalPowerManager; 26 import android.os.Looper; 27 import android.view.animation.Animation; 28 29 import java.io.FileDescriptor; 30 import java.io.PrintWriter; 31 32 /** 33 * This interface supplies all UI-specific behavior of the window manager. An 34 * instance of it is created by the window manager when it starts up, and allows 35 * customization of window layering, special window types, key dispatching, and 36 * layout. 37 * 38 * <p>Because this provides deep interaction with the system window manager, 39 * specific methods on this interface can be called from a variety of contexts 40 * with various restrictions on what they can do. These are encoded through 41 * a suffixes at the end of a method encoding the thread the method is called 42 * from and any locks that are held when it is being called; if no suffix 43 * is attached to a method, then it is not called with any locks and may be 44 * called from the main window manager thread or another thread calling into 45 * the window manager. 46 * 47 * <p>The current suffixes are: 48 * 49 * <dl> 50 * <dt> Ti <dd> Called from the input thread. This is the thread that 51 * collects pending input events and dispatches them to the appropriate window. 52 * It may block waiting for events to be processed, so that the input stream is 53 * properly serialized. 54 * <dt> Tq <dd> Called from the low-level input queue thread. This is the 55 * thread that reads events out of the raw input devices and places them 56 * into the global input queue that is read by the <var>Ti</var> thread. 57 * This thread should not block for a long period of time on anything but the 58 * key driver. 59 * <dt> Lw <dd> Called with the main window manager lock held. Because the 60 * window manager is a very low-level system service, there are few other 61 * system services you can call with this lock held. It is explicitly okay to 62 * make calls into the package manager and power manager; it is explicitly not 63 * okay to make calls into the activity manager or most other services. Note that 64 * {@link android.content.Context#checkPermission(String, int, int)} and 65 * variations require calling into the activity manager. 66 * <dt> Li <dd> Called with the input thread lock held. This lock can be 67 * acquired by the window manager while it holds the window lock, so this is 68 * even more restrictive than <var>Lw</var>. 69 * </dl> 70 * 71 * @hide 72 */ 73 public interface WindowManagerPolicy { 74 // Policy flags. These flags are also defined in frameworks/base/include/ui/Input.h. 75 public final static int FLAG_WAKE = 0x00000001; 76 public final static int FLAG_WAKE_DROPPED = 0x00000002; 77 public final static int FLAG_SHIFT = 0x00000004; 78 public final static int FLAG_CAPS_LOCK = 0x00000008; 79 public final static int FLAG_ALT = 0x00000010; 80 public final static int FLAG_ALT_GR = 0x00000020; 81 public final static int FLAG_MENU = 0x00000040; 82 public final static int FLAG_LAUNCHER = 0x00000080; 83 public final static int FLAG_VIRTUAL = 0x00000100; 84 85 public final static int FLAG_INJECTED = 0x01000000; 86 public final static int FLAG_TRUSTED = 0x02000000; 87 public final static int FLAG_FILTERED = 0x04000000; 88 public final static int FLAG_DISABLE_KEY_REPEAT = 0x08000000; 89 90 public final static int FLAG_WOKE_HERE = 0x10000000; 91 public final static int FLAG_BRIGHT_HERE = 0x20000000; 92 public final static int FLAG_PASS_TO_USER = 0x40000000; 93 94 public final static boolean WATCH_POINTER = false; 95 96 /** 97 * Sticky broadcast of the current HDMI plugged state. 98 */ 99 public final static String ACTION_HDMI_PLUGGED = "android.intent.action.HDMI_PLUGGED"; 100 101 /** 102 * Extra in {@link #ACTION_HDMI_PLUGGED} indicating the state: true if 103 * plugged in to HDMI, false if not. 104 */ 105 public final static String EXTRA_HDMI_PLUGGED_STATE = "state"; 106 107 /** 108 * Pass this event to the user / app. To be returned from 109 * {@link #interceptKeyBeforeQueueing}. 110 */ 111 public final static int ACTION_PASS_TO_USER = 0x00000001; 112 113 /** 114 * This key event should extend the user activity timeout and turn the lights on. 115 * To be returned from {@link #interceptKeyBeforeQueueing}. 116 * Do not return this and {@link #ACTION_GO_TO_SLEEP} or {@link #ACTION_PASS_TO_USER}. 117 */ 118 public final static int ACTION_POKE_USER_ACTIVITY = 0x00000002; 119 120 /** 121 * This key event should put the device to sleep (and engage keyguard if necessary) 122 * To be returned from {@link #interceptKeyBeforeQueueing}. 123 * Do not return this and {@link #ACTION_POKE_USER_ACTIVITY} or {@link #ACTION_PASS_TO_USER}. 124 */ 125 public final static int ACTION_GO_TO_SLEEP = 0x00000004; 126 127 /** 128 * Interface to the Window Manager state associated with a particular 129 * window. You can hold on to an instance of this interface from the call 130 * to prepareAddWindow() until removeWindow(). 131 */ 132 public interface WindowState { 133 /** 134 * Perform standard frame computation. The result can be obtained with 135 * getFrame() if so desired. Must be called with the window manager 136 * lock held. 137 * 138 * @param parentFrame The frame of the parent container this window 139 * is in, used for computing its basic position. 140 * @param displayFrame The frame of the overall display in which this 141 * window can appear, used for constraining the overall dimensions 142 * of the window. 143 * @param contentFrame The frame within the display in which we would 144 * like active content to appear. This will cause windows behind to 145 * be resized to match the given content frame. 146 * @param visibleFrame The frame within the display that the window 147 * is actually visible, used for computing its visible insets to be 148 * given to windows behind. 149 * This can be used as a hint for scrolling (avoiding resizing) 150 * the window to make certain that parts of its content 151 * are visible. 152 */ 153 public void computeFrameLw(Rect parentFrame, Rect displayFrame, 154 Rect contentFrame, Rect visibleFrame); 155 156 /** 157 * Retrieve the current frame of the window that has been assigned by 158 * the window manager. Must be called with the window manager lock held. 159 * 160 * @return Rect The rectangle holding the window frame. 161 */ 162 public Rect getFrameLw(); 163 164 /** 165 * Retrieve the current frame of the window that is actually shown. 166 * Must be called with the window manager lock held. 167 * 168 * @return Rect The rectangle holding the shown window frame. 169 */ 170 public RectF getShownFrameLw(); 171 172 /** 173 * Retrieve the frame of the display that this window was last 174 * laid out in. Must be called with the 175 * window manager lock held. 176 * 177 * @return Rect The rectangle holding the display frame. 178 */ 179 public Rect getDisplayFrameLw(); 180 181 /** 182 * Retrieve the frame of the content area that this window was last 183 * laid out in. This is the area in which the content of the window 184 * should be placed. It will be smaller than the display frame to 185 * account for screen decorations such as a status bar or soft 186 * keyboard. Must be called with the 187 * window manager lock held. 188 * 189 * @return Rect The rectangle holding the content frame. 190 */ 191 public Rect getContentFrameLw(); 192 193 /** 194 * Retrieve the frame of the visible area that this window was last 195 * laid out in. This is the area of the screen in which the window 196 * will actually be fully visible. It will be smaller than the 197 * content frame to account for transient UI elements blocking it 198 * such as an input method's candidates UI. Must be called with the 199 * window manager lock held. 200 * 201 * @return Rect The rectangle holding the visible frame. 202 */ 203 public Rect getVisibleFrameLw(); 204 205 /** 206 * Returns true if this window is waiting to receive its given 207 * internal insets from the client app, and so should not impact the 208 * layout of other windows. 209 */ 210 public boolean getGivenInsetsPendingLw(); 211 212 /** 213 * Retrieve the insets given by this window's client for the content 214 * area of windows behind it. Must be called with the 215 * window manager lock held. 216 * 217 * @return Rect The left, top, right, and bottom insets, relative 218 * to the window's frame, of the actual contents. 219 */ 220 public Rect getGivenContentInsetsLw(); 221 222 /** 223 * Retrieve the insets given by this window's client for the visible 224 * area of windows behind it. Must be called with the 225 * window manager lock held. 226 * 227 * @return Rect The left, top, right, and bottom insets, relative 228 * to the window's frame, of the actual visible area. 229 */ 230 public Rect getGivenVisibleInsetsLw(); 231 232 /** 233 * Retrieve the current LayoutParams of the window. 234 * 235 * @return WindowManager.LayoutParams The window's internal LayoutParams 236 * instance. 237 */ 238 public WindowManager.LayoutParams getAttrs(); 239 240 /** 241 * Return whether this window needs the menu key shown. Must be called 242 * with window lock held, because it may need to traverse down through 243 * window list to determine the result. 244 * @param bottom The bottom-most window to consider when determining this. 245 */ 246 public boolean getNeedsMenuLw(WindowState bottom); 247 248 /** 249 * Retrieve the current system UI visibility flags associated with 250 * this window. 251 */ 252 public int getSystemUiVisibility(); 253 254 /** 255 * Get the layer at which this window's surface will be Z-ordered. 256 */ 257 public int getSurfaceLayer(); 258 259 /** 260 * Return the token for the application (actually activity) that owns 261 * this window. May return null for system windows. 262 * 263 * @return An IApplicationToken identifying the owning activity. 264 */ 265 public IApplicationToken getAppToken(); 266 267 /** 268 * Return true if, at any point, the application token associated with 269 * this window has actually displayed any windows. This is most useful 270 * with the "starting up" window to determine if any windows were 271 * displayed when it is closed. 272 * 273 * @return Returns true if one or more windows have been displayed, 274 * else false. 275 */ 276 public boolean hasAppShownWindows(); 277 278 /** 279 * Is this window visible? It is not visible if there is no 280 * surface, or we are in the process of running an exit animation 281 * that will remove the surface. 282 */ 283 boolean isVisibleLw(); 284 285 /** 286 * Like {@link #isVisibleLw}, but also counts a window that is currently 287 * "hidden" behind the keyguard as visible. This allows us to apply 288 * things like window flags that impact the keyguard. 289 */ 290 boolean isVisibleOrBehindKeyguardLw(); 291 292 /** 293 * Is this window currently visible to the user on-screen? It is 294 * displayed either if it is visible or it is currently running an 295 * animation before no longer being visible. Must be called with the 296 * window manager lock held. 297 */ 298 boolean isDisplayedLw(); 299 300 /** 301 * Is this window considered to be gone for purposes of layout? 302 */ 303 boolean isGoneForLayoutLw(); 304 305 /** 306 * Returns true if this window has been shown on screen at some time in 307 * the past. Must be called with the window manager lock held. 308 * 309 * @return boolean 310 */ 311 public boolean hasDrawnLw(); 312 313 /** 314 * Can be called by the policy to force a window to be hidden, 315 * regardless of whether the client or window manager would like 316 * it shown. Must be called with the window manager lock held. 317 * Returns true if {@link #showLw} was last called for the window. 318 */ 319 public boolean hideLw(boolean doAnimation); 320 321 /** 322 * Can be called to undo the effect of {@link #hideLw}, allowing a 323 * window to be shown as long as the window manager and client would 324 * also like it to be shown. Must be called with the window manager 325 * lock held. 326 * Returns true if {@link #hideLw} was last called for the window. 327 */ 328 public boolean showLw(boolean doAnimation); 329 } 330 331 /** 332 * Representation of a "fake window" that the policy has added to the 333 * window manager to consume events. 334 */ 335 public interface FakeWindow { 336 /** 337 * Remove the fake window from the window manager. 338 */ 339 void dismiss(); 340 } 341 342 /** 343 * Interface for calling back in to the window manager that is private 344 * between it and the policy. 345 */ 346 public interface WindowManagerFuncs { 347 /** 348 * Ask the window manager to re-evaluate the system UI flags. 349 */ 350 public void reevaluateStatusBarVisibility(); 351 352 /** 353 * Add a fake window to the window manager. This window sits 354 * at the top of the other windows and consumes events. 355 */ 356 public FakeWindow addFakeWindow(Looper looper, InputHandler inputHandler, 357 String name, int windowType, int layoutParamsFlags, boolean canReceiveKeys, 358 boolean hasFocus, boolean touchFullscreen); 359 } 360 361 /** 362 * Bit mask that is set for all enter transition. 363 */ 364 public final int TRANSIT_ENTER_MASK = 0x1000; 365 366 /** 367 * Bit mask that is set for all exit transitions. 368 */ 369 public final int TRANSIT_EXIT_MASK = 0x2000; 370 371 /** Not set up for a transition. */ 372 public final int TRANSIT_UNSET = -1; 373 /** No animation for transition. */ 374 public final int TRANSIT_NONE = 0; 375 /** Window has been added to the screen. */ 376 public final int TRANSIT_ENTER = 1 | TRANSIT_ENTER_MASK; 377 /** Window has been removed from the screen. */ 378 public final int TRANSIT_EXIT = 2 | TRANSIT_EXIT_MASK; 379 /** Window has been made visible. */ 380 public final int TRANSIT_SHOW = 3 | TRANSIT_ENTER_MASK; 381 /** Window has been made invisible. */ 382 public final int TRANSIT_HIDE = 4 | TRANSIT_EXIT_MASK; 383 /** The "application starting" preview window is no longer needed, and will 384 * animate away to show the real window. */ 385 public final int TRANSIT_PREVIEW_DONE = 5; 386 /** A window in a new activity is being opened on top of an existing one 387 * in the same task. */ 388 public final int TRANSIT_ACTIVITY_OPEN = 6 | TRANSIT_ENTER_MASK; 389 /** The window in the top-most activity is being closed to reveal the 390 * previous activity in the same task. */ 391 public final int TRANSIT_ACTIVITY_CLOSE = 7 | TRANSIT_EXIT_MASK; 392 /** A window in a new task is being opened on top of an existing one 393 * in another activity's task. */ 394 public final int TRANSIT_TASK_OPEN = 8 | TRANSIT_ENTER_MASK; 395 /** A window in the top-most activity is being closed to reveal the 396 * previous activity in a different task. */ 397 public final int TRANSIT_TASK_CLOSE = 9 | TRANSIT_EXIT_MASK; 398 /** A window in an existing task is being displayed on top of an existing one 399 * in another activity's task. */ 400 public final int TRANSIT_TASK_TO_FRONT = 10 | TRANSIT_ENTER_MASK; 401 /** A window in an existing task is being put below all other tasks. */ 402 public final int TRANSIT_TASK_TO_BACK = 11 | TRANSIT_EXIT_MASK; 403 /** A window in a new activity that doesn't have a wallpaper is being 404 * opened on top of one that does, effectively closing the wallpaper. */ 405 public final int TRANSIT_WALLPAPER_CLOSE = 12 | TRANSIT_EXIT_MASK; 406 /** A window in a new activity that does have a wallpaper is being 407 * opened on one that didn't, effectively opening the wallpaper. */ 408 public final int TRANSIT_WALLPAPER_OPEN = 13 | TRANSIT_ENTER_MASK; 409 /** A window in a new activity is being opened on top of an existing one, 410 * and both are on top of the wallpaper. */ 411 public final int TRANSIT_WALLPAPER_INTRA_OPEN = 14 | TRANSIT_ENTER_MASK; 412 /** The window in the top-most activity is being closed to reveal the 413 * previous activity, and both are on top of he wallpaper. */ 414 public final int TRANSIT_WALLPAPER_INTRA_CLOSE = 15 | TRANSIT_EXIT_MASK; 415 416 // NOTE: screen off reasons are in order of significance, with more 417 // important ones lower than less important ones. 418 419 /** Screen turned off because of a device admin */ 420 public final int OFF_BECAUSE_OF_ADMIN = 1; 421 /** Screen turned off because of power button */ 422 public final int OFF_BECAUSE_OF_USER = 2; 423 /** Screen turned off because of timeout */ 424 public final int OFF_BECAUSE_OF_TIMEOUT = 3; 425 /** Screen turned off because of proximity sensor */ 426 public final int OFF_BECAUSE_OF_PROX_SENSOR = 4; 427 428 /** When not otherwise specified by the activity's screenOrientation, rotation should be 429 * determined by the system (that is, using sensors). */ 430 public final int USER_ROTATION_FREE = 0; 431 /** When not otherwise specified by the activity's screenOrientation, rotation is set by 432 * the user. */ 433 public final int USER_ROTATION_LOCKED = 1; 434 435 /** 436 * Perform initialization of the policy. 437 * 438 * @param context The system context we are running in. 439 * @param powerManager 440 */ 441 public void init(Context context, IWindowManager windowManager, 442 WindowManagerFuncs windowManagerFuncs, 443 LocalPowerManager powerManager); 444 445 /** 446 * Called by window manager once it has the initial, default native 447 * display dimensions. 448 */ 449 public void setInitialDisplaySize(int width, int height); 450 451 /** 452 * Check permissions when adding a window. 453 * 454 * @param attrs The window's LayoutParams. 455 * 456 * @return {@link WindowManagerImpl#ADD_OKAY} if the add can proceed; 457 * else an error code, usually 458 * {@link WindowManagerImpl#ADD_PERMISSION_DENIED}, to abort the add. 459 */ 460 public int checkAddPermission(WindowManager.LayoutParams attrs); 461 462 /** 463 * Sanitize the layout parameters coming from a client. Allows the policy 464 * to do things like ensure that windows of a specific type can't take 465 * input focus. 466 * 467 * @param attrs The window layout parameters to be modified. These values 468 * are modified in-place. 469 */ 470 public void adjustWindowParamsLw(WindowManager.LayoutParams attrs); 471 472 /** 473 * After the window manager has computed the current configuration based 474 * on its knowledge of the display and input devices, it gives the policy 475 * a chance to adjust the information contained in it. If you want to 476 * leave it as-is, simply do nothing. 477 * 478 * <p>This method may be called by any thread in the window manager, but 479 * no internal locks in the window manager will be held. 480 * 481 * @param config The Configuration being computed, for you to change as 482 * desired. 483 */ 484 public void adjustConfigurationLw(Configuration config); 485 486 /** 487 * Assign a window type to a layer. Allows you to control how different 488 * kinds of windows are ordered on-screen. 489 * 490 * @param type The type of window being assigned. 491 * 492 * @return int An arbitrary integer used to order windows, with lower 493 * numbers below higher ones. 494 */ 495 public int windowTypeToLayerLw(int type); 496 497 /** 498 * Return how to Z-order sub-windows in relation to the window they are 499 * attached to. Return positive to have them ordered in front, negative for 500 * behind. 501 * 502 * @param type The sub-window type code. 503 * 504 * @return int Layer in relation to the attached window, where positive is 505 * above and negative is below. 506 */ 507 public int subWindowTypeToLayerLw(int type); 508 509 /** 510 * Get the highest layer (actually one more than) that the wallpaper is 511 * allowed to be in. 512 */ 513 public int getMaxWallpaperLayer(); 514 515 /** 516 * Return true if the policy allows the status bar to hide. Otherwise, 517 * it is a tablet-style system bar. 518 */ 519 public boolean canStatusBarHide(); 520 521 /** 522 * Return the display width available after excluding any screen 523 * decorations that can never be removed. That is, system bar or 524 * button bar. 525 */ 526 public int getNonDecorDisplayWidth(int fullWidth, int fullHeight, int rotation); 527 528 /** 529 * Return the display height available after excluding any screen 530 * decorations that can never be removed. That is, system bar or 531 * button bar. 532 */ 533 public int getNonDecorDisplayHeight(int fullWidth, int fullHeight, int rotation); 534 535 /** 536 * Return the available screen width that we should report for the 537 * configuration. This must be no larger than 538 * {@link #getNonDecorDisplayWidth(int, int)}; it may be smaller than 539 * that to account for more transient decoration like a status bar. 540 */ 541 public int getConfigDisplayWidth(int fullWidth, int fullHeight, int rotation); 542 543 /** 544 * Return the available screen height that we should report for the 545 * configuration. This must be no larger than 546 * {@link #getNonDecorDisplayHeight(int, int)}; it may be smaller than 547 * that to account for more transient decoration like a status bar. 548 */ 549 public int getConfigDisplayHeight(int fullWidth, int fullHeight, int rotation); 550 551 /** 552 * Return whether the given window should forcibly hide everything 553 * behind it. Typically returns true for the keyguard. 554 */ 555 public boolean doesForceHide(WindowState win, WindowManager.LayoutParams attrs); 556 557 /** 558 * Determine if a window that is behind one that is force hiding 559 * (as determined by {@link #doesForceHide}) should actually be hidden. 560 * For example, typically returns false for the status bar. Be careful 561 * to return false for any window that you may hide yourself, since this 562 * will conflict with what you set. 563 */ 564 public boolean canBeForceHidden(WindowState win, WindowManager.LayoutParams attrs); 565 566 /** 567 * Called when the system would like to show a UI to indicate that an 568 * application is starting. You can use this to add a 569 * APPLICATION_STARTING_TYPE window with the given appToken to the window 570 * manager (using the normal window manager APIs) that will be shown until 571 * the application displays its own window. This is called without the 572 * window manager locked so that you can call back into it. 573 * 574 * @param appToken Token of the application being started. 575 * @param packageName The name of the application package being started. 576 * @param theme Resource defining the application's overall visual theme. 577 * @param nonLocalizedLabel The default title label of the application if 578 * no data is found in the resource. 579 * @param labelRes The resource ID the application would like to use as its name. 580 * @param icon The resource ID the application would like to use as its icon. 581 * @param windowFlags Window layout flags. 582 * 583 * @return Optionally you can return the View that was used to create the 584 * window, for easy removal in removeStartingWindow. 585 * 586 * @see #removeStartingWindow 587 */ 588 public View addStartingWindow(IBinder appToken, String packageName, 589 int theme, CompatibilityInfo compatInfo, CharSequence nonLocalizedLabel, 590 int labelRes, int icon, int windowFlags); 591 592 /** 593 * Called when the first window of an application has been displayed, while 594 * {@link #addStartingWindow} has created a temporary initial window for 595 * that application. You should at this point remove the window from the 596 * window manager. This is called without the window manager locked so 597 * that you can call back into it. 598 * 599 * <p>Note: due to the nature of these functions not being called with the 600 * window manager locked, you must be prepared for this function to be 601 * called multiple times and/or an initial time with a null View window 602 * even if you previously returned one. 603 * 604 * @param appToken Token of the application that has started. 605 * @param window Window View that was returned by createStartingWindow. 606 * 607 * @see #addStartingWindow 608 */ 609 public void removeStartingWindow(IBinder appToken, View window); 610 611 /** 612 * Prepare for a window being added to the window manager. You can throw an 613 * exception here to prevent the window being added, or do whatever setup 614 * you need to keep track of the window. 615 * 616 * @param win The window being added. 617 * @param attrs The window's LayoutParams. 618 * 619 * @return {@link WindowManagerImpl#ADD_OKAY} if the add can proceed, else an 620 * error code to abort the add. 621 */ 622 public int prepareAddWindowLw(WindowState win, 623 WindowManager.LayoutParams attrs); 624 625 /** 626 * Called when a window is being removed from a window manager. Must not 627 * throw an exception -- clean up as much as possible. 628 * 629 * @param win The window being removed. 630 */ 631 public void removeWindowLw(WindowState win); 632 633 /** 634 * Control the animation to run when a window's state changes. Return a 635 * non-0 number to force the animation to a specific resource ID, or 0 636 * to use the default animation. 637 * 638 * @param win The window that is changing. 639 * @param transit What is happening to the window: {@link #TRANSIT_ENTER}, 640 * {@link #TRANSIT_EXIT}, {@link #TRANSIT_SHOW}, or 641 * {@link #TRANSIT_HIDE}. 642 * 643 * @return Resource ID of the actual animation to use, or 0 for none. 644 */ 645 public int selectAnimationLw(WindowState win, int transit); 646 647 /** 648 * Create and return an animation to re-display a force hidden window. 649 */ 650 public Animation createForceHideEnterAnimation(); 651 652 /** 653 * Called from the input reader thread before a key is enqueued. 654 * 655 * <p>There are some actions that need to be handled here because they 656 * affect the power state of the device, for example, the power keys. 657 * Generally, it's best to keep as little as possible in the queue thread 658 * because it's the most fragile. 659 * @param event The key event. 660 * @param policyFlags The policy flags associated with the key. 661 * @param isScreenOn True if the screen is already on 662 * 663 * @return The bitwise or of the {@link #ACTION_PASS_TO_USER}, 664 * {@link #ACTION_POKE_USER_ACTIVITY} and {@link #ACTION_GO_TO_SLEEP} flags. 665 */ 666 public int interceptKeyBeforeQueueing(KeyEvent event, int policyFlags, boolean isScreenOn); 667 668 /** 669 * Called from the input reader thread before a motion is enqueued when the screen is off. 670 * 671 * <p>There are some actions that need to be handled here because they 672 * affect the power state of the device, for example, waking on motions. 673 * Generally, it's best to keep as little as possible in the queue thread 674 * because it's the most fragile. 675 * @param policyFlags The policy flags associated with the motion. 676 * 677 * @return The bitwise or of the {@link #ACTION_PASS_TO_USER}, 678 * {@link #ACTION_POKE_USER_ACTIVITY} and {@link #ACTION_GO_TO_SLEEP} flags. 679 */ 680 public int interceptMotionBeforeQueueingWhenScreenOff(int policyFlags); 681 682 /** 683 * Called from the input dispatcher thread before a key is dispatched to a window. 684 * 685 * <p>Allows you to define 686 * behavior for keys that can not be overridden by applications. 687 * This method is called from the input thread, with no locks held. 688 * 689 * @param win The window that currently has focus. This is where the key 690 * event will normally go. 691 * @param event The key event. 692 * @param policyFlags The policy flags associated with the key. 693 * @return 0 if the key should be dispatched immediately, -1 if the key should 694 * not be dispatched ever, or a positive value indicating the number of 695 * milliseconds by which the key dispatch should be delayed before trying 696 * again. 697 */ 698 public long interceptKeyBeforeDispatching(WindowState win, KeyEvent event, int policyFlags); 699 700 /** 701 * Called from the input dispatcher thread when an application did not handle 702 * a key that was dispatched to it. 703 * 704 * <p>Allows you to define default global behavior for keys that were not handled 705 * by applications. This method is called from the input thread, with no locks held. 706 * 707 * @param win The window that currently has focus. This is where the key 708 * event will normally go. 709 * @param event The key event. 710 * @param policyFlags The policy flags associated with the key. 711 * @return Returns an alternate key event to redispatch as a fallback, or null to give up. 712 * The caller is responsible for recycling the key event. 713 */ 714 public KeyEvent dispatchUnhandledKey(WindowState win, KeyEvent event, int policyFlags); 715 716 /** 717 * Called when layout of the windows is about to start. 718 * 719 * @param displayWidth The current full width of the screen. 720 * @param displayHeight The current full height of the screen. 721 * @param displayRotation The current rotation being applied to the base 722 * window. 723 */ 724 public void beginLayoutLw(int displayWidth, int displayHeight, int displayRotation); 725 726 /** 727 * Called for each window attached to the window manager as layout is 728 * proceeding. The implementation of this function must take care of 729 * setting the window's frame, either here or in finishLayout(). 730 * 731 * @param win The window being positioned. 732 * @param attrs The LayoutParams of the window. 733 * @param attached For sub-windows, the window it is attached to; this 734 * window will already have had layoutWindow() called on it 735 * so you can use its Rect. Otherwise null. 736 */ 737 public void layoutWindowLw(WindowState win, 738 WindowManager.LayoutParams attrs, WindowState attached); 739 740 741 /** 742 * Return the insets for the areas covered by system windows. These values 743 * are computed on the most recent layout, so they are not guaranteed to 744 * be correct. 745 * 746 * @param attrs The LayoutParams of the window. 747 * @param contentInset The areas covered by system windows, expressed as positive insets 748 * 749 */ 750 public void getContentInsetHintLw(WindowManager.LayoutParams attrs, Rect contentInset); 751 752 /** 753 * Called when layout of the windows is finished. After this function has 754 * returned, all windows given to layoutWindow() <em>must</em> have had a 755 * frame assigned. 756 * 757 * @return Return any bit set of {@link #FINISH_LAYOUT_REDO_LAYOUT}, 758 * {@link #FINISH_LAYOUT_REDO_CONFIG}, {@link #FINISH_LAYOUT_REDO_WALLPAPER}, 759 * or {@link #FINISH_LAYOUT_REDO_ANIM}. 760 */ 761 public int finishLayoutLw(); 762 763 /** Layout state may have changed (so another layout will be performed) */ 764 static final int FINISH_LAYOUT_REDO_LAYOUT = 0x0001; 765 /** Configuration state may have changed */ 766 static final int FINISH_LAYOUT_REDO_CONFIG = 0x0002; 767 /** Wallpaper may need to move */ 768 static final int FINISH_LAYOUT_REDO_WALLPAPER = 0x0004; 769 /** Need to recompute animations */ 770 static final int FINISH_LAYOUT_REDO_ANIM = 0x0008; 771 772 /** 773 * Called when animation of the windows is about to start. 774 * 775 * @param displayWidth The current full width of the screen. 776 * @param displayHeight The current full height of the screen. 777 */ 778 public void beginAnimationLw(int displayWidth, int displayHeight); 779 780 /** 781 * Called each time a window is animating. 782 * 783 * @param win The window being positioned. 784 * @param attrs The LayoutParams of the window. 785 */ 786 public void animatingWindowLw(WindowState win, 787 WindowManager.LayoutParams attrs); 788 789 /** 790 * Called when animation of the windows is finished. If in this function you do 791 * something that may have modified the animation state of another window, 792 * be sure to return true in order to perform another animation frame. 793 * 794 * @return Return any bit set of {@link #FINISH_LAYOUT_REDO_LAYOUT}, 795 * {@link #FINISH_LAYOUT_REDO_CONFIG}, {@link #FINISH_LAYOUT_REDO_WALLPAPER}, 796 * or {@link #FINISH_LAYOUT_REDO_ANIM}. 797 */ 798 public int finishAnimationLw(); 799 800 /** 801 * Return true if it is okay to perform animations for an app transition 802 * that is about to occur. You may return false for this if, for example, 803 * the lock screen is currently displayed so the switch should happen 804 * immediately. 805 */ 806 public boolean allowAppAnimationsLw(); 807 808 809 /** 810 * A new window has been focused. 811 */ 812 public int focusChangedLw(WindowState lastFocus, WindowState newFocus); 813 814 /** 815 * Called after the screen turns off. 816 * 817 * @param why {@link #OFF_BECAUSE_OF_USER} or 818 * {@link #OFF_BECAUSE_OF_TIMEOUT}. 819 */ 820 public void screenTurnedOff(int why); 821 822 public interface ScreenOnListener { 823 void onScreenOn(); 824 }; 825 826 /** 827 * Called when the power manager would like to turn the screen on. 828 * Must call back on the listener to tell it when the higher-level system 829 * is ready for the screen to go on (i.e. the lock screen is shown). 830 */ 831 public void screenTurningOn(ScreenOnListener screenOnListener); 832 833 /** 834 * Return whether the screen is about to turn on or is currently on. 835 */ 836 public boolean isScreenOnEarly(); 837 838 /** 839 * Return whether the screen is fully turned on. 840 */ 841 public boolean isScreenOnFully(); 842 843 /** 844 * Tell the policy that the lid switch has changed state. 845 * @param whenNanos The time when the change occurred in uptime nanoseconds. 846 * @param lidOpen True if the lid is now open. 847 */ 848 public void notifyLidSwitchChanged(long whenNanos, boolean lidOpen); 849 850 /** 851 * Tell the policy if anyone is requesting that keyguard not come on. 852 * 853 * @param enabled Whether keyguard can be on or not. does not actually 854 * turn it on, unless it was previously disabled with this function. 855 * 856 * @see android.app.KeyguardManager.KeyguardLock#disableKeyguard() 857 * @see android.app.KeyguardManager.KeyguardLock#reenableKeyguard() 858 */ 859 public void enableKeyguard(boolean enabled); 860 861 /** 862 * Callback used by {@link WindowManagerPolicy#exitKeyguardSecurely} 863 */ 864 interface OnKeyguardExitResult { 865 void onKeyguardExitResult(boolean success); 866 } 867 868 /** 869 * Tell the policy if anyone is requesting the keyguard to exit securely 870 * (this would be called after the keyguard was disabled) 871 * @param callback Callback to send the result back. 872 * @see android.app.KeyguardManager#exitKeyguardSecurely(android.app.KeyguardManager.OnKeyguardExitResult) 873 */ 874 void exitKeyguardSecurely(OnKeyguardExitResult callback); 875 876 /** 877 * isKeyguardLocked 878 * 879 * Return whether the keyguard is currently locked. 880 * 881 * @return true if in keyguard is locked. 882 */ 883 public boolean isKeyguardLocked(); 884 885 /** 886 * isKeyguardSecure 887 * 888 * Return whether the keyguard requires a password to unlock. 889 * 890 * @return true if in keyguard is secure. 891 */ 892 public boolean isKeyguardSecure(); 893 894 /** 895 * inKeyguardRestrictedKeyInputMode 896 * 897 * if keyguard screen is showing or in restricted key input mode (i.e. in 898 * keyguard password emergency screen). When in such mode, certain keys, 899 * such as the Home key and the right soft keys, don't work. 900 * 901 * @return true if in keyguard restricted input mode. 902 */ 903 public boolean inKeyguardRestrictedKeyInputMode(); 904 905 /** 906 * Ask the policy to dismiss the keyguard, if it is currently shown. 907 */ 908 public void dismissKeyguardLw(); 909 910 /** 911 * Given an orientation constant, returns the appropriate surface rotation, 912 * taking into account sensors, docking mode, rotation lock, and other factors. 913 * 914 * @param orientation An orientation constant, such as 915 * {@link android.content.pm.ActivityInfo#SCREEN_ORIENTATION_LANDSCAPE}. 916 * @param lastRotation The most recently used rotation. 917 * @return The surface rotation to use. 918 */ 919 public int rotationForOrientationLw(int orientation, int lastRotation); 920 921 /** 922 * Given an orientation constant and a rotation, returns true if the rotation 923 * has compatible metrics to the requested orientation. For example, if 924 * the application requested landscape and got seascape, then the rotation 925 * has compatible metrics; if the application requested portrait and got landscape, 926 * then the rotation has incompatible metrics; if the application did not specify 927 * a preference, then anything goes. 928 * 929 * @param orientation An orientation constant, such as 930 * {@link android.content.pm.ActivityInfo#SCREEN_ORIENTATION_LANDSCAPE}. 931 * @param rotation The rotation to check. 932 * @return True if the rotation is compatible with the requested orientation. 933 */ 934 public boolean rotationHasCompatibleMetricsLw(int orientation, int rotation); 935 936 /** 937 * Called by the window manager when the rotation changes. 938 * 939 * @param rotation The new rotation. 940 */ 941 public void setRotationLw(int rotation); 942 943 /** 944 * Called when the system is mostly done booting to determine whether 945 * the system should go into safe mode. 946 */ 947 public boolean detectSafeMode(); 948 949 /** 950 * Called when the system is mostly done booting. 951 */ 952 public void systemReady(); 953 954 /** 955 * Called when the system is done booting to the point where the 956 * user can start interacting with it. 957 */ 958 public void systemBooted(); 959 960 /** 961 * Show boot time message to the user. 962 */ 963 public void showBootMessage(final CharSequence msg, final boolean always); 964 965 /** 966 * Hide the UI for showing boot messages, never to be displayed again. 967 */ 968 public void hideBootMessages(); 969 970 /** 971 * Called when userActivity is signalled in the power manager. 972 * This is safe to call from any thread, with any window manager locks held or not. 973 */ 974 public void userActivity(); 975 976 /** 977 * Called when we have finished booting and can now display the home 978 * screen to the user. This wilWl happen after systemReady(), and at 979 * this point the display is active. 980 */ 981 public void enableScreenAfterBoot(); 982 983 public void setCurrentOrientationLw(int newOrientation); 984 985 /** 986 * Call from application to perform haptic feedback on its window. 987 */ 988 public boolean performHapticFeedbackLw(WindowState win, int effectId, boolean always); 989 990 /** 991 * Called when we have started keeping the screen on because a window 992 * requesting this has become visible. 993 */ 994 public void screenOnStartedLw(); 995 996 /** 997 * Called when we have stopped keeping the screen on because the last window 998 * requesting this is no longer visible. 999 */ 1000 public void screenOnStoppedLw(); 1001 1002 /** 1003 * Return false to disable key repeat events from being generated. 1004 */ 1005 public boolean allowKeyRepeat(); 1006 1007 /** 1008 * Inform the policy that the user has chosen a preferred orientation ("rotation lock"). 1009 * 1010 * @param mode One of {@link WindowManagerPolicy#USER_ROTATION_LOCKED} or 1011 * {@link * WindowManagerPolicy#USER_ROTATION_FREE}. 1012 * @param rotation One of {@link Surface#ROTATION_0}, {@link Surface#ROTATION_90}, 1013 * {@link Surface#ROTATION_180}, {@link Surface#ROTATION_270}. 1014 */ 1015 public void setUserRotationMode(int mode, int rotation); 1016 1017 /** 1018 * Called when a new system UI visibility is being reported, allowing 1019 * the policy to adjust what is actually reported. 1020 * @param visibility The raw visiblity reported by the status bar. 1021 * @return The new desired visibility. 1022 */ 1023 public int adjustSystemUiVisibilityLw(int visibility); 1024 1025 /** 1026 * Specifies whether there is an on-screen navigation bar separate from the status bar. 1027 */ 1028 public boolean hasNavigationBar(); 1029 1030 /** 1031 * Lock the device now. 1032 */ 1033 public void lockNow(); 1034 1035 /** 1036 * Print the WindowManagerPolicy's state into the given stream. 1037 * 1038 * @param prefix Text to print at the front of each line. 1039 * @param fd The raw file descriptor that the dump is being sent to. 1040 * @param writer The PrintWriter to which you should dump your state. This will be 1041 * closed for you after you return. 1042 * @param args additional arguments to the dump request. 1043 */ 1044 public void dump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args); 1045 } 1046