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