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.Configuration; 21 import android.graphics.Rect; 22 import android.os.IBinder; 23 import android.os.LocalPowerManager; 24 import android.view.animation.Animation; 25 26 /** 27 * This interface supplies all UI-specific behavior of the window manager. An 28 * instance of it is created by the window manager when it starts up, and allows 29 * customization of window layering, special window types, key dispatching, and 30 * layout. 31 * 32 * <p>Because this provides deep interaction with the system window manager, 33 * specific methods on this interface can be called from a variety of contexts 34 * with various restrictions on what they can do. These are encoded through 35 * a suffixes at the end of a method encoding the thread the method is called 36 * from and any locks that are held when it is being called; if no suffix 37 * is attached to a method, then it is not called with any locks and may be 38 * called from the main window manager thread or another thread calling into 39 * the window manager. 40 * 41 * <p>The current suffixes are: 42 * 43 * <dl> 44 * <dt> Ti <dd> Called from the input thread. This is the thread that 45 * collects pending input events and dispatches them to the appropriate window. 46 * It may block waiting for events to be processed, so that the input stream is 47 * properly serialized. 48 * <dt> Tq <dd> Called from the low-level input queue thread. This is the 49 * thread that reads events out of the raw input devices and places them 50 * into the global input queue that is read by the <var>Ti</var> thread. 51 * This thread should not block for a long period of time on anything but the 52 * key driver. 53 * <dt> Lw <dd> Called with the main window manager lock held. Because the 54 * window manager is a very low-level system service, there are few other 55 * system services you can call with this lock held. It is explicitly okay to 56 * make calls into the package manager and power manager; it is explicitly not 57 * okay to make calls into the activity manager or most other services. Note that 58 * {@link android.content.Context#checkPermission(String, int, int)} and 59 * variations require calling into the activity manager. 60 * <dt> Li <dd> Called with the input thread lock held. This lock can be 61 * acquired by the window manager while it holds the window lock, so this is 62 * even more restrictive than <var>Lw</var>. 63 * </dl> 64 * 65 * @hide 66 */ 67 public interface WindowManagerPolicy { 68 // Policy flags. These flags are also defined in frameworks/base/include/ui/Input.h. 69 public final static int FLAG_WAKE = 0x00000001; 70 public final static int FLAG_WAKE_DROPPED = 0x00000002; 71 public final static int FLAG_SHIFT = 0x00000004; 72 public final static int FLAG_CAPS_LOCK = 0x00000008; 73 public final static int FLAG_ALT = 0x00000010; 74 public final static int FLAG_ALT_GR = 0x00000020; 75 public final static int FLAG_MENU = 0x00000040; 76 public final static int FLAG_LAUNCHER = 0x00000080; 77 public final static int FLAG_VIRTUAL = 0x00000100; 78 79 public final static int FLAG_INJECTED = 0x01000000; 80 public final static int FLAG_TRUSTED = 0x02000000; 81 82 public final static int FLAG_WOKE_HERE = 0x10000000; 83 public final static int FLAG_BRIGHT_HERE = 0x20000000; 84 public final static int FLAG_PASS_TO_USER = 0x40000000; 85 86 public final static boolean WATCH_POINTER = false; 87 88 // flags for interceptKeyTq 89 /** 90 * Pass this event to the user / app. To be returned from {@link #interceptKeyTq}. 91 */ 92 public final static int ACTION_PASS_TO_USER = 0x00000001; 93 94 /** 95 * This key event should extend the user activity timeout and turn the lights on. 96 * To be returned from {@link #interceptKeyTq}. Do not return this and 97 * {@link #ACTION_GO_TO_SLEEP} or {@link #ACTION_PASS_TO_USER}. 98 */ 99 public final static int ACTION_POKE_USER_ACTIVITY = 0x00000002; 100 101 /** 102 * This key event should put the device to sleep (and engage keyguard if necessary) 103 * To be returned from {@link #interceptKeyTq}. Do not return this and 104 * {@link #ACTION_POKE_USER_ACTIVITY} or {@link #ACTION_PASS_TO_USER}. 105 */ 106 public final static int ACTION_GO_TO_SLEEP = 0x00000004; 107 108 /** 109 * Interface to the Window Manager state associated with a particular 110 * window. You can hold on to an instance of this interface from the call 111 * to prepareAddWindow() until removeWindow(). 112 */ 113 public interface WindowState { 114 /** 115 * Perform standard frame computation. The result can be obtained with 116 * getFrame() if so desired. Must be called with the window manager 117 * lock held. 118 * 119 * @param parentFrame The frame of the parent container this window 120 * is in, used for computing its basic position. 121 * @param displayFrame The frame of the overall display in which this 122 * window can appear, used for constraining the overall dimensions 123 * of the window. 124 * @param contentFrame The frame within the display in which we would 125 * like active content to appear. This will cause windows behind to 126 * be resized to match the given content frame. 127 * @param visibleFrame The frame within the display that the window 128 * is actually visible, used for computing its visible insets to be 129 * given to windows behind. 130 * This can be used as a hint for scrolling (avoiding resizing) 131 * the window to make certain that parts of its content 132 * are visible. 133 */ computeFrameLw(Rect parentFrame, Rect displayFrame, Rect contentFrame, Rect visibleFrame)134 public void computeFrameLw(Rect parentFrame, Rect displayFrame, 135 Rect contentFrame, Rect visibleFrame); 136 137 /** 138 * Retrieve the current frame of the window that has been assigned by 139 * the window manager. Must be called with the window manager lock held. 140 * 141 * @return Rect The rectangle holding the window frame. 142 */ getFrameLw()143 public Rect getFrameLw(); 144 145 /** 146 * Retrieve the current frame of the window that is actually shown. 147 * Must be called with the window manager lock held. 148 * 149 * @return Rect The rectangle holding the shown window frame. 150 */ getShownFrameLw()151 public Rect getShownFrameLw(); 152 153 /** 154 * Retrieve the frame of the display that this window was last 155 * laid out in. Must be called with the 156 * window manager lock held. 157 * 158 * @return Rect The rectangle holding the display frame. 159 */ getDisplayFrameLw()160 public Rect getDisplayFrameLw(); 161 162 /** 163 * Retrieve the frame of the content area that this window was last 164 * laid out in. This is the area in which the content of the window 165 * should be placed. It will be smaller than the display frame to 166 * account for screen decorations such as a status bar or soft 167 * keyboard. Must be called with the 168 * window manager lock held. 169 * 170 * @return Rect The rectangle holding the content frame. 171 */ getContentFrameLw()172 public Rect getContentFrameLw(); 173 174 /** 175 * Retrieve the frame of the visible area that this window was last 176 * laid out in. This is the area of the screen in which the window 177 * will actually be fully visible. It will be smaller than the 178 * content frame to account for transient UI elements blocking it 179 * such as an input method's candidates UI. Must be called with the 180 * window manager lock held. 181 * 182 * @return Rect The rectangle holding the visible frame. 183 */ getVisibleFrameLw()184 public Rect getVisibleFrameLw(); 185 186 /** 187 * Returns true if this window is waiting to receive its given 188 * internal insets from the client app, and so should not impact the 189 * layout of other windows. 190 */ getGivenInsetsPendingLw()191 public boolean getGivenInsetsPendingLw(); 192 193 /** 194 * Retrieve the insets given by this window's client for the content 195 * area of windows behind it. Must be called with the 196 * window manager lock held. 197 * 198 * @return Rect The left, top, right, and bottom insets, relative 199 * to the window's frame, of the actual contents. 200 */ getGivenContentInsetsLw()201 public Rect getGivenContentInsetsLw(); 202 203 /** 204 * Retrieve the insets given by this window's client for the visible 205 * area of windows behind it. Must be called with the 206 * window manager lock held. 207 * 208 * @return Rect The left, top, right, and bottom insets, relative 209 * to the window's frame, of the actual visible area. 210 */ getGivenVisibleInsetsLw()211 public Rect getGivenVisibleInsetsLw(); 212 213 /** 214 * Retrieve the current LayoutParams of the window. 215 * 216 * @return WindowManager.LayoutParams The window's internal LayoutParams 217 * instance. 218 */ getAttrs()219 public WindowManager.LayoutParams getAttrs(); 220 221 /** 222 * Get the layer at which this window's surface will be Z-ordered. 223 */ getSurfaceLayer()224 public int getSurfaceLayer(); 225 226 /** 227 * Return the token for the application (actually activity) that owns 228 * this window. May return null for system windows. 229 * 230 * @return An IApplicationToken identifying the owning activity. 231 */ getAppToken()232 public IApplicationToken getAppToken(); 233 234 /** 235 * Return true if, at any point, the application token associated with 236 * this window has actually displayed any windows. This is most useful 237 * with the "starting up" window to determine if any windows were 238 * displayed when it is closed. 239 * 240 * @return Returns true if one or more windows have been displayed, 241 * else false. 242 */ hasAppShownWindows()243 public boolean hasAppShownWindows(); 244 245 /** 246 * Is this window visible? It is not visible if there is no 247 * surface, or we are in the process of running an exit animation 248 * that will remove the surface. 249 */ isVisibleLw()250 boolean isVisibleLw(); 251 252 /** 253 * Like {@link #isVisibleLw}, but also counts a window that is currently 254 * "hidden" behind the keyguard as visible. This allows us to apply 255 * things like window flags that impact the keyguard. 256 */ isVisibleOrBehindKeyguardLw()257 boolean isVisibleOrBehindKeyguardLw(); 258 259 /** 260 * Is this window currently visible to the user on-screen? It is 261 * displayed either if it is visible or it is currently running an 262 * animation before no longer being visible. Must be called with the 263 * window manager lock held. 264 */ isDisplayedLw()265 boolean isDisplayedLw(); 266 267 /** 268 * Returns true if this window has been shown on screen at some time in 269 * the past. Must be called with the window manager lock held. 270 * 271 * @return boolean 272 */ hasDrawnLw()273 public boolean hasDrawnLw(); 274 275 /** 276 * Can be called by the policy to force a window to be hidden, 277 * regardless of whether the client or window manager would like 278 * it shown. Must be called with the window manager lock held. 279 * Returns true if {@link #showLw} was last called for the window. 280 */ hideLw(boolean doAnimation)281 public boolean hideLw(boolean doAnimation); 282 283 /** 284 * Can be called to undo the effect of {@link #hideLw}, allowing a 285 * window to be shown as long as the window manager and client would 286 * also like it to be shown. Must be called with the window manager 287 * lock held. 288 * Returns true if {@link #hideLw} was last called for the window. 289 */ showLw(boolean doAnimation)290 public boolean showLw(boolean doAnimation); 291 } 292 293 /** 294 * Bit mask that is set for all enter transition. 295 */ 296 public final int TRANSIT_ENTER_MASK = 0x1000; 297 298 /** 299 * Bit mask that is set for all exit transitions. 300 */ 301 public final int TRANSIT_EXIT_MASK = 0x2000; 302 303 /** Not set up for a transition. */ 304 public final int TRANSIT_UNSET = -1; 305 /** No animation for transition. */ 306 public final int TRANSIT_NONE = 0; 307 /** Window has been added to the screen. */ 308 public final int TRANSIT_ENTER = 1 | TRANSIT_ENTER_MASK; 309 /** Window has been removed from the screen. */ 310 public final int TRANSIT_EXIT = 2 | TRANSIT_EXIT_MASK; 311 /** Window has been made visible. */ 312 public final int TRANSIT_SHOW = 3 | TRANSIT_ENTER_MASK; 313 /** Window has been made invisible. */ 314 public final int TRANSIT_HIDE = 4 | TRANSIT_EXIT_MASK; 315 /** The "application starting" preview window is no longer needed, and will 316 * animate away to show the real window. */ 317 public final int TRANSIT_PREVIEW_DONE = 5; 318 /** A window in a new activity is being opened on top of an existing one 319 * in the same task. */ 320 public final int TRANSIT_ACTIVITY_OPEN = 6 | TRANSIT_ENTER_MASK; 321 /** The window in the top-most activity is being closed to reveal the 322 * previous activity in the same task. */ 323 public final int TRANSIT_ACTIVITY_CLOSE = 7 | TRANSIT_EXIT_MASK; 324 /** A window in a new task is being opened on top of an existing one 325 * in another activity's task. */ 326 public final int TRANSIT_TASK_OPEN = 8 | TRANSIT_ENTER_MASK; 327 /** A window in the top-most activity is being closed to reveal the 328 * previous activity in a different task. */ 329 public final int TRANSIT_TASK_CLOSE = 9 | TRANSIT_EXIT_MASK; 330 /** A window in an existing task is being displayed on top of an existing one 331 * in another activity's task. */ 332 public final int TRANSIT_TASK_TO_FRONT = 10 | TRANSIT_ENTER_MASK; 333 /** A window in an existing task is being put below all other tasks. */ 334 public final int TRANSIT_TASK_TO_BACK = 11 | TRANSIT_EXIT_MASK; 335 /** A window in a new activity that doesn't have a wallpaper is being 336 * opened on top of one that does, effectively closing the wallpaper. */ 337 public final int TRANSIT_WALLPAPER_CLOSE = 12 | TRANSIT_EXIT_MASK; 338 /** A window in a new activity that does have a wallpaper is being 339 * opened on one that didn't, effectively opening the wallpaper. */ 340 public final int TRANSIT_WALLPAPER_OPEN = 13 | TRANSIT_ENTER_MASK; 341 /** A window in a new activity is being opened on top of an existing one, 342 * and both are on top of the wallpaper. */ 343 public final int TRANSIT_WALLPAPER_INTRA_OPEN = 14 | TRANSIT_ENTER_MASK; 344 /** The window in the top-most activity is being closed to reveal the 345 * previous activity, and both are on top of he wallpaper. */ 346 public final int TRANSIT_WALLPAPER_INTRA_CLOSE = 15 | TRANSIT_EXIT_MASK; 347 348 // NOTE: screen off reasons are in order of significance, with more 349 // important ones lower than less important ones. 350 351 /** Screen turned off because of a device admin */ 352 public final int OFF_BECAUSE_OF_ADMIN = 1; 353 /** Screen turned off because of power button */ 354 public final int OFF_BECAUSE_OF_USER = 2; 355 /** Screen turned off because of timeout */ 356 public final int OFF_BECAUSE_OF_TIMEOUT = 3; 357 /** Screen turned off because of proximity sensor */ 358 public final int OFF_BECAUSE_OF_PROX_SENSOR = 4; 359 360 /** 361 * Magic constant to {@link IWindowManager#setRotation} to not actually 362 * modify the rotation. 363 */ 364 public final int USE_LAST_ROTATION = -1000; 365 366 /** 367 * Perform initialization of the policy. 368 * 369 * @param context The system context we are running in. 370 * @param powerManager 371 */ init(Context context, IWindowManager windowManager, LocalPowerManager powerManager)372 public void init(Context context, IWindowManager windowManager, 373 LocalPowerManager powerManager); 374 375 /** 376 * Check permissions when adding a window. 377 * 378 * @param attrs The window's LayoutParams. 379 * 380 * @return {@link WindowManagerImpl#ADD_OKAY} if the add can proceed; 381 * else an error code, usually 382 * {@link WindowManagerImpl#ADD_PERMISSION_DENIED}, to abort the add. 383 */ checkAddPermission(WindowManager.LayoutParams attrs)384 public int checkAddPermission(WindowManager.LayoutParams attrs); 385 386 /** 387 * Sanitize the layout parameters coming from a client. Allows the policy 388 * to do things like ensure that windows of a specific type can't take 389 * input focus. 390 * 391 * @param attrs The window layout parameters to be modified. These values 392 * are modified in-place. 393 */ adjustWindowParamsLw(WindowManager.LayoutParams attrs)394 public void adjustWindowParamsLw(WindowManager.LayoutParams attrs); 395 396 /** 397 * After the window manager has computed the current configuration based 398 * on its knowledge of the display and input devices, it gives the policy 399 * a chance to adjust the information contained in it. If you want to 400 * leave it as-is, simply do nothing. 401 * 402 * <p>This method may be called by any thread in the window manager, but 403 * no internal locks in the window manager will be held. 404 * 405 * @param config The Configuration being computed, for you to change as 406 * desired. 407 */ adjustConfigurationLw(Configuration config)408 public void adjustConfigurationLw(Configuration config); 409 410 /** 411 * Assign a window type to a layer. Allows you to control how different 412 * kinds of windows are ordered on-screen. 413 * 414 * @param type The type of window being assigned. 415 * 416 * @return int An arbitrary integer used to order windows, with lower 417 * numbers below higher ones. 418 */ windowTypeToLayerLw(int type)419 public int windowTypeToLayerLw(int type); 420 421 /** 422 * Return how to Z-order sub-windows in relation to the window they are 423 * attached to. Return positive to have them ordered in front, negative for 424 * behind. 425 * 426 * @param type The sub-window type code. 427 * 428 * @return int Layer in relation to the attached window, where positive is 429 * above and negative is below. 430 */ subWindowTypeToLayerLw(int type)431 public int subWindowTypeToLayerLw(int type); 432 433 /** 434 * Get the highest layer (actually one more than) that the wallpaper is 435 * allowed to be in. 436 */ getMaxWallpaperLayer()437 public int getMaxWallpaperLayer(); 438 439 /** 440 * Return whether the given window should forcibly hide everything 441 * behind it. Typically returns true for the keyguard. 442 */ doesForceHide(WindowState win, WindowManager.LayoutParams attrs)443 public boolean doesForceHide(WindowState win, WindowManager.LayoutParams attrs); 444 445 /** 446 * Determine if a window that is behind one that is force hiding 447 * (as determined by {@link #doesForceHide}) should actually be hidden. 448 * For example, typically returns false for the status bar. Be careful 449 * to return false for any window that you may hide yourself, since this 450 * will conflict with what you set. 451 */ canBeForceHidden(WindowState win, WindowManager.LayoutParams attrs)452 public boolean canBeForceHidden(WindowState win, WindowManager.LayoutParams attrs); 453 454 /** 455 * Called when the system would like to show a UI to indicate that an 456 * application is starting. You can use this to add a 457 * APPLICATION_STARTING_TYPE window with the given appToken to the window 458 * manager (using the normal window manager APIs) that will be shown until 459 * the application displays its own window. This is called without the 460 * window manager locked so that you can call back into it. 461 * 462 * @param appToken Token of the application being started. 463 * @param packageName The name of the application package being started. 464 * @param theme Resource defining the application's overall visual theme. 465 * @param nonLocalizedLabel The default title label of the application if 466 * no data is found in the resource. 467 * @param labelRes The resource ID the application would like to use as its name. 468 * @param icon The resource ID the application would like to use as its icon. 469 * 470 * @return Optionally you can return the View that was used to create the 471 * window, for easy removal in removeStartingWindow. 472 * 473 * @see #removeStartingWindow 474 */ addStartingWindow(IBinder appToken, String packageName, int theme, CharSequence nonLocalizedLabel, int labelRes, int icon)475 public View addStartingWindow(IBinder appToken, String packageName, 476 int theme, CharSequence nonLocalizedLabel, 477 int labelRes, int icon); 478 479 /** 480 * Called when the first window of an application has been displayed, while 481 * {@link #addStartingWindow} has created a temporary initial window for 482 * that application. You should at this point remove the window from the 483 * window manager. This is called without the window manager locked so 484 * that you can call back into it. 485 * 486 * <p>Note: due to the nature of these functions not being called with the 487 * window manager locked, you must be prepared for this function to be 488 * called multiple times and/or an initial time with a null View window 489 * even if you previously returned one. 490 * 491 * @param appToken Token of the application that has started. 492 * @param window Window View that was returned by createStartingWindow. 493 * 494 * @see #addStartingWindow 495 */ removeStartingWindow(IBinder appToken, View window)496 public void removeStartingWindow(IBinder appToken, View window); 497 498 /** 499 * Prepare for a window being added to the window manager. You can throw an 500 * exception here to prevent the window being added, or do whatever setup 501 * you need to keep track of the window. 502 * 503 * @param win The window being added. 504 * @param attrs The window's LayoutParams. 505 * 506 * @return {@link WindowManagerImpl#ADD_OKAY} if the add can proceed, else an 507 * error code to abort the add. 508 */ prepareAddWindowLw(WindowState win, WindowManager.LayoutParams attrs)509 public int prepareAddWindowLw(WindowState win, 510 WindowManager.LayoutParams attrs); 511 512 /** 513 * Called when a window is being removed from a window manager. Must not 514 * throw an exception -- clean up as much as possible. 515 * 516 * @param win The window being removed. 517 */ removeWindowLw(WindowState win)518 public void removeWindowLw(WindowState win); 519 520 /** 521 * Control the animation to run when a window's state changes. Return a 522 * non-0 number to force the animation to a specific resource ID, or 0 523 * to use the default animation. 524 * 525 * @param win The window that is changing. 526 * @param transit What is happening to the window: {@link #TRANSIT_ENTER}, 527 * {@link #TRANSIT_EXIT}, {@link #TRANSIT_SHOW}, or 528 * {@link #TRANSIT_HIDE}. 529 * 530 * @return Resource ID of the actual animation to use, or 0 for none. 531 */ selectAnimationLw(WindowState win, int transit)532 public int selectAnimationLw(WindowState win, int transit); 533 534 /** 535 * Create and return an animation to re-display a force hidden window. 536 */ createForceHideEnterAnimation()537 public Animation createForceHideEnterAnimation(); 538 539 /** 540 * Called from the input reader thread before a key is enqueued. 541 * 542 * <p>There are some actions that need to be handled here because they 543 * affect the power state of the device, for example, the power keys. 544 * Generally, it's best to keep as little as possible in the queue thread 545 * because it's the most fragile. 546 * @param whenNanos The event time in uptime nanoseconds. 547 * @param action The key event action. 548 * @param flags The key event flags. 549 * @param keyCode The key code. 550 * @param scanCode The key's scan code. 551 * @param policyFlags The policy flags associated with the key. 552 * @param isScreenOn True if the screen is already on 553 * 554 * @return The bitwise or of the {@link #ACTION_PASS_TO_USER}, 555 * {@link #ACTION_POKE_USER_ACTIVITY} and {@link #ACTION_GO_TO_SLEEP} flags. 556 */ interceptKeyBeforeQueueing(long whenNanos, int action, int flags, int keyCode, int scanCode, int policyFlags, boolean isScreenOn)557 public int interceptKeyBeforeQueueing(long whenNanos, int action, int flags, 558 int keyCode, int scanCode, int policyFlags, boolean isScreenOn); 559 560 /** 561 * Called from the input dispatcher thread before a key is dispatched to a window. 562 * 563 * <p>Allows you to define 564 * behavior for keys that can not be overridden by applications or redirect 565 * key events to a different window. This method is called from the 566 * input thread, with no locks held. 567 * 568 * <p>Note that if you change the window a key is dispatched to, the new 569 * target window will receive the key event without having input focus. 570 * 571 * @param win The window that currently has focus. This is where the key 572 * event will normally go. 573 * @param action The key event action. 574 * @param flags The key event flags. 575 * @param keyCode The key code. 576 * @param scanCode The key's scan code. 577 * @param metaState bit mask of meta keys that are held. 578 * @param repeatCount Number of times a key down has repeated. 579 * @param policyFlags The policy flags associated with the key. 580 * @return Returns true if the policy consumed the event and it should 581 * not be further dispatched. 582 */ interceptKeyBeforeDispatching(WindowState win, int action, int flags, int keyCode, int scanCode, int metaState, int repeatCount, int policyFlags)583 public boolean interceptKeyBeforeDispatching(WindowState win, int action, int flags, 584 int keyCode, int scanCode, int metaState, int repeatCount, int policyFlags); 585 586 /** 587 * Called when layout of the windows is about to start. 588 * 589 * @param displayWidth The current full width of the screen. 590 * @param displayHeight The current full height of the screen. 591 */ beginLayoutLw(int displayWidth, int displayHeight)592 public void beginLayoutLw(int displayWidth, int displayHeight); 593 594 /** 595 * Called for each window attached to the window manager as layout is 596 * proceeding. The implementation of this function must take care of 597 * setting the window's frame, either here or in finishLayout(). 598 * 599 * @param win The window being positioned. 600 * @param attrs The LayoutParams of the window. 601 * @param attached For sub-windows, the window it is attached to; this 602 * window will already have had layoutWindow() called on it 603 * so you can use its Rect. Otherwise null. 604 */ layoutWindowLw(WindowState win, WindowManager.LayoutParams attrs, WindowState attached)605 public void layoutWindowLw(WindowState win, 606 WindowManager.LayoutParams attrs, WindowState attached); 607 608 609 /** 610 * Return the insets for the areas covered by system windows. These values 611 * are computed on the most recent layout, so they are not guaranteed to 612 * be correct. 613 * 614 * @param attrs The LayoutParams of the window. 615 * @param contentInset The areas covered by system windows, expressed as positive insets 616 * 617 */ getContentInsetHintLw(WindowManager.LayoutParams attrs, Rect contentInset)618 public void getContentInsetHintLw(WindowManager.LayoutParams attrs, Rect contentInset); 619 620 /** 621 * Called when layout of the windows is finished. After this function has 622 * returned, all windows given to layoutWindow() <em>must</em> have had a 623 * frame assigned. 624 * 625 * @return Return any bit set of {@link #FINISH_LAYOUT_REDO_LAYOUT}, 626 * {@link #FINISH_LAYOUT_REDO_CONFIG}, {@link #FINISH_LAYOUT_REDO_WALLPAPER}, 627 * or {@link #FINISH_LAYOUT_REDO_ANIM}. 628 */ finishLayoutLw()629 public int finishLayoutLw(); 630 631 /** Layout state may have changed (so another layout will be performed) */ 632 static final int FINISH_LAYOUT_REDO_LAYOUT = 0x0001; 633 /** Configuration state may have changed */ 634 static final int FINISH_LAYOUT_REDO_CONFIG = 0x0002; 635 /** Wallpaper may need to move */ 636 static final int FINISH_LAYOUT_REDO_WALLPAPER = 0x0004; 637 /** Need to recompute animations */ 638 static final int FINISH_LAYOUT_REDO_ANIM = 0x0008; 639 640 /** 641 * Called when animation of the windows is about to start. 642 * 643 * @param displayWidth The current full width of the screen. 644 * @param displayHeight The current full height of the screen. 645 */ beginAnimationLw(int displayWidth, int displayHeight)646 public void beginAnimationLw(int displayWidth, int displayHeight); 647 648 /** 649 * Called each time a window is animating. 650 * 651 * @param win The window being positioned. 652 * @param attrs The LayoutParams of the window. 653 */ animatingWindowLw(WindowState win, WindowManager.LayoutParams attrs)654 public void animatingWindowLw(WindowState win, 655 WindowManager.LayoutParams attrs); 656 657 /** 658 * Called when animation of the windows is finished. If in this function you do 659 * something that may have modified the animation state of another window, 660 * be sure to return true in order to perform another animation frame. 661 * 662 * @return Return any bit set of {@link #FINISH_LAYOUT_REDO_LAYOUT}, 663 * {@link #FINISH_LAYOUT_REDO_CONFIG}, {@link #FINISH_LAYOUT_REDO_WALLPAPER}, 664 * or {@link #FINISH_LAYOUT_REDO_ANIM}. 665 */ finishAnimationLw()666 public int finishAnimationLw(); 667 668 /** 669 * Return true if it is okay to perform animations for an app transition 670 * that is about to occur. You may return false for this if, for example, 671 * the lock screen is currently displayed so the switch should happen 672 * immediately. 673 */ allowAppAnimationsLw()674 public boolean allowAppAnimationsLw(); 675 676 /** 677 * Called after the screen turns off. 678 * 679 * @param why {@link #OFF_BECAUSE_OF_USER} or 680 * {@link #OFF_BECAUSE_OF_TIMEOUT}. 681 */ screenTurnedOff(int why)682 public void screenTurnedOff(int why); 683 684 /** 685 * Called after the screen turns on. 686 */ screenTurnedOn()687 public void screenTurnedOn(); 688 689 /** 690 * Return whether the screen is currently on. 691 */ isScreenOn()692 public boolean isScreenOn(); 693 694 /** 695 * Tell the policy that the lid switch has changed state. 696 * @param whenNanos The time when the change occurred in uptime nanoseconds. 697 * @param lidOpen True if the lid is now open. 698 */ notifyLidSwitchChanged(long whenNanos, boolean lidOpen)699 public void notifyLidSwitchChanged(long whenNanos, boolean lidOpen); 700 701 /** 702 * Tell the policy if anyone is requesting that keyguard not come on. 703 * 704 * @param enabled Whether keyguard can be on or not. does not actually 705 * turn it on, unless it was previously disabled with this function. 706 * 707 * @see android.app.KeyguardManager.KeyguardLock#disableKeyguard() 708 * @see android.app.KeyguardManager.KeyguardLock#reenableKeyguard() 709 */ enableKeyguard(boolean enabled)710 public void enableKeyguard(boolean enabled); 711 712 /** 713 * Callback used by {@link WindowManagerPolicy#exitKeyguardSecurely} 714 */ 715 interface OnKeyguardExitResult { onKeyguardExitResult(boolean success)716 void onKeyguardExitResult(boolean success); 717 } 718 719 /** 720 * Tell the policy if anyone is requesting the keyguard to exit securely 721 * (this would be called after the keyguard was disabled) 722 * @param callback Callback to send the result back. 723 * @see android.app.KeyguardManager#exitKeyguardSecurely(android.app.KeyguardManager.OnKeyguardExitResult) 724 */ exitKeyguardSecurely(OnKeyguardExitResult callback)725 void exitKeyguardSecurely(OnKeyguardExitResult callback); 726 727 /** 728 * inKeyguardRestrictedKeyInputMode 729 * 730 * if keyguard screen is showing or in restricted key input mode (i.e. in 731 * keyguard password emergency screen). When in such mode, certain keys, 732 * such as the Home key and the right soft keys, don't work. 733 * 734 * @return true if in keyguard restricted input mode. 735 */ inKeyguardRestrictedKeyInputMode()736 public boolean inKeyguardRestrictedKeyInputMode(); 737 738 /** 739 * Given an orientation constant 740 * ({@link android.content.pm.ActivityInfo#SCREEN_ORIENTATION_LANDSCAPE 741 * ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE} or 742 * {@link android.content.pm.ActivityInfo#SCREEN_ORIENTATION_PORTRAIT 743 * ActivityInfo.SCREEN_ORIENTATION_PORTRAIT}), return a surface 744 * rotation. 745 */ rotationForOrientationLw(int orientation, int lastRotation, boolean displayEnabled)746 public int rotationForOrientationLw(int orientation, int lastRotation, 747 boolean displayEnabled); 748 749 /** 750 * Called when the system is mostly done booting to determine whether 751 * the system should go into safe mode. 752 */ detectSafeMode()753 public boolean detectSafeMode(); 754 755 /** 756 * Called when the system is mostly done booting. 757 */ systemReady()758 public void systemReady(); 759 760 /** 761 * Called when userActivity is signalled in the power manager. 762 * This is safe to call from any thread, with any window manager locks held or not. 763 */ userActivity()764 public void userActivity(); 765 766 /** 767 * Called when we have finished booting and can now display the home 768 * screen to the user. This wilWl happen after systemReady(), and at 769 * this point the display is active. 770 */ enableScreenAfterBoot()771 public void enableScreenAfterBoot(); 772 setCurrentOrientationLw(int newOrientation)773 public void setCurrentOrientationLw(int newOrientation); 774 775 /** 776 * Call from application to perform haptic feedback on its window. 777 */ performHapticFeedbackLw(WindowState win, int effectId, boolean always)778 public boolean performHapticFeedbackLw(WindowState win, int effectId, boolean always); 779 780 /** 781 * Called when we have stopped keeping the screen on because a window 782 * requesting this is no longer visible. 783 */ screenOnStoppedLw()784 public void screenOnStoppedLw(); 785 786 /** 787 * Return false to disable key repeat events from being generated. 788 */ allowKeyRepeat()789 public boolean allowKeyRepeat(); 790 } 791