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 */ computeFrameLw(Rect parentFrame, Rect displayFrame, Rect contentFrame, Rect visibleFrame)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 */ getFrameLw()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 */ getShownFrameLw()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 */ getDisplayFrameLw()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 */ getContentFrameLw()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 */ getVisibleFrameLw()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 */ getGivenInsetsPendingLw()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 */ getGivenContentInsetsLw()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 */ getGivenVisibleInsetsLw()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 */ getAttrs()238 public WindowManager.LayoutParams getAttrs(); 239 240 /** 241 * Retrieve the current system UI visibility flags associated with 242 * this window. 243 */ getSystemUiVisibility()244 public int getSystemUiVisibility(); 245 246 /** 247 * Get the layer at which this window's surface will be Z-ordered. 248 */ getSurfaceLayer()249 public int getSurfaceLayer(); 250 251 /** 252 * Return the token for the application (actually activity) that owns 253 * this window. May return null for system windows. 254 * 255 * @return An IApplicationToken identifying the owning activity. 256 */ getAppToken()257 public IApplicationToken getAppToken(); 258 259 /** 260 * Return true if, at any point, the application token associated with 261 * this window has actually displayed any windows. This is most useful 262 * with the "starting up" window to determine if any windows were 263 * displayed when it is closed. 264 * 265 * @return Returns true if one or more windows have been displayed, 266 * else false. 267 */ hasAppShownWindows()268 public boolean hasAppShownWindows(); 269 270 /** 271 * Is this window visible? It is not visible if there is no 272 * surface, or we are in the process of running an exit animation 273 * that will remove the surface. 274 */ isVisibleLw()275 boolean isVisibleLw(); 276 277 /** 278 * Like {@link #isVisibleLw}, but also counts a window that is currently 279 * "hidden" behind the keyguard as visible. This allows us to apply 280 * things like window flags that impact the keyguard. 281 */ isVisibleOrBehindKeyguardLw()282 boolean isVisibleOrBehindKeyguardLw(); 283 284 /** 285 * Is this window currently visible to the user on-screen? It is 286 * displayed either if it is visible or it is currently running an 287 * animation before no longer being visible. Must be called with the 288 * window manager lock held. 289 */ isDisplayedLw()290 boolean isDisplayedLw(); 291 292 /** 293 * Returns true if this window has been shown on screen at some time in 294 * the past. Must be called with the window manager lock held. 295 * 296 * @return boolean 297 */ hasDrawnLw()298 public boolean hasDrawnLw(); 299 300 /** 301 * Can be called by the policy to force a window to be hidden, 302 * regardless of whether the client or window manager would like 303 * it shown. Must be called with the window manager lock held. 304 * Returns true if {@link #showLw} was last called for the window. 305 */ hideLw(boolean doAnimation)306 public boolean hideLw(boolean doAnimation); 307 308 /** 309 * Can be called to undo the effect of {@link #hideLw}, allowing a 310 * window to be shown as long as the window manager and client would 311 * also like it to be shown. Must be called with the window manager 312 * lock held. 313 * Returns true if {@link #hideLw} was last called for the window. 314 */ showLw(boolean doAnimation)315 public boolean showLw(boolean doAnimation); 316 } 317 318 /** 319 * Representation of a "fake window" that the policy has added to the 320 * window manager to consume events. 321 */ 322 public interface FakeWindow { 323 /** 324 * Remove the fake window from the window manager. 325 */ dismiss()326 void dismiss(); 327 } 328 329 /** 330 * Interface for calling back in to the window manager that is private 331 * between it and the policy. 332 */ 333 public interface WindowManagerFuncs { 334 /** 335 * Ask the window manager to re-evaluate the system UI flags. 336 */ reevaluateStatusBarVisibility()337 public void reevaluateStatusBarVisibility(); 338 339 /** 340 * Add a fake window to the window manager. This window sits 341 * at the top of the other windows and consumes events. 342 */ addFakeWindow(Looper looper, InputHandler inputHandler, String name, int windowType, int layoutParamsFlags, boolean canReceiveKeys, boolean hasFocus, boolean touchFullscreen)343 public FakeWindow addFakeWindow(Looper looper, InputHandler inputHandler, 344 String name, int windowType, int layoutParamsFlags, boolean canReceiveKeys, 345 boolean hasFocus, boolean touchFullscreen); 346 } 347 348 /** 349 * Bit mask that is set for all enter transition. 350 */ 351 public final int TRANSIT_ENTER_MASK = 0x1000; 352 353 /** 354 * Bit mask that is set for all exit transitions. 355 */ 356 public final int TRANSIT_EXIT_MASK = 0x2000; 357 358 /** Not set up for a transition. */ 359 public final int TRANSIT_UNSET = -1; 360 /** No animation for transition. */ 361 public final int TRANSIT_NONE = 0; 362 /** Window has been added to the screen. */ 363 public final int TRANSIT_ENTER = 1 | TRANSIT_ENTER_MASK; 364 /** Window has been removed from the screen. */ 365 public final int TRANSIT_EXIT = 2 | TRANSIT_EXIT_MASK; 366 /** Window has been made visible. */ 367 public final int TRANSIT_SHOW = 3 | TRANSIT_ENTER_MASK; 368 /** Window has been made invisible. */ 369 public final int TRANSIT_HIDE = 4 | TRANSIT_EXIT_MASK; 370 /** The "application starting" preview window is no longer needed, and will 371 * animate away to show the real window. */ 372 public final int TRANSIT_PREVIEW_DONE = 5; 373 /** A window in a new activity is being opened on top of an existing one 374 * in the same task. */ 375 public final int TRANSIT_ACTIVITY_OPEN = 6 | TRANSIT_ENTER_MASK; 376 /** The window in the top-most activity is being closed to reveal the 377 * previous activity in the same task. */ 378 public final int TRANSIT_ACTIVITY_CLOSE = 7 | TRANSIT_EXIT_MASK; 379 /** A window in a new task is being opened on top of an existing one 380 * in another activity's task. */ 381 public final int TRANSIT_TASK_OPEN = 8 | TRANSIT_ENTER_MASK; 382 /** A window in the top-most activity is being closed to reveal the 383 * previous activity in a different task. */ 384 public final int TRANSIT_TASK_CLOSE = 9 | TRANSIT_EXIT_MASK; 385 /** A window in an existing task is being displayed on top of an existing one 386 * in another activity's task. */ 387 public final int TRANSIT_TASK_TO_FRONT = 10 | TRANSIT_ENTER_MASK; 388 /** A window in an existing task is being put below all other tasks. */ 389 public final int TRANSIT_TASK_TO_BACK = 11 | TRANSIT_EXIT_MASK; 390 /** A window in a new activity that doesn't have a wallpaper is being 391 * opened on top of one that does, effectively closing the wallpaper. */ 392 public final int TRANSIT_WALLPAPER_CLOSE = 12 | TRANSIT_EXIT_MASK; 393 /** A window in a new activity that does have a wallpaper is being 394 * opened on one that didn't, effectively opening the wallpaper. */ 395 public final int TRANSIT_WALLPAPER_OPEN = 13 | TRANSIT_ENTER_MASK; 396 /** A window in a new activity is being opened on top of an existing one, 397 * and both are on top of the wallpaper. */ 398 public final int TRANSIT_WALLPAPER_INTRA_OPEN = 14 | TRANSIT_ENTER_MASK; 399 /** The window in the top-most activity is being closed to reveal the 400 * previous activity, and both are on top of he wallpaper. */ 401 public final int TRANSIT_WALLPAPER_INTRA_CLOSE = 15 | TRANSIT_EXIT_MASK; 402 403 // NOTE: screen off reasons are in order of significance, with more 404 // important ones lower than less important ones. 405 406 /** Screen turned off because of a device admin */ 407 public final int OFF_BECAUSE_OF_ADMIN = 1; 408 /** Screen turned off because of power button */ 409 public final int OFF_BECAUSE_OF_USER = 2; 410 /** Screen turned off because of timeout */ 411 public final int OFF_BECAUSE_OF_TIMEOUT = 3; 412 /** Screen turned off because of proximity sensor */ 413 public final int OFF_BECAUSE_OF_PROX_SENSOR = 4; 414 415 /** When not otherwise specified by the activity's screenOrientation, rotation should be 416 * determined by the system (that is, using sensors). */ 417 public final int USER_ROTATION_FREE = 0; 418 /** When not otherwise specified by the activity's screenOrientation, rotation is set by 419 * the user. */ 420 public final int USER_ROTATION_LOCKED = 1; 421 422 /** 423 * Perform initialization of the policy. 424 * 425 * @param context The system context we are running in. 426 * @param powerManager 427 */ init(Context context, IWindowManager windowManager, WindowManagerFuncs windowManagerFuncs, LocalPowerManager powerManager)428 public void init(Context context, IWindowManager windowManager, 429 WindowManagerFuncs windowManagerFuncs, 430 LocalPowerManager powerManager); 431 432 /** 433 * Called by window manager once it has the initial, default native 434 * display dimensions. 435 */ setInitialDisplaySize(int width, int height)436 public void setInitialDisplaySize(int width, int height); 437 438 /** 439 * Check permissions when adding a window. 440 * 441 * @param attrs The window's LayoutParams. 442 * 443 * @return {@link WindowManagerImpl#ADD_OKAY} if the add can proceed; 444 * else an error code, usually 445 * {@link WindowManagerImpl#ADD_PERMISSION_DENIED}, to abort the add. 446 */ checkAddPermission(WindowManager.LayoutParams attrs)447 public int checkAddPermission(WindowManager.LayoutParams attrs); 448 449 /** 450 * Sanitize the layout parameters coming from a client. Allows the policy 451 * to do things like ensure that windows of a specific type can't take 452 * input focus. 453 * 454 * @param attrs The window layout parameters to be modified. These values 455 * are modified in-place. 456 */ adjustWindowParamsLw(WindowManager.LayoutParams attrs)457 public void adjustWindowParamsLw(WindowManager.LayoutParams attrs); 458 459 /** 460 * After the window manager has computed the current configuration based 461 * on its knowledge of the display and input devices, it gives the policy 462 * a chance to adjust the information contained in it. If you want to 463 * leave it as-is, simply do nothing. 464 * 465 * <p>This method may be called by any thread in the window manager, but 466 * no internal locks in the window manager will be held. 467 * 468 * @param config The Configuration being computed, for you to change as 469 * desired. 470 */ adjustConfigurationLw(Configuration config)471 public void adjustConfigurationLw(Configuration config); 472 473 /** 474 * Assign a window type to a layer. Allows you to control how different 475 * kinds of windows are ordered on-screen. 476 * 477 * @param type The type of window being assigned. 478 * 479 * @return int An arbitrary integer used to order windows, with lower 480 * numbers below higher ones. 481 */ windowTypeToLayerLw(int type)482 public int windowTypeToLayerLw(int type); 483 484 /** 485 * Return how to Z-order sub-windows in relation to the window they are 486 * attached to. Return positive to have them ordered in front, negative for 487 * behind. 488 * 489 * @param type The sub-window type code. 490 * 491 * @return int Layer in relation to the attached window, where positive is 492 * above and negative is below. 493 */ subWindowTypeToLayerLw(int type)494 public int subWindowTypeToLayerLw(int type); 495 496 /** 497 * Get the highest layer (actually one more than) that the wallpaper is 498 * allowed to be in. 499 */ getMaxWallpaperLayer()500 public int getMaxWallpaperLayer(); 501 502 /** 503 * Return true if the policy allows the status bar to hide. Otherwise, 504 * it is a tablet-style system bar. 505 */ canStatusBarHide()506 public boolean canStatusBarHide(); 507 508 /** 509 * Return the display width available after excluding any screen 510 * decorations that can never be removed. That is, system bar or 511 * button bar. 512 */ getNonDecorDisplayWidth(int fullWidth, int fullHeight, int rotation)513 public int getNonDecorDisplayWidth(int fullWidth, int fullHeight, int rotation); 514 515 /** 516 * Return the display height available after excluding any screen 517 * decorations that can never be removed. That is, system bar or 518 * button bar. 519 */ getNonDecorDisplayHeight(int fullWidth, int fullHeight, int rotation)520 public int getNonDecorDisplayHeight(int fullWidth, int fullHeight, int rotation); 521 522 /** 523 * Return the available screen width that we should report for the 524 * configuration. This must be no larger than 525 * {@link #getNonDecorDisplayWidth(int, int)}; it may be smaller than 526 * that to account for more transient decoration like a status bar. 527 */ getConfigDisplayWidth(int fullWidth, int fullHeight, int rotation)528 public int getConfigDisplayWidth(int fullWidth, int fullHeight, int rotation); 529 530 /** 531 * Return the available screen height that we should report for the 532 * configuration. This must be no larger than 533 * {@link #getNonDecorDisplayHeight(int, int)}; it may be smaller than 534 * that to account for more transient decoration like a status bar. 535 */ getConfigDisplayHeight(int fullWidth, int fullHeight, int rotation)536 public int getConfigDisplayHeight(int fullWidth, int fullHeight, int rotation); 537 538 /** 539 * Return whether the given window should forcibly hide everything 540 * behind it. Typically returns true for the keyguard. 541 */ doesForceHide(WindowState win, WindowManager.LayoutParams attrs)542 public boolean doesForceHide(WindowState win, WindowManager.LayoutParams attrs); 543 544 /** 545 * Determine if a window that is behind one that is force hiding 546 * (as determined by {@link #doesForceHide}) should actually be hidden. 547 * For example, typically returns false for the status bar. Be careful 548 * to return false for any window that you may hide yourself, since this 549 * will conflict with what you set. 550 */ canBeForceHidden(WindowState win, WindowManager.LayoutParams attrs)551 public boolean canBeForceHidden(WindowState win, WindowManager.LayoutParams attrs); 552 553 /** 554 * Called when the system would like to show a UI to indicate that an 555 * application is starting. You can use this to add a 556 * APPLICATION_STARTING_TYPE window with the given appToken to the window 557 * manager (using the normal window manager APIs) that will be shown until 558 * the application displays its own window. This is called without the 559 * window manager locked so that you can call back into it. 560 * 561 * @param appToken Token of the application being started. 562 * @param packageName The name of the application package being started. 563 * @param theme Resource defining the application's overall visual theme. 564 * @param nonLocalizedLabel The default title label of the application if 565 * no data is found in the resource. 566 * @param labelRes The resource ID the application would like to use as its name. 567 * @param icon The resource ID the application would like to use as its icon. 568 * @param windowFlags Window layout flags. 569 * 570 * @return Optionally you can return the View that was used to create the 571 * window, for easy removal in removeStartingWindow. 572 * 573 * @see #removeStartingWindow 574 */ addStartingWindow(IBinder appToken, String packageName, int theme, CompatibilityInfo compatInfo, CharSequence nonLocalizedLabel, int labelRes, int icon, int windowFlags)575 public View addStartingWindow(IBinder appToken, String packageName, 576 int theme, CompatibilityInfo compatInfo, CharSequence nonLocalizedLabel, 577 int labelRes, int icon, int windowFlags); 578 579 /** 580 * Called when the first window of an application has been displayed, while 581 * {@link #addStartingWindow} has created a temporary initial window for 582 * that application. You should at this point remove the window from the 583 * window manager. This is called without the window manager locked so 584 * that you can call back into it. 585 * 586 * <p>Note: due to the nature of these functions not being called with the 587 * window manager locked, you must be prepared for this function to be 588 * called multiple times and/or an initial time with a null View window 589 * even if you previously returned one. 590 * 591 * @param appToken Token of the application that has started. 592 * @param window Window View that was returned by createStartingWindow. 593 * 594 * @see #addStartingWindow 595 */ removeStartingWindow(IBinder appToken, View window)596 public void removeStartingWindow(IBinder appToken, View window); 597 598 /** 599 * Prepare for a window being added to the window manager. You can throw an 600 * exception here to prevent the window being added, or do whatever setup 601 * you need to keep track of the window. 602 * 603 * @param win The window being added. 604 * @param attrs The window's LayoutParams. 605 * 606 * @return {@link WindowManagerImpl#ADD_OKAY} if the add can proceed, else an 607 * error code to abort the add. 608 */ prepareAddWindowLw(WindowState win, WindowManager.LayoutParams attrs)609 public int prepareAddWindowLw(WindowState win, 610 WindowManager.LayoutParams attrs); 611 612 /** 613 * Called when a window is being removed from a window manager. Must not 614 * throw an exception -- clean up as much as possible. 615 * 616 * @param win The window being removed. 617 */ removeWindowLw(WindowState win)618 public void removeWindowLw(WindowState win); 619 620 /** 621 * Control the animation to run when a window's state changes. Return a 622 * non-0 number to force the animation to a specific resource ID, or 0 623 * to use the default animation. 624 * 625 * @param win The window that is changing. 626 * @param transit What is happening to the window: {@link #TRANSIT_ENTER}, 627 * {@link #TRANSIT_EXIT}, {@link #TRANSIT_SHOW}, or 628 * {@link #TRANSIT_HIDE}. 629 * 630 * @return Resource ID of the actual animation to use, or 0 for none. 631 */ selectAnimationLw(WindowState win, int transit)632 public int selectAnimationLw(WindowState win, int transit); 633 634 /** 635 * Create and return an animation to re-display a force hidden window. 636 */ createForceHideEnterAnimation()637 public Animation createForceHideEnterAnimation(); 638 639 /** 640 * Called from the input reader thread before a key is enqueued. 641 * 642 * <p>There are some actions that need to be handled here because they 643 * affect the power state of the device, for example, the power keys. 644 * Generally, it's best to keep as little as possible in the queue thread 645 * because it's the most fragile. 646 * @param event The key event. 647 * @param policyFlags The policy flags associated with the key. 648 * @param isScreenOn True if the screen is already on 649 * 650 * @return The bitwise or of the {@link #ACTION_PASS_TO_USER}, 651 * {@link #ACTION_POKE_USER_ACTIVITY} and {@link #ACTION_GO_TO_SLEEP} flags. 652 */ interceptKeyBeforeQueueing(KeyEvent event, int policyFlags, boolean isScreenOn)653 public int interceptKeyBeforeQueueing(KeyEvent event, int policyFlags, boolean isScreenOn); 654 655 /** 656 * Called from the input reader thread before a motion is enqueued when the screen is off. 657 * 658 * <p>There are some actions that need to be handled here because they 659 * affect the power state of the device, for example, waking on motions. 660 * Generally, it's best to keep as little as possible in the queue thread 661 * because it's the most fragile. 662 * @param policyFlags The policy flags associated with the motion. 663 * 664 * @return The bitwise or of the {@link #ACTION_PASS_TO_USER}, 665 * {@link #ACTION_POKE_USER_ACTIVITY} and {@link #ACTION_GO_TO_SLEEP} flags. 666 */ interceptMotionBeforeQueueingWhenScreenOff(int policyFlags)667 public int interceptMotionBeforeQueueingWhenScreenOff(int policyFlags); 668 669 /** 670 * Called from the input dispatcher thread before a key is dispatched to a window. 671 * 672 * <p>Allows you to define 673 * behavior for keys that can not be overridden by applications. 674 * This method is called from the input thread, with no locks held. 675 * 676 * @param win The window that currently has focus. This is where the key 677 * event will normally go. 678 * @param event The key event. 679 * @param policyFlags The policy flags associated with the key. 680 * @return 0 if the key should be dispatched immediately, -1 if the key should 681 * not be dispatched ever, or a positive value indicating the number of 682 * milliseconds by which the key dispatch should be delayed before trying 683 * again. 684 */ interceptKeyBeforeDispatching(WindowState win, KeyEvent event, int policyFlags)685 public long interceptKeyBeforeDispatching(WindowState win, KeyEvent event, int policyFlags); 686 687 /** 688 * Called from the input dispatcher thread when an application did not handle 689 * a key that was dispatched to it. 690 * 691 * <p>Allows you to define default global behavior for keys that were not handled 692 * by applications. This method is called from the input thread, with no locks held. 693 * 694 * @param win The window that currently has focus. This is where the key 695 * event will normally go. 696 * @param event The key event. 697 * @param policyFlags The policy flags associated with the key. 698 * @return Returns an alternate key event to redispatch as a fallback, or null to give up. 699 * The caller is responsible for recycling the key event. 700 */ dispatchUnhandledKey(WindowState win, KeyEvent event, int policyFlags)701 public KeyEvent dispatchUnhandledKey(WindowState win, KeyEvent event, int policyFlags); 702 703 /** 704 * Called when layout of the windows is about to start. 705 * 706 * @param displayWidth The current full width of the screen. 707 * @param displayHeight The current full height of the screen. 708 * @param displayRotation The current rotation being applied to the base 709 * window. 710 */ beginLayoutLw(int displayWidth, int displayHeight, int displayRotation)711 public void beginLayoutLw(int displayWidth, int displayHeight, int displayRotation); 712 713 /** 714 * Called for each window attached to the window manager as layout is 715 * proceeding. The implementation of this function must take care of 716 * setting the window's frame, either here or in finishLayout(). 717 * 718 * @param win The window being positioned. 719 * @param attrs The LayoutParams of the window. 720 * @param attached For sub-windows, the window it is attached to; this 721 * window will already have had layoutWindow() called on it 722 * so you can use its Rect. Otherwise null. 723 */ layoutWindowLw(WindowState win, WindowManager.LayoutParams attrs, WindowState attached)724 public void layoutWindowLw(WindowState win, 725 WindowManager.LayoutParams attrs, WindowState attached); 726 727 728 /** 729 * Return the insets for the areas covered by system windows. These values 730 * are computed on the most recent layout, so they are not guaranteed to 731 * be correct. 732 * 733 * @param attrs The LayoutParams of the window. 734 * @param contentInset The areas covered by system windows, expressed as positive insets 735 * 736 */ getContentInsetHintLw(WindowManager.LayoutParams attrs, Rect contentInset)737 public void getContentInsetHintLw(WindowManager.LayoutParams attrs, Rect contentInset); 738 739 /** 740 * Called when layout of the windows is finished. After this function has 741 * returned, all windows given to layoutWindow() <em>must</em> have had a 742 * frame assigned. 743 * 744 * @return Return any bit set of {@link #FINISH_LAYOUT_REDO_LAYOUT}, 745 * {@link #FINISH_LAYOUT_REDO_CONFIG}, {@link #FINISH_LAYOUT_REDO_WALLPAPER}, 746 * or {@link #FINISH_LAYOUT_REDO_ANIM}. 747 */ finishLayoutLw()748 public int finishLayoutLw(); 749 750 /** Layout state may have changed (so another layout will be performed) */ 751 static final int FINISH_LAYOUT_REDO_LAYOUT = 0x0001; 752 /** Configuration state may have changed */ 753 static final int FINISH_LAYOUT_REDO_CONFIG = 0x0002; 754 /** Wallpaper may need to move */ 755 static final int FINISH_LAYOUT_REDO_WALLPAPER = 0x0004; 756 /** Need to recompute animations */ 757 static final int FINISH_LAYOUT_REDO_ANIM = 0x0008; 758 759 /** 760 * Called when animation of the windows is about to start. 761 * 762 * @param displayWidth The current full width of the screen. 763 * @param displayHeight The current full height of the screen. 764 */ beginAnimationLw(int displayWidth, int displayHeight)765 public void beginAnimationLw(int displayWidth, int displayHeight); 766 767 /** 768 * Called each time a window is animating. 769 * 770 * @param win The window being positioned. 771 * @param attrs The LayoutParams of the window. 772 */ animatingWindowLw(WindowState win, WindowManager.LayoutParams attrs)773 public void animatingWindowLw(WindowState win, 774 WindowManager.LayoutParams attrs); 775 776 /** 777 * Called when animation of the windows is finished. If in this function you do 778 * something that may have modified the animation state of another window, 779 * be sure to return true in order to perform another animation frame. 780 * 781 * @return Return any bit set of {@link #FINISH_LAYOUT_REDO_LAYOUT}, 782 * {@link #FINISH_LAYOUT_REDO_CONFIG}, {@link #FINISH_LAYOUT_REDO_WALLPAPER}, 783 * or {@link #FINISH_LAYOUT_REDO_ANIM}. 784 */ finishAnimationLw()785 public int finishAnimationLw(); 786 787 /** 788 * Return true if it is okay to perform animations for an app transition 789 * that is about to occur. You may return false for this if, for example, 790 * the lock screen is currently displayed so the switch should happen 791 * immediately. 792 */ allowAppAnimationsLw()793 public boolean allowAppAnimationsLw(); 794 795 796 /** 797 * A new window has been focused. 798 */ focusChangedLw(WindowState lastFocus, WindowState newFocus)799 public int focusChangedLw(WindowState lastFocus, WindowState newFocus); 800 801 /** 802 * Called after the screen turns off. 803 * 804 * @param why {@link #OFF_BECAUSE_OF_USER} or 805 * {@link #OFF_BECAUSE_OF_TIMEOUT}. 806 */ screenTurnedOff(int why)807 public void screenTurnedOff(int why); 808 809 public interface ScreenOnListener { onScreenOn()810 void onScreenOn(); 811 }; 812 813 /** 814 * Called when the power manager would like to turn the screen on. 815 * Must call back on the listener to tell it when the higher-level system 816 * is ready for the screen to go on (i.e. the lock screen is shown). 817 */ screenTurningOn(ScreenOnListener screenOnListener)818 public void screenTurningOn(ScreenOnListener screenOnListener); 819 820 /** 821 * Return whether the screen is about to turn on or is currently on. 822 */ isScreenOnEarly()823 public boolean isScreenOnEarly(); 824 825 /** 826 * Return whether the screen is fully turned on. 827 */ isScreenOnFully()828 public boolean isScreenOnFully(); 829 830 /** 831 * Tell the policy that the lid switch has changed state. 832 * @param whenNanos The time when the change occurred in uptime nanoseconds. 833 * @param lidOpen True if the lid is now open. 834 */ notifyLidSwitchChanged(long whenNanos, boolean lidOpen)835 public void notifyLidSwitchChanged(long whenNanos, boolean lidOpen); 836 837 /** 838 * Tell the policy if anyone is requesting that keyguard not come on. 839 * 840 * @param enabled Whether keyguard can be on or not. does not actually 841 * turn it on, unless it was previously disabled with this function. 842 * 843 * @see android.app.KeyguardManager.KeyguardLock#disableKeyguard() 844 * @see android.app.KeyguardManager.KeyguardLock#reenableKeyguard() 845 */ enableKeyguard(boolean enabled)846 public void enableKeyguard(boolean enabled); 847 848 /** 849 * Callback used by {@link WindowManagerPolicy#exitKeyguardSecurely} 850 */ 851 interface OnKeyguardExitResult { onKeyguardExitResult(boolean success)852 void onKeyguardExitResult(boolean success); 853 } 854 855 /** 856 * Tell the policy if anyone is requesting the keyguard to exit securely 857 * (this would be called after the keyguard was disabled) 858 * @param callback Callback to send the result back. 859 * @see android.app.KeyguardManager#exitKeyguardSecurely(android.app.KeyguardManager.OnKeyguardExitResult) 860 */ exitKeyguardSecurely(OnKeyguardExitResult callback)861 void exitKeyguardSecurely(OnKeyguardExitResult callback); 862 863 /** 864 * isKeyguardLocked 865 * 866 * Return whether the keyguard is currently locked. 867 * 868 * @return true if in keyguard is locked. 869 */ isKeyguardLocked()870 public boolean isKeyguardLocked(); 871 872 /** 873 * isKeyguardSecure 874 * 875 * Return whether the keyguard requires a password to unlock. 876 * 877 * @return true if in keyguard is secure. 878 */ isKeyguardSecure()879 public boolean isKeyguardSecure(); 880 881 /** 882 * inKeyguardRestrictedKeyInputMode 883 * 884 * if keyguard screen is showing or in restricted key input mode (i.e. in 885 * keyguard password emergency screen). When in such mode, certain keys, 886 * such as the Home key and the right soft keys, don't work. 887 * 888 * @return true if in keyguard restricted input mode. 889 */ inKeyguardRestrictedKeyInputMode()890 public boolean inKeyguardRestrictedKeyInputMode(); 891 892 /** 893 * Ask the policy to dismiss the keyguard, if it is currently shown. 894 */ dismissKeyguardLw()895 public void dismissKeyguardLw(); 896 897 /** 898 * Given an orientation constant, returns the appropriate surface rotation, 899 * taking into account sensors, docking mode, rotation lock, and other factors. 900 * 901 * @param orientation An orientation constant, such as 902 * {@link android.content.pm.ActivityInfo#SCREEN_ORIENTATION_LANDSCAPE}. 903 * @param lastRotation The most recently used rotation. 904 * @return The surface rotation to use. 905 */ rotationForOrientationLw(int orientation, int lastRotation)906 public int rotationForOrientationLw(int orientation, int lastRotation); 907 908 /** 909 * Given an orientation constant and a rotation, returns true if the rotation 910 * has compatible metrics to the requested orientation. For example, if 911 * the application requested landscape and got seascape, then the rotation 912 * has compatible metrics; if the application requested portrait and got landscape, 913 * then the rotation has incompatible metrics; if the application did not specify 914 * a preference, then anything goes. 915 * 916 * @param orientation An orientation constant, such as 917 * {@link android.content.pm.ActivityInfo#SCREEN_ORIENTATION_LANDSCAPE}. 918 * @param rotation The rotation to check. 919 * @return True if the rotation is compatible with the requested orientation. 920 */ rotationHasCompatibleMetricsLw(int orientation, int rotation)921 public boolean rotationHasCompatibleMetricsLw(int orientation, int rotation); 922 923 /** 924 * Called by the window manager when the rotation changes. 925 * 926 * @param rotation The new rotation. 927 */ setRotationLw(int rotation)928 public void setRotationLw(int rotation); 929 930 /** 931 * Called when the system is mostly done booting to determine whether 932 * the system should go into safe mode. 933 */ detectSafeMode()934 public boolean detectSafeMode(); 935 936 /** 937 * Called when the system is mostly done booting. 938 */ systemReady()939 public void systemReady(); 940 941 /** 942 * Called when the system is done booting to the point where the 943 * user can start interacting with it. 944 */ systemBooted()945 public void systemBooted(); 946 947 /** 948 * Show boot time message to the user. 949 */ showBootMessage(final CharSequence msg, final boolean always)950 public void showBootMessage(final CharSequence msg, final boolean always); 951 952 /** 953 * Hide the UI for showing boot messages, never to be displayed again. 954 */ hideBootMessages()955 public void hideBootMessages(); 956 957 /** 958 * Called when userActivity is signalled in the power manager. 959 * This is safe to call from any thread, with any window manager locks held or not. 960 */ userActivity()961 public void userActivity(); 962 963 /** 964 * Called when we have finished booting and can now display the home 965 * screen to the user. This wilWl happen after systemReady(), and at 966 * this point the display is active. 967 */ enableScreenAfterBoot()968 public void enableScreenAfterBoot(); 969 setCurrentOrientationLw(int newOrientation)970 public void setCurrentOrientationLw(int newOrientation); 971 972 /** 973 * Call from application to perform haptic feedback on its window. 974 */ performHapticFeedbackLw(WindowState win, int effectId, boolean always)975 public boolean performHapticFeedbackLw(WindowState win, int effectId, boolean always); 976 977 /** 978 * Called when we have started keeping the screen on because a window 979 * requesting this has become visible. 980 */ screenOnStartedLw()981 public void screenOnStartedLw(); 982 983 /** 984 * Called when we have stopped keeping the screen on because the last window 985 * requesting this is no longer visible. 986 */ screenOnStoppedLw()987 public void screenOnStoppedLw(); 988 989 /** 990 * Return false to disable key repeat events from being generated. 991 */ allowKeyRepeat()992 public boolean allowKeyRepeat(); 993 994 /** 995 * Inform the policy that the user has chosen a preferred orientation ("rotation lock"). 996 * 997 * @param mode One of {@link WindowManagerPolicy#USER_ROTATION_LOCKED} or 998 * {@link * WindowManagerPolicy#USER_ROTATION_FREE}. 999 * @param rotation One of {@link Surface#ROTATION_0}, {@link Surface#ROTATION_90}, 1000 * {@link Surface#ROTATION_180}, {@link Surface#ROTATION_270}. 1001 */ setUserRotationMode(int mode, int rotation)1002 public void setUserRotationMode(int mode, int rotation); 1003 1004 /** 1005 * Called when a new system UI visibility is being reported, allowing 1006 * the policy to adjust what is actually reported. 1007 * @param visibility The raw visiblity reported by the status bar. 1008 * @return The new desired visibility. 1009 */ adjustSystemUiVisibilityLw(int visibility)1010 public int adjustSystemUiVisibilityLw(int visibility); 1011 1012 /** 1013 * Specifies whether there is an on-screen navigation bar separate from the status bar. 1014 */ hasNavigationBar()1015 public boolean hasNavigationBar(); 1016 1017 /** 1018 * Print the WindowManagerPolicy's state into the given stream. 1019 * 1020 * @param prefix Text to print at the front of each line. 1021 * @param fd The raw file descriptor that the dump is being sent to. 1022 * @param writer The PrintWriter to which you should dump your state. This will be 1023 * closed for you after you return. 1024 * @param args additional arguments to the dump request. 1025 */ dump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args)1026 public void dump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args); 1027 } 1028