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.annotation.IntDef; 20 import android.content.Context; 21 import android.content.pm.ActivityInfo; 22 import android.content.res.CompatibilityInfo; 23 import android.content.res.Configuration; 24 import android.graphics.Rect; 25 import android.graphics.RectF; 26 import android.os.Bundle; 27 import android.os.IBinder; 28 import android.os.Looper; 29 import android.view.animation.Animation; 30 31 import java.io.PrintWriter; 32 import java.lang.annotation.Retention; 33 import java.lang.annotation.RetentionPolicy; 34 35 /** 36 * This interface supplies all UI-specific behavior of the window manager. An 37 * instance of it is created by the window manager when it starts up, and allows 38 * customization of window layering, special window types, key dispatching, and 39 * layout. 40 * 41 * <p>Because this provides deep interaction with the system window manager, 42 * specific methods on this interface can be called from a variety of contexts 43 * with various restrictions on what they can do. These are encoded through 44 * a suffixes at the end of a method encoding the thread the method is called 45 * from and any locks that are held when it is being called; if no suffix 46 * is attached to a method, then it is not called with any locks and may be 47 * called from the main window manager thread or another thread calling into 48 * the window manager. 49 * 50 * <p>The current suffixes are: 51 * 52 * <dl> 53 * <dt> Ti <dd> Called from the input thread. This is the thread that 54 * collects pending input events and dispatches them to the appropriate window. 55 * It may block waiting for events to be processed, so that the input stream is 56 * properly serialized. 57 * <dt> Tq <dd> Called from the low-level input queue thread. This is the 58 * thread that reads events out of the raw input devices and places them 59 * into the global input queue that is read by the <var>Ti</var> thread. 60 * This thread should not block for a long period of time on anything but the 61 * key driver. 62 * <dt> Lw <dd> Called with the main window manager lock held. Because the 63 * window manager is a very low-level system service, there are few other 64 * system services you can call with this lock held. It is explicitly okay to 65 * make calls into the package manager and power manager; it is explicitly not 66 * okay to make calls into the activity manager or most other services. Note that 67 * {@link android.content.Context#checkPermission(String, int, int)} and 68 * variations require calling into the activity manager. 69 * <dt> Li <dd> Called with the input thread lock held. This lock can be 70 * acquired by the window manager while it holds the window lock, so this is 71 * even more restrictive than <var>Lw</var>. 72 * </dl> 73 * 74 * @hide 75 */ 76 public interface WindowManagerPolicy { 77 // Policy flags. These flags are also defined in frameworks/base/include/ui/Input.h. 78 public final static int FLAG_WAKE = 0x00000001; 79 public final static int FLAG_VIRTUAL = 0x00000002; 80 81 public final static int FLAG_INJECTED = 0x01000000; 82 public final static int FLAG_TRUSTED = 0x02000000; 83 public final static int FLAG_FILTERED = 0x04000000; 84 public final static int FLAG_DISABLE_KEY_REPEAT = 0x08000000; 85 86 public final static int FLAG_INTERACTIVE = 0x20000000; 87 public final static int FLAG_PASS_TO_USER = 0x40000000; 88 89 // Flags used for indicating whether the internal and/or external input devices 90 // of some type are available. 91 public final static int PRESENCE_INTERNAL = 1 << 0; 92 public final static int PRESENCE_EXTERNAL = 1 << 1; 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 * Interface to the Window Manager state associated with a particular 115 * window. You can hold on to an instance of this interface from the call 116 * to prepareAddWindow() until removeWindow(). 117 */ 118 public interface WindowState { 119 /** 120 * Return the uid of the app that owns this window. 121 */ 122 int getOwningUid(); 123 124 /** 125 * Return the package name of the app that owns this window. 126 */ 127 String getOwningPackage(); 128 129 /** 130 * Perform standard frame computation. The result can be obtained with 131 * getFrame() if so desired. Must be called with the window manager 132 * lock held. 133 * 134 * @param parentFrame The frame of the parent container this window 135 * is in, used for computing its basic position. 136 * @param displayFrame The frame of the overall display in which this 137 * window can appear, used for constraining the overall dimensions 138 * of the window. 139 * @param overlayFrame The frame within the display that is inside 140 * of the overlay region. 141 * @param contentFrame The frame within the display in which we would 142 * like active content to appear. This will cause windows behind to 143 * be resized to match the given content frame. 144 * @param visibleFrame The frame within the display that the window 145 * is actually visible, used for computing its visible insets to be 146 * given to windows behind. 147 * This can be used as a hint for scrolling (avoiding resizing) 148 * the window to make certain that parts of its content 149 * are visible. 150 * @param decorFrame The decor frame specified by policy specific to this window, 151 * to use for proper cropping during animation. 152 * @param stableFrame The frame around which stable system decoration is positioned. 153 */ 154 public void computeFrameLw(Rect parentFrame, Rect displayFrame, 155 Rect overlayFrame, Rect contentFrame, Rect visibleFrame, Rect decorFrame, 156 Rect stableFrame); 157 158 /** 159 * Retrieve the current frame of the window that has been assigned by 160 * the window manager. Must be called with the window manager lock held. 161 * 162 * @return Rect The rectangle holding the window frame. 163 */ 164 public Rect getFrameLw(); 165 166 /** 167 * Retrieve the current frame of the window that is actually shown. 168 * Must be called with the window manager lock held. 169 * 170 * @return Rect The rectangle holding the shown window frame. 171 */ 172 public RectF getShownFrameLw(); 173 174 /** 175 * Retrieve the frame of the display that this window was last 176 * laid out in. Must be called with the 177 * window manager lock held. 178 * 179 * @return Rect The rectangle holding the display frame. 180 */ 181 public Rect getDisplayFrameLw(); 182 183 /** 184 * Retrieve the frame of the area inside the overscan region of the 185 * display that this window was last laid out in. Must be called with the 186 * window manager lock held. 187 * 188 * @return Rect The rectangle holding the display overscan frame. 189 */ 190 public Rect getOverscanFrameLw(); 191 192 /** 193 * Retrieve the frame of the content area that this window was last 194 * laid out in. This is the area in which the content of the window 195 * should be placed. It will be smaller than the display frame to 196 * account for screen decorations such as a status bar or soft 197 * keyboard. Must be called with the 198 * window manager lock held. 199 * 200 * @return Rect The rectangle holding the content frame. 201 */ 202 public Rect getContentFrameLw(); 203 204 /** 205 * Retrieve the frame of the visible area that this window was last 206 * laid out in. This is the area of the screen in which the window 207 * will actually be fully visible. It will be smaller than the 208 * content frame to account for transient UI elements blocking it 209 * such as an input method's candidates UI. Must be called with the 210 * window manager lock held. 211 * 212 * @return Rect The rectangle holding the visible frame. 213 */ 214 public Rect getVisibleFrameLw(); 215 216 /** 217 * Returns true if this window is waiting to receive its given 218 * internal insets from the client app, and so should not impact the 219 * layout of other windows. 220 */ 221 public boolean getGivenInsetsPendingLw(); 222 223 /** 224 * Retrieve the insets given by this window's client for the content 225 * area of windows behind it. Must be called with the 226 * window manager lock held. 227 * 228 * @return Rect The left, top, right, and bottom insets, relative 229 * to the window's frame, of the actual contents. 230 */ 231 public Rect getGivenContentInsetsLw(); 232 233 /** 234 * Retrieve the insets given by this window's client for the visible 235 * area of windows behind it. Must be called with the 236 * window manager lock held. 237 * 238 * @return Rect The left, top, right, and bottom insets, relative 239 * to the window's frame, of the actual visible area. 240 */ 241 public Rect getGivenVisibleInsetsLw(); 242 243 /** 244 * Retrieve the current LayoutParams of the window. 245 * 246 * @return WindowManager.LayoutParams The window's internal LayoutParams 247 * instance. 248 */ 249 public WindowManager.LayoutParams getAttrs(); 250 251 /** 252 * Return whether this window needs the menu key shown. Must be called 253 * with window lock held, because it may need to traverse down through 254 * window list to determine the result. 255 * @param bottom The bottom-most window to consider when determining this. 256 */ 257 public boolean getNeedsMenuLw(WindowState bottom); 258 259 /** 260 * Retrieve the current system UI visibility flags associated with 261 * this window. 262 */ 263 public int getSystemUiVisibility(); 264 265 /** 266 * Get the layer at which this window's surface will be Z-ordered. 267 */ 268 public int getSurfaceLayer(); 269 270 /** 271 * Return the token for the application (actually activity) that owns 272 * this window. May return null for system windows. 273 * 274 * @return An IApplicationToken identifying the owning activity. 275 */ 276 public IApplicationToken getAppToken(); 277 278 /** 279 * Return true if this window is participating in voice interaction. 280 */ 281 public boolean isVoiceInteraction(); 282 283 /** 284 * Return true if, at any point, the application token associated with 285 * this window has actually displayed any windows. This is most useful 286 * with the "starting up" window to determine if any windows were 287 * displayed when it is closed. 288 * 289 * @return Returns true if one or more windows have been displayed, 290 * else false. 291 */ 292 public boolean hasAppShownWindows(); 293 294 /** 295 * Is this window visible? It is not visible if there is no 296 * surface, or we are in the process of running an exit animation 297 * that will remove the surface. 298 */ 299 boolean isVisibleLw(); 300 301 /** 302 * Like {@link #isVisibleLw}, but also counts a window that is currently 303 * "hidden" behind the keyguard as visible. This allows us to apply 304 * things like window flags that impact the keyguard. 305 */ 306 boolean isVisibleOrBehindKeyguardLw(); 307 308 /** 309 * Is this window currently visible to the user on-screen? It is 310 * displayed either if it is visible or it is currently running an 311 * animation before no longer being visible. Must be called with the 312 * window manager lock held. 313 */ 314 boolean isDisplayedLw(); 315 316 /** 317 * Return true if this window (or a window it is attached to, but not 318 * considering its app token) is currently animating. 319 */ 320 public boolean isAnimatingLw(); 321 322 /** 323 * Is this window considered to be gone for purposes of layout? 324 */ 325 boolean isGoneForLayoutLw(); 326 327 /** 328 * Returns true if this window has been shown on screen at some time in 329 * the past. Must be called with the window manager lock held. 330 */ 331 public boolean hasDrawnLw(); 332 333 /** 334 * Can be called by the policy to force a window to be hidden, 335 * regardless of whether the client or window manager would like 336 * it shown. Must be called with the window manager lock held. 337 * Returns true if {@link #showLw} was last called for the window. 338 */ 339 public boolean hideLw(boolean doAnimation); 340 341 /** 342 * Can be called to undo the effect of {@link #hideLw}, allowing a 343 * window to be shown as long as the window manager and client would 344 * also like it to be shown. Must be called with the window manager 345 * lock held. 346 * Returns true if {@link #hideLw} was last called for the window. 347 */ 348 public boolean showLw(boolean doAnimation); 349 350 /** 351 * Check whether the process hosting this window is currently alive. 352 */ 353 public boolean isAlive(); 354 355 /** 356 * Check if window is on {@link Display#DEFAULT_DISPLAY}. 357 * @return true if window is on default display. 358 */ 359 public boolean isDefaultDisplay(); 360 } 361 362 /** 363 * Representation of a "fake window" that the policy has added to the 364 * window manager to consume events. 365 */ 366 public interface FakeWindow { 367 /** 368 * Remove the fake window from the window manager. 369 */ 370 void dismiss(); 371 } 372 373 /** 374 * Interface for calling back in to the window manager that is private 375 * between it and the policy. 376 */ 377 public interface WindowManagerFuncs { 378 public static final int LID_ABSENT = -1; 379 public static final int LID_CLOSED = 0; 380 public static final int LID_OPEN = 1; 381 382 public static final int CAMERA_LENS_COVER_ABSENT = -1; 383 public static final int CAMERA_LENS_UNCOVERED = 0; 384 public static final int CAMERA_LENS_COVERED = 1; 385 386 /** 387 * Ask the window manager to re-evaluate the system UI flags. 388 */ 389 public void reevaluateStatusBarVisibility(); 390 391 /** 392 * Add a fake window to the window manager. This window sits 393 * at the top of the other windows and consumes events. 394 */ 395 public FakeWindow addFakeWindow(Looper looper, 396 InputEventReceiver.Factory inputEventReceiverFactory, 397 String name, int windowType, int layoutParamsFlags, int layoutParamsPrivateFlags, 398 boolean canReceiveKeys, boolean hasFocus, boolean touchFullscreen); 399 400 /** 401 * Returns a code that describes the current state of the lid switch. 402 */ 403 public int getLidState(); 404 405 /** 406 * Returns a code that descripbes whether the camera lens is covered or not. 407 */ 408 public int getCameraLensCoverState(); 409 410 /** 411 * Switch the keyboard layout for the given device. 412 * Direction should be +1 or -1 to go to the next or previous keyboard layout. 413 */ 414 public void switchKeyboardLayout(int deviceId, int direction); 415 416 public void shutdown(boolean confirm); 417 public void rebootSafeMode(boolean confirm); 418 419 /** 420 * Return the window manager lock needed to correctly call "Lw" methods. 421 */ 422 public Object getWindowManagerLock(); 423 424 /** Register a system listener for touch events */ 425 void registerPointerEventListener(PointerEventListener listener); 426 427 /** Unregister a system listener for touch events */ 428 void unregisterPointerEventListener(PointerEventListener listener); 429 } 430 431 public interface PointerEventListener { 432 /** 433 * 1. onPointerEvent will be called on the service.UiThread. 434 * 2. motionEvent will be recycled after onPointerEvent returns so if it is needed later a 435 * copy() must be made and the copy must be recycled. 436 **/ 437 public void onPointerEvent(MotionEvent motionEvent); 438 } 439 440 /** Window has been added to the screen. */ 441 public static final int TRANSIT_ENTER = 1; 442 /** Window has been removed from the screen. */ 443 public static final int TRANSIT_EXIT = 2; 444 /** Window has been made visible. */ 445 public static final int TRANSIT_SHOW = 3; 446 /** Window has been made invisible. 447 * TODO: Consider removal as this is unused. */ 448 public static final int TRANSIT_HIDE = 4; 449 /** The "application starting" preview window is no longer needed, and will 450 * animate away to show the real window. */ 451 public static final int TRANSIT_PREVIEW_DONE = 5; 452 453 // NOTE: screen off reasons are in order of significance, with more 454 // important ones lower than less important ones. 455 456 /** Screen turned off because of a device admin */ 457 public final int OFF_BECAUSE_OF_ADMIN = 1; 458 /** Screen turned off because of power button */ 459 public final int OFF_BECAUSE_OF_USER = 2; 460 /** Screen turned off because of timeout */ 461 public final int OFF_BECAUSE_OF_TIMEOUT = 3; 462 463 /** @hide */ 464 @IntDef({USER_ROTATION_FREE, USER_ROTATION_LOCKED}) 465 @Retention(RetentionPolicy.SOURCE) 466 public @interface UserRotationMode {} 467 468 /** When not otherwise specified by the activity's screenOrientation, rotation should be 469 * determined by the system (that is, using sensors). */ 470 public final int USER_ROTATION_FREE = 0; 471 /** When not otherwise specified by the activity's screenOrientation, rotation is set by 472 * the user. */ 473 public final int USER_ROTATION_LOCKED = 1; 474 475 /** 476 * Perform initialization of the policy. 477 * 478 * @param context The system context we are running in. 479 */ 480 public void init(Context context, IWindowManager windowManager, 481 WindowManagerFuncs windowManagerFuncs); 482 483 /** 484 * @return true if com.android.internal.R.bool#config_forceDefaultOrientation is true. 485 */ 486 public boolean isDefaultOrientationForced(); 487 488 /** 489 * Called by window manager once it has the initial, default native 490 * display dimensions. 491 */ 492 public void setInitialDisplaySize(Display display, int width, int height, int density); 493 494 /** 495 * Called by window manager to set the overscan region that should be used for the 496 * given display. 497 */ 498 public void setDisplayOverscan(Display display, int left, int top, int right, int bottom); 499 500 /** 501 * Check permissions when adding a window. 502 * 503 * @param attrs The window's LayoutParams. 504 * @param outAppOp First element will be filled with the app op corresponding to 505 * this window, or OP_NONE. 506 * 507 * @return {@link WindowManagerGlobal#ADD_OKAY} if the add can proceed; 508 * else an error code, usually 509 * {@link WindowManagerGlobal#ADD_PERMISSION_DENIED}, to abort the add. 510 */ 511 public int checkAddPermission(WindowManager.LayoutParams attrs, int[] outAppOp); 512 513 /** 514 * Check permissions when adding a window. 515 * 516 * @param attrs The window's LayoutParams. 517 * 518 * @return True if the window may only be shown to the current user, false if the window can 519 * be shown on all users' windows. 520 */ 521 public boolean checkShowToOwnerOnly(WindowManager.LayoutParams attrs); 522 523 /** 524 * Sanitize the layout parameters coming from a client. Allows the policy 525 * to do things like ensure that windows of a specific type can't take 526 * input focus. 527 * 528 * @param attrs The window layout parameters to be modified. These values 529 * are modified in-place. 530 */ 531 public void adjustWindowParamsLw(WindowManager.LayoutParams attrs); 532 533 /** 534 * After the window manager has computed the current configuration based 535 * on its knowledge of the display and input devices, it gives the policy 536 * a chance to adjust the information contained in it. If you want to 537 * leave it as-is, simply do nothing. 538 * 539 * <p>This method may be called by any thread in the window manager, but 540 * no internal locks in the window manager will be held. 541 * 542 * @param config The Configuration being computed, for you to change as 543 * desired. 544 * @param keyboardPresence Flags that indicate whether internal or external 545 * keyboards are present. 546 * @param navigationPresence Flags that indicate whether internal or external 547 * navigation devices are present. 548 */ 549 public void adjustConfigurationLw(Configuration config, int keyboardPresence, 550 int navigationPresence); 551 552 /** 553 * Assign a window type to a layer. Allows you to control how different 554 * kinds of windows are ordered on-screen. 555 * 556 * @param type The type of window being assigned. 557 * 558 * @return int An arbitrary integer used to order windows, with lower 559 * numbers below higher ones. 560 */ 561 public int windowTypeToLayerLw(int type); 562 563 /** 564 * Return how to Z-order sub-windows in relation to the window they are 565 * attached to. Return positive to have them ordered in front, negative for 566 * behind. 567 * 568 * @param type The sub-window type code. 569 * 570 * @return int Layer in relation to the attached window, where positive is 571 * above and negative is below. 572 */ 573 public int subWindowTypeToLayerLw(int type); 574 575 /** 576 * Get the highest layer (actually one more than) that the wallpaper is 577 * allowed to be in. 578 */ 579 public int getMaxWallpaperLayer(); 580 581 /** 582 * Return the window layer at which windows appear above the normal 583 * universe (that is no longer impacted by the universe background 584 * transform). 585 */ 586 public int getAboveUniverseLayer(); 587 588 /** 589 * Return the display width available after excluding any screen 590 * decorations that can never be removed. That is, system bar or 591 * button bar. 592 */ 593 public int getNonDecorDisplayWidth(int fullWidth, int fullHeight, int rotation); 594 595 /** 596 * Return the display height available after excluding any screen 597 * decorations that can never be removed. That is, system bar or 598 * button bar. 599 */ 600 public int getNonDecorDisplayHeight(int fullWidth, int fullHeight, int rotation); 601 602 /** 603 * Return the available screen width that we should report for the 604 * configuration. This must be no larger than 605 * {@link #getNonDecorDisplayWidth(int, int, int)}; it may be smaller than 606 * that to account for more transient decoration like a status bar. 607 */ 608 public int getConfigDisplayWidth(int fullWidth, int fullHeight, int rotation); 609 610 /** 611 * Return the available screen height that we should report for the 612 * configuration. This must be no larger than 613 * {@link #getNonDecorDisplayHeight(int, int, int)}; it may be smaller than 614 * that to account for more transient decoration like a status bar. 615 */ 616 public int getConfigDisplayHeight(int fullWidth, int fullHeight, int rotation); 617 618 /** 619 * Return whether the given window is forcibly hiding all windows except windows with 620 * FLAG_SHOW_WHEN_LOCKED set. Typically returns true for the keyguard. 621 */ 622 public boolean isForceHiding(WindowManager.LayoutParams attrs); 623 624 625 /** 626 * Return whether the given window can become one that passes isForceHiding() test. 627 * Typically returns true for the StatusBar. 628 */ 629 public boolean isKeyguardHostWindow(WindowManager.LayoutParams attrs); 630 631 /** 632 * Determine if a window that is behind one that is force hiding 633 * (as determined by {@link #isForceHiding}) should actually be hidden. 634 * For example, typically returns false for the status bar. Be careful 635 * to return false for any window that you may hide yourself, since this 636 * will conflict with what you set. 637 */ 638 public boolean canBeForceHidden(WindowState win, WindowManager.LayoutParams attrs); 639 640 /** 641 * Return the window that is hiding the keyguard, if such a thing exists. 642 */ 643 public WindowState getWinShowWhenLockedLw(); 644 645 /** 646 * Called when the system would like to show a UI to indicate that an 647 * application is starting. You can use this to add a 648 * APPLICATION_STARTING_TYPE window with the given appToken to the window 649 * manager (using the normal window manager APIs) that will be shown until 650 * the application displays its own window. This is called without the 651 * window manager locked so that you can call back into it. 652 * 653 * @param appToken Token of the application being started. 654 * @param packageName The name of the application package being started. 655 * @param theme Resource defining the application's overall visual theme. 656 * @param nonLocalizedLabel The default title label of the application if 657 * no data is found in the resource. 658 * @param labelRes The resource ID the application would like to use as its name. 659 * @param icon The resource ID the application would like to use as its icon. 660 * @param windowFlags Window layout flags. 661 * 662 * @return Optionally you can return the View that was used to create the 663 * window, for easy removal in removeStartingWindow. 664 * 665 * @see #removeStartingWindow 666 */ 667 public View addStartingWindow(IBinder appToken, String packageName, 668 int theme, CompatibilityInfo compatInfo, CharSequence nonLocalizedLabel, 669 int labelRes, int icon, int logo, int windowFlags); 670 671 /** 672 * Called when the first window of an application has been displayed, while 673 * {@link #addStartingWindow} has created a temporary initial window for 674 * that application. You should at this point remove the window from the 675 * window manager. This is called without the window manager locked so 676 * that you can call back into it. 677 * 678 * <p>Note: due to the nature of these functions not being called with the 679 * window manager locked, you must be prepared for this function to be 680 * called multiple times and/or an initial time with a null View window 681 * even if you previously returned one. 682 * 683 * @param appToken Token of the application that has started. 684 * @param window Window View that was returned by createStartingWindow. 685 * 686 * @see #addStartingWindow 687 */ 688 public void removeStartingWindow(IBinder appToken, View window); 689 690 /** 691 * Prepare for a window being added to the window manager. You can throw an 692 * exception here to prevent the window being added, or do whatever setup 693 * you need to keep track of the window. 694 * 695 * @param win The window being added. 696 * @param attrs The window's LayoutParams. 697 * 698 * @return {@link WindowManagerGlobal#ADD_OKAY} if the add can proceed, else an 699 * error code to abort the add. 700 */ 701 public int prepareAddWindowLw(WindowState win, 702 WindowManager.LayoutParams attrs); 703 704 /** 705 * Called when a window is being removed from a window manager. Must not 706 * throw an exception -- clean up as much as possible. 707 * 708 * @param win The window being removed. 709 */ 710 public void removeWindowLw(WindowState win); 711 712 /** 713 * Control the animation to run when a window's state changes. Return a 714 * non-0 number to force the animation to a specific resource ID, or 0 715 * to use the default animation. 716 * 717 * @param win The window that is changing. 718 * @param transit What is happening to the window: {@link #TRANSIT_ENTER}, 719 * {@link #TRANSIT_EXIT}, {@link #TRANSIT_SHOW}, or 720 * {@link #TRANSIT_HIDE}. 721 * 722 * @return Resource ID of the actual animation to use, or 0 for none. 723 */ 724 public int selectAnimationLw(WindowState win, int transit); 725 726 /** 727 * Determine the animation to run for a rotation transition based on the 728 * top fullscreen windows {@link WindowManager.LayoutParams#rotationAnimation} 729 * and whether it is currently fullscreen and frontmost. 730 * 731 * @param anim The exiting animation resource id is stored in anim[0], the 732 * entering animation resource id is stored in anim[1]. 733 */ 734 public void selectRotationAnimationLw(int anim[]); 735 736 /** 737 * Validate whether the current top fullscreen has specified the same 738 * {@link WindowManager.LayoutParams#rotationAnimation} value as that 739 * being passed in from the previous top fullscreen window. 740 * 741 * @param exitAnimId exiting resource id from the previous window. 742 * @param enterAnimId entering resource id from the previous window. 743 * @param forceDefault For rotation animations only, if true ignore the 744 * animation values and just return false. 745 * @return true if the previous values are still valid, false if they 746 * should be replaced with the default. 747 */ 748 public boolean validateRotationAnimationLw(int exitAnimId, int enterAnimId, 749 boolean forceDefault); 750 751 /** 752 * Create and return an animation to re-display a force hidden window. 753 */ 754 public Animation createForceHideEnterAnimation(boolean onWallpaper, 755 boolean goingToNotificationShade); 756 757 /** 758 * Create and return an animation to let the wallpaper disappear after being shown on a force 759 * hiding window. 760 */ 761 public Animation createForceHideWallpaperExitAnimation(boolean goingToNotificationShade); 762 763 /** 764 * Called from the input reader thread before a key is enqueued. 765 * 766 * <p>There are some actions that need to be handled here because they 767 * affect the power state of the device, for example, the power keys. 768 * Generally, it's best to keep as little as possible in the queue thread 769 * because it's the most fragile. 770 * @param event The key event. 771 * @param policyFlags The policy flags associated with the key. 772 * 773 * @return Actions flags: may be {@link #ACTION_PASS_TO_USER}. 774 */ 775 public int interceptKeyBeforeQueueing(KeyEvent event, int policyFlags); 776 777 /** 778 * Called from the input reader thread before a motion is enqueued when the device is in a 779 * non-interactive state. 780 * 781 * <p>There are some actions that need to be handled here because they 782 * affect the power state of the device, for example, waking on motions. 783 * Generally, it's best to keep as little as possible in the queue thread 784 * because it's the most fragile. 785 * @param policyFlags The policy flags associated with the motion. 786 * 787 * @return Actions flags: may be {@link #ACTION_PASS_TO_USER}. 788 */ 789 public int interceptMotionBeforeQueueingNonInteractive(long whenNanos, int policyFlags); 790 791 /** 792 * Called from the input dispatcher thread before a key is dispatched to a window. 793 * 794 * <p>Allows you to define 795 * behavior for keys that can not be overridden by applications. 796 * This method is called from the input thread, with no locks held. 797 * 798 * @param win The window that currently has focus. This is where the key 799 * event will normally go. 800 * @param event The key event. 801 * @param policyFlags The policy flags associated with the key. 802 * @return 0 if the key should be dispatched immediately, -1 if the key should 803 * not be dispatched ever, or a positive value indicating the number of 804 * milliseconds by which the key dispatch should be delayed before trying 805 * again. 806 */ 807 public long interceptKeyBeforeDispatching(WindowState win, KeyEvent event, int policyFlags); 808 809 /** 810 * Called from the input dispatcher thread when an application did not handle 811 * a key that was dispatched to it. 812 * 813 * <p>Allows you to define default global behavior for keys that were not handled 814 * by applications. This method is called from the input thread, with no locks held. 815 * 816 * @param win The window that currently has focus. This is where the key 817 * event will normally go. 818 * @param event The key event. 819 * @param policyFlags The policy flags associated with the key. 820 * @return Returns an alternate key event to redispatch as a fallback, or null to give up. 821 * The caller is responsible for recycling the key event. 822 */ 823 public KeyEvent dispatchUnhandledKey(WindowState win, KeyEvent event, int policyFlags); 824 825 /** 826 * Called when layout of the windows is about to start. 827 * 828 * @param isDefaultDisplay true if window is on {@link Display#DEFAULT_DISPLAY}. 829 * @param displayWidth The current full width of the screen. 830 * @param displayHeight The current full height of the screen. 831 * @param displayRotation The current rotation being applied to the base 832 * window. 833 */ 834 public void beginLayoutLw(boolean isDefaultDisplay, int displayWidth, int displayHeight, 835 int displayRotation); 836 837 /** 838 * Returns the bottom-most layer of the system decor, above which no policy decor should 839 * be applied. 840 */ 841 public int getSystemDecorLayerLw(); 842 843 /** 844 * Return the rectangle of the screen that is available for applications to run in. 845 * This will be called immediately after {@link #beginLayoutLw}. 846 * 847 * @param r The rectangle to be filled with the boundaries available to applications. 848 */ 849 public void getContentRectLw(Rect r); 850 851 /** 852 * Called for each window attached to the window manager as layout is 853 * proceeding. The implementation of this function must take care of 854 * setting the window's frame, either here or in finishLayout(). 855 * 856 * @param win The window being positioned. 857 * @param attached For sub-windows, the window it is attached to; this 858 * window will already have had layoutWindow() called on it 859 * so you can use its Rect. Otherwise null. 860 */ 861 public void layoutWindowLw(WindowState win, WindowState attached); 862 863 864 /** 865 * Return the insets for the areas covered by system windows. These values 866 * are computed on the most recent layout, so they are not guaranteed to 867 * be correct. 868 * 869 * @param attrs The LayoutParams of the window. 870 * @param outContentInsets The areas covered by system windows, expressed as positive insets. 871 * @param outStableInsets The areas covered by stable system windows irrespective of their 872 * current visibility. Expressed as positive insets. 873 * 874 */ 875 public void getInsetHintLw(WindowManager.LayoutParams attrs, Rect outContentInsets, 876 Rect outStableInsets); 877 878 /** 879 * Called when layout of the windows is finished. After this function has 880 * returned, all windows given to layoutWindow() <em>must</em> have had a 881 * frame assigned. 882 */ 883 public void finishLayoutLw(); 884 885 /** Layout state may have changed (so another layout will be performed) */ 886 static final int FINISH_LAYOUT_REDO_LAYOUT = 0x0001; 887 /** Configuration state may have changed */ 888 static final int FINISH_LAYOUT_REDO_CONFIG = 0x0002; 889 /** Wallpaper may need to move */ 890 static final int FINISH_LAYOUT_REDO_WALLPAPER = 0x0004; 891 /** Need to recompute animations */ 892 static final int FINISH_LAYOUT_REDO_ANIM = 0x0008; 893 894 /** 895 * Called following layout of all windows before each window has policy applied. 896 * 897 * @param displayWidth The current full width of the screen. 898 * @param displayHeight The current full height of the screen. 899 */ 900 public void beginPostLayoutPolicyLw(int displayWidth, int displayHeight); 901 902 /** 903 * Called following layout of all window to apply policy to each window. 904 * 905 * @param win The window being positioned. 906 * @param attrs The LayoutParams of the window. 907 * @param attached For sub-windows, the window it is attached to. Otherwise null. 908 */ 909 public void applyPostLayoutPolicyLw(WindowState win, 910 WindowManager.LayoutParams attrs, WindowState attached); 911 912 /** 913 * Called following layout of all windows and after policy has been applied 914 * to each window. If in this function you do 915 * something that may have modified the animation state of another window, 916 * be sure to return non-zero in order to perform another pass through layout. 917 * 918 * @return Return any bit set of {@link #FINISH_LAYOUT_REDO_LAYOUT}, 919 * {@link #FINISH_LAYOUT_REDO_CONFIG}, {@link #FINISH_LAYOUT_REDO_WALLPAPER}, 920 * or {@link #FINISH_LAYOUT_REDO_ANIM}. 921 */ 922 public int finishPostLayoutPolicyLw(); 923 924 /** 925 * Return true if it is okay to perform animations for an app transition 926 * that is about to occur. You may return false for this if, for example, 927 * the lock screen is currently displayed so the switch should happen 928 * immediately. 929 */ 930 public boolean allowAppAnimationsLw(); 931 932 933 /** 934 * A new window has been focused. 935 */ 936 public int focusChangedLw(WindowState lastFocus, WindowState newFocus); 937 938 /** 939 * Called when the device is waking up. 940 */ 941 public void wakingUp(); 942 943 /** 944 * Called when the device is going to sleep. 945 * 946 * @param why {@link #OFF_BECAUSE_OF_USER} or 947 * {@link #OFF_BECAUSE_OF_TIMEOUT}. 948 */ 949 public void goingToSleep(int why); 950 951 /** 952 * Called when the device is about to turn on the screen to show content. 953 * When waking up, this method will be called once after the call to wakingUp(). 954 * When dozing, the method will be called sometime after the call to goingToSleep() and 955 * may be called repeatedly in the case where the screen is pulsing on and off. 956 * 957 * Must call back on the listener to tell it when the higher-level system 958 * is ready for the screen to go on (i.e. the lock screen is shown). 959 */ 960 public void screenTurningOn(ScreenOnListener screenOnListener); 961 962 /** 963 * Called when the device has turned the screen off. 964 */ 965 public void screenTurnedOff(); 966 967 public interface ScreenOnListener { 968 void onScreenOn(); 969 } 970 971 /** 972 * Return whether the default display is on and not blocked by a black surface. 973 */ 974 public boolean isScreenOn(); 975 976 /** 977 * Tell the policy that the lid switch has changed state. 978 * @param whenNanos The time when the change occurred in uptime nanoseconds. 979 * @param lidOpen True if the lid is now open. 980 */ 981 public void notifyLidSwitchChanged(long whenNanos, boolean lidOpen); 982 983 /** 984 * Tell the policy that the camera lens has been covered or uncovered. 985 * @param whenNanos The time when the change occurred in uptime nanoseconds. 986 * @param lensCovered True if the lens is covered. 987 */ 988 public void notifyCameraLensCoverSwitchChanged(long whenNanos, boolean lensCovered); 989 990 /** 991 * Tell the policy if anyone is requesting that keyguard not come on. 992 * 993 * @param enabled Whether keyguard can be on or not. does not actually 994 * turn it on, unless it was previously disabled with this function. 995 * 996 * @see android.app.KeyguardManager.KeyguardLock#disableKeyguard() 997 * @see android.app.KeyguardManager.KeyguardLock#reenableKeyguard() 998 */ 999 @SuppressWarnings("javadoc") 1000 public void enableKeyguard(boolean enabled); 1001 1002 /** 1003 * Callback used by {@link WindowManagerPolicy#exitKeyguardSecurely} 1004 */ 1005 interface OnKeyguardExitResult { 1006 void onKeyguardExitResult(boolean success); 1007 } 1008 1009 /** 1010 * Tell the policy if anyone is requesting the keyguard to exit securely 1011 * (this would be called after the keyguard was disabled) 1012 * @param callback Callback to send the result back. 1013 * @see android.app.KeyguardManager#exitKeyguardSecurely(android.app.KeyguardManager.OnKeyguardExitResult) 1014 */ 1015 @SuppressWarnings("javadoc") 1016 void exitKeyguardSecurely(OnKeyguardExitResult callback); 1017 1018 /** 1019 * isKeyguardLocked 1020 * 1021 * Return whether the keyguard is currently locked. 1022 * 1023 * @return true if in keyguard is locked. 1024 */ 1025 public boolean isKeyguardLocked(); 1026 1027 /** 1028 * isKeyguardSecure 1029 * 1030 * Return whether the keyguard requires a password to unlock. 1031 * 1032 * @return true if in keyguard is secure. 1033 */ 1034 public boolean isKeyguardSecure(); 1035 1036 /** 1037 * inKeyguardRestrictedKeyInputMode 1038 * 1039 * if keyguard screen is showing or in restricted key input mode (i.e. in 1040 * keyguard password emergency screen). When in such mode, certain keys, 1041 * such as the Home key and the right soft keys, don't work. 1042 * 1043 * @return true if in keyguard restricted input mode. 1044 */ 1045 public boolean inKeyguardRestrictedKeyInputMode(); 1046 1047 /** 1048 * Ask the policy to dismiss the keyguard, if it is currently shown. 1049 */ 1050 public void dismissKeyguardLw(); 1051 1052 /** 1053 * Notifies the keyguard that the activity has drawn it was waiting for. 1054 */ 1055 public void notifyActivityDrawnForKeyguardLw(); 1056 1057 /** 1058 * Ask the policy whether the Keyguard has drawn. If the Keyguard is disabled, this method 1059 * returns true as soon as we know that Keyguard is disabled. 1060 * 1061 * @return true if the keyguard has drawn. 1062 */ 1063 public boolean isKeyguardDrawnLw(); 1064 1065 /** 1066 * Given an orientation constant, returns the appropriate surface rotation, 1067 * taking into account sensors, docking mode, rotation lock, and other factors. 1068 * 1069 * @param orientation An orientation constant, such as 1070 * {@link android.content.pm.ActivityInfo#SCREEN_ORIENTATION_LANDSCAPE}. 1071 * @param lastRotation The most recently used rotation. 1072 * @return The surface rotation to use. 1073 */ 1074 public int rotationForOrientationLw(@ActivityInfo.ScreenOrientation int orientation, 1075 int lastRotation); 1076 1077 /** 1078 * Given an orientation constant and a rotation, returns true if the rotation 1079 * has compatible metrics to the requested orientation. For example, if 1080 * the application requested landscape and got seascape, then the rotation 1081 * has compatible metrics; if the application requested portrait and got landscape, 1082 * then the rotation has incompatible metrics; if the application did not specify 1083 * a preference, then anything goes. 1084 * 1085 * @param orientation An orientation constant, such as 1086 * {@link android.content.pm.ActivityInfo#SCREEN_ORIENTATION_LANDSCAPE}. 1087 * @param rotation The rotation to check. 1088 * @return True if the rotation is compatible with the requested orientation. 1089 */ 1090 public boolean rotationHasCompatibleMetricsLw(@ActivityInfo.ScreenOrientation int orientation, 1091 int rotation); 1092 1093 /** 1094 * Called by the window manager when the rotation changes. 1095 * 1096 * @param rotation The new rotation. 1097 */ 1098 public void setRotationLw(int rotation); 1099 1100 /** 1101 * Called when the system is mostly done booting to set whether 1102 * the system should go into safe mode. 1103 */ 1104 public void setSafeMode(boolean safeMode); 1105 1106 /** 1107 * Called when the system is mostly done booting. 1108 */ 1109 public void systemReady(); 1110 1111 /** 1112 * Called when the system is done booting to the point where the 1113 * user can start interacting with it. 1114 */ 1115 public void systemBooted(); 1116 1117 /** 1118 * Show boot time message to the user. 1119 */ 1120 public void showBootMessage(final CharSequence msg, final boolean always); 1121 1122 /** 1123 * Hide the UI for showing boot messages, never to be displayed again. 1124 */ 1125 public void hideBootMessages(); 1126 1127 /** 1128 * Called when userActivity is signalled in the power manager. 1129 * This is safe to call from any thread, with any window manager locks held or not. 1130 */ 1131 public void userActivity(); 1132 1133 /** 1134 * Called when we have finished booting and can now display the home 1135 * screen to the user. This will happen after systemReady(), and at 1136 * this point the display is active. 1137 */ 1138 public void enableScreenAfterBoot(); 1139 1140 public void setCurrentOrientationLw(@ActivityInfo.ScreenOrientation int newOrientation); 1141 1142 /** 1143 * Call from application to perform haptic feedback on its window. 1144 */ 1145 public boolean performHapticFeedbackLw(WindowState win, int effectId, boolean always); 1146 1147 /** 1148 * Called when we have started keeping the screen on because a window 1149 * requesting this has become visible. 1150 */ 1151 public void keepScreenOnStartedLw(); 1152 1153 /** 1154 * Called when we have stopped keeping the screen on because the last window 1155 * requesting this is no longer visible. 1156 */ 1157 public void keepScreenOnStoppedLw(); 1158 1159 /** 1160 * Gets the current user rotation mode. 1161 * 1162 * @return The rotation mode. 1163 * 1164 * @see WindowManagerPolicy#USER_ROTATION_LOCKED 1165 * @see WindowManagerPolicy#USER_ROTATION_FREE 1166 */ 1167 @UserRotationMode 1168 public int getUserRotationMode(); 1169 1170 /** 1171 * Inform the policy that the user has chosen a preferred orientation ("rotation lock"). 1172 * 1173 * @param mode One of {@link WindowManagerPolicy#USER_ROTATION_LOCKED} or 1174 * {@link WindowManagerPolicy#USER_ROTATION_FREE}. 1175 * @param rotation One of {@link Surface#ROTATION_0}, {@link Surface#ROTATION_90}, 1176 * {@link Surface#ROTATION_180}, {@link Surface#ROTATION_270}. 1177 */ 1178 public void setUserRotationMode(@UserRotationMode int mode, @Surface.Rotation int rotation); 1179 1180 /** 1181 * Called when a new system UI visibility is being reported, allowing 1182 * the policy to adjust what is actually reported. 1183 * @param visibility The raw visibility reported by the status bar. 1184 * @return The new desired visibility. 1185 */ 1186 public int adjustSystemUiVisibilityLw(int visibility); 1187 1188 /** 1189 * Specifies whether there is an on-screen navigation bar separate from the status bar. 1190 */ 1191 public boolean hasNavigationBar(); 1192 1193 /** 1194 * Lock the device now. 1195 */ 1196 public void lockNow(Bundle options); 1197 1198 /** 1199 * Set the last used input method window state. This state is used to make IME transition 1200 * smooth. 1201 * @hide 1202 */ 1203 public void setLastInputMethodWindowLw(WindowState ime, WindowState target); 1204 1205 /** 1206 * Show the recents task list app. 1207 * @hide 1208 */ 1209 public void showRecentApps(); 1210 1211 /** 1212 * Show the global actions dialog. 1213 * @hide 1214 */ 1215 public void showGlobalActions(); 1216 1217 /** 1218 * @return The current height of the input method window. 1219 */ 1220 public int getInputMethodWindowVisibleHeightLw(); 1221 1222 /** 1223 * Called when the current user changes. Guaranteed to be called before the broadcast 1224 * of the new user id is made to all listeners. 1225 * 1226 * @param newUserId The id of the incoming user. 1227 */ 1228 public void setCurrentUserLw(int newUserId); 1229 1230 /** 1231 * Print the WindowManagerPolicy's state into the given stream. 1232 * 1233 * @param prefix Text to print at the front of each line. 1234 * @param writer The PrintWriter to which you should dump your state. This will be 1235 * closed for you after you return. 1236 * @param args additional arguments to the dump request. 1237 */ 1238 public void dump(String prefix, PrintWriter writer, String[] args); 1239 1240 /** 1241 * Returns whether a given window type can be magnified. 1242 * 1243 * @param windowType The window type. 1244 * @return True if the window can be magnified. 1245 */ 1246 public boolean canMagnifyWindow(int windowType); 1247 1248 /** 1249 * Returns whether a given window type is considered a top level one. 1250 * A top level window does not have a container, i.e. attached window, 1251 * or if it has a container it is laid out as a top-level window, not 1252 * as a child of its container. 1253 * 1254 * @param windowType The window type. 1255 * @return True if the window is a top level one. 1256 */ 1257 public boolean isTopLevelWindow(int windowType); 1258 1259 /** 1260 * Notifies the keyguard to start fading out. 1261 * 1262 * @param startTime the start time of the animation in uptime milliseconds 1263 * @param fadeoutDuration the duration of the exit animation, in milliseconds 1264 */ 1265 public void startKeyguardExitAnimation(long startTime, long fadeoutDuration); 1266 } 1267
