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.pm.ActivityInfo; 20 import android.graphics.PixelFormat; 21 import android.os.IBinder; 22 import android.os.Parcel; 23 import android.os.Parcelable; 24 import android.text.TextUtils; 25 import android.util.Log; 26 27 28 /** 29 * The interface that apps use to talk to the window manager. 30 * <p> 31 * Use <code>Context.getSystemService(Context.WINDOW_SERVICE)</code> to get one of these. 32 * 33 * @see android.content.Context#getSystemService 34 * @see android.content.Context#WINDOW_SERVICE 35 */ 36 public interface WindowManager extends ViewManager { 37 /** 38 * Exception that is thrown when trying to add view whose 39 * {@link WindowManager.LayoutParams} {@link WindowManager.LayoutParams#token} 40 * is invalid. 41 */ 42 public static class BadTokenException extends RuntimeException { BadTokenException()43 public BadTokenException() { 44 } 45 BadTokenException(String name)46 public BadTokenException(String name) { 47 super(name); 48 } 49 } 50 51 /** 52 * Use this method to get the default Display object. 53 * 54 * @return default Display object 55 */ getDefaultDisplay()56 public Display getDefaultDisplay(); 57 58 /** 59 * Special variation of {@link #removeView} that immediately invokes 60 * the given view hierarchy's {@link View#onDetachedFromWindow() 61 * View.onDetachedFromWindow()} methods before returning. This is not 62 * for normal applications; using it correctly requires great care. 63 * 64 * @param view The view to be removed. 65 */ removeViewImmediate(View view)66 public void removeViewImmediate(View view); 67 68 public static class LayoutParams extends ViewGroup.LayoutParams 69 implements Parcelable { 70 /** 71 * X position for this window. With the default gravity it is ignored. 72 * When using {@link Gravity#LEFT} or {@link Gravity#RIGHT} it provides 73 * an offset from the given edge. 74 */ 75 public int x; 76 77 /** 78 * Y position for this window. With the default gravity it is ignored. 79 * When using {@link Gravity#TOP} or {@link Gravity#BOTTOM} it provides 80 * an offset from the given edge. 81 */ 82 public int y; 83 84 /** 85 * Indicates how much of the extra space will be allocated horizontally 86 * to the view associated with these LayoutParams. Specify 0 if the view 87 * should not be stretched. Otherwise the extra pixels will be pro-rated 88 * among all views whose weight is greater than 0. 89 */ 90 public float horizontalWeight; 91 92 /** 93 * Indicates how much of the extra space will be allocated vertically 94 * to the view associated with these LayoutParams. Specify 0 if the view 95 * should not be stretched. Otherwise the extra pixels will be pro-rated 96 * among all views whose weight is greater than 0. 97 */ 98 public float verticalWeight; 99 100 /** 101 * The general type of window. There are three main classes of 102 * window types: 103 * <ul> 104 * <li> <strong>Application windows</strong> (ranging from 105 * {@link #FIRST_APPLICATION_WINDOW} to 106 * {@link #LAST_APPLICATION_WINDOW}) are normal top-level application 107 * windows. For these types of windows, the {@link #token} must be 108 * set to the token of the activity they are a part of (this will 109 * normally be done for you if {@link #token} is null). 110 * <li> <strong>Sub-windows</strong> (ranging from 111 * {@link #FIRST_SUB_WINDOW} to 112 * {@link #LAST_SUB_WINDOW}) are associated with another top-level 113 * window. For these types of windows, the {@link #token} must be 114 * the token of the window it is attached to. 115 * <li> <strong>System windows</strong> (ranging from 116 * {@link #FIRST_SYSTEM_WINDOW} to 117 * {@link #LAST_SYSTEM_WINDOW}) are special types of windows for 118 * use by the system for specific purposes. They should not normally 119 * be used by applications, and a special permission is required 120 * to use them. 121 * </ul> 122 * 123 * @see #TYPE_BASE_APPLICATION 124 * @see #TYPE_APPLICATION 125 * @see #TYPE_APPLICATION_STARTING 126 * @see #TYPE_APPLICATION_PANEL 127 * @see #TYPE_APPLICATION_MEDIA 128 * @see #TYPE_APPLICATION_SUB_PANEL 129 * @see #TYPE_APPLICATION_ATTACHED_DIALOG 130 * @see #TYPE_STATUS_BAR 131 * @see #TYPE_SEARCH_BAR 132 * @see #TYPE_PHONE 133 * @see #TYPE_SYSTEM_ALERT 134 * @see #TYPE_KEYGUARD 135 * @see #TYPE_TOAST 136 * @see #TYPE_SYSTEM_OVERLAY 137 * @see #TYPE_PRIORITY_PHONE 138 * @see #TYPE_STATUS_BAR_PANEL 139 * @see #TYPE_SYSTEM_DIALOG 140 * @see #TYPE_KEYGUARD_DIALOG 141 * @see #TYPE_SYSTEM_ERROR 142 * @see #TYPE_INPUT_METHOD 143 * @see #TYPE_INPUT_METHOD_DIALOG 144 */ 145 public int type; 146 147 /** 148 * Start of window types that represent normal application windows. 149 */ 150 public static final int FIRST_APPLICATION_WINDOW = 1; 151 152 /** 153 * Window type: an application window that serves as the "base" window 154 * of the overall application; all other application windows will 155 * appear on top of it. 156 */ 157 public static final int TYPE_BASE_APPLICATION = 1; 158 159 /** 160 * Window type: a normal application window. The {@link #token} must be 161 * an Activity token identifying who the window belongs to. 162 */ 163 public static final int TYPE_APPLICATION = 2; 164 165 /** 166 * Window type: special application window that is displayed while the 167 * application is starting. Not for use by applications themselves; 168 * this is used by the system to display something until the 169 * application can show its own windows. 170 */ 171 public static final int TYPE_APPLICATION_STARTING = 3; 172 173 /** 174 * End of types of application windows. 175 */ 176 public static final int LAST_APPLICATION_WINDOW = 99; 177 178 /** 179 * Start of types of sub-windows. The {@link #token} of these windows 180 * must be set to the window they are attached to. These types of 181 * windows are kept next to their attached window in Z-order, and their 182 * coordinate space is relative to their attached window. 183 */ 184 public static final int FIRST_SUB_WINDOW = 1000; 185 186 /** 187 * Window type: a panel on top of an application window. These windows 188 * appear on top of their attached window. 189 */ 190 public static final int TYPE_APPLICATION_PANEL = FIRST_SUB_WINDOW; 191 192 /** 193 * Window type: window for showing media (e.g. video). These windows 194 * are displayed behind their attached window. 195 */ 196 public static final int TYPE_APPLICATION_MEDIA = FIRST_SUB_WINDOW+1; 197 198 /** 199 * Window type: a sub-panel on top of an application window. These 200 * windows are displayed on top their attached window and any 201 * {@link #TYPE_APPLICATION_PANEL} panels. 202 */ 203 public static final int TYPE_APPLICATION_SUB_PANEL = FIRST_SUB_WINDOW+2; 204 205 /** Window type: like {@link #TYPE_APPLICATION_PANEL}, but layout 206 * of the window happens as that of a top-level window, <em>not</em> 207 * as a child of its container. 208 */ 209 public static final int TYPE_APPLICATION_ATTACHED_DIALOG = FIRST_SUB_WINDOW+3; 210 211 /** 212 * Window type: window for showing overlays on top of media windows. 213 * These windows are displayed between TYPE_APPLICATION_MEDIA and the 214 * application window. They should be translucent to be useful. This 215 * is a big ugly hack so: 216 * @hide 217 */ 218 public static final int TYPE_APPLICATION_MEDIA_OVERLAY = FIRST_SUB_WINDOW+4; 219 220 /** 221 * End of types of sub-windows. 222 */ 223 public static final int LAST_SUB_WINDOW = 1999; 224 225 /** 226 * Start of system-specific window types. These are not normally 227 * created by applications. 228 */ 229 public static final int FIRST_SYSTEM_WINDOW = 2000; 230 231 /** 232 * Window type: the status bar. There can be only one status bar 233 * window; it is placed at the top of the screen, and all other 234 * windows are shifted down so they are below it. 235 */ 236 public static final int TYPE_STATUS_BAR = FIRST_SYSTEM_WINDOW; 237 238 /** 239 * Window type: the search bar. There can be only one search bar 240 * window; it is placed at the top of the screen. 241 */ 242 public static final int TYPE_SEARCH_BAR = FIRST_SYSTEM_WINDOW+1; 243 244 /** 245 * Window type: phone. These are non-application windows providing 246 * user interaction with the phone (in particular incoming calls). 247 * These windows are normally placed above all applications, but behind 248 * the status bar. 249 */ 250 public static final int TYPE_PHONE = FIRST_SYSTEM_WINDOW+2; 251 252 /** 253 * Window type: system window, such as low power alert. These windows 254 * are always on top of application windows. 255 */ 256 public static final int TYPE_SYSTEM_ALERT = FIRST_SYSTEM_WINDOW+3; 257 258 /** 259 * Window type: keyguard window. 260 */ 261 public static final int TYPE_KEYGUARD = FIRST_SYSTEM_WINDOW+4; 262 263 /** 264 * Window type: transient notifications. 265 */ 266 public static final int TYPE_TOAST = FIRST_SYSTEM_WINDOW+5; 267 268 /** 269 * Window type: system overlay windows, which need to be displayed 270 * on top of everything else. These windows must not take input 271 * focus, or they will interfere with the keyguard. 272 */ 273 public static final int TYPE_SYSTEM_OVERLAY = FIRST_SYSTEM_WINDOW+6; 274 275 /** 276 * Window type: priority phone UI, which needs to be displayed even if 277 * the keyguard is active. These windows must not take input 278 * focus, or they will interfere with the keyguard. 279 */ 280 public static final int TYPE_PRIORITY_PHONE = FIRST_SYSTEM_WINDOW+7; 281 282 /** 283 * Window type: panel that slides out from the status bar 284 */ 285 public static final int TYPE_SYSTEM_DIALOG = FIRST_SYSTEM_WINDOW+8; 286 287 /** 288 * Window type: dialogs that the keyguard shows 289 */ 290 public static final int TYPE_KEYGUARD_DIALOG = FIRST_SYSTEM_WINDOW+9; 291 292 /** 293 * Window type: internal system error windows, appear on top of 294 * everything they can. 295 */ 296 public static final int TYPE_SYSTEM_ERROR = FIRST_SYSTEM_WINDOW+10; 297 298 /** 299 * Window type: internal input methods windows, which appear above 300 * the normal UI. Application windows may be resized or panned to keep 301 * the input focus visible while this window is displayed. 302 */ 303 public static final int TYPE_INPUT_METHOD = FIRST_SYSTEM_WINDOW+11; 304 305 /** 306 * Window type: internal input methods dialog windows, which appear above 307 * the current input method window. 308 */ 309 public static final int TYPE_INPUT_METHOD_DIALOG= FIRST_SYSTEM_WINDOW+12; 310 311 /** 312 * Window type: wallpaper window, placed behind any window that wants 313 * to sit on top of the wallpaper. 314 */ 315 public static final int TYPE_WALLPAPER = FIRST_SYSTEM_WINDOW+13; 316 317 /** 318 * Window type: panel that slides out from the status bar 319 */ 320 public static final int TYPE_STATUS_BAR_PANEL = FIRST_SYSTEM_WINDOW+14; 321 322 /** 323 * End of types of system windows. 324 */ 325 public static final int LAST_SYSTEM_WINDOW = 2999; 326 327 /** 328 * Specifies what type of memory buffers should be used by this window. 329 * Default is normal. 330 * 331 * @see #MEMORY_TYPE_NORMAL 332 * @see #MEMORY_TYPE_PUSH_BUFFERS 333 */ 334 public int memoryType; 335 336 /** Memory type: The window's surface is allocated in main memory. */ 337 public static final int MEMORY_TYPE_NORMAL = 0; 338 /** Memory type: The window's surface is configured to be accessible 339 * by DMA engines and hardware accelerators. 340 * @deprecated this is ignored, this value is set automatically when needed. 341 */ 342 @Deprecated 343 public static final int MEMORY_TYPE_HARDWARE = 1; 344 /** Memory type: The window's surface is configured to be accessible 345 * by graphics accelerators. 346 * @deprecated this is ignored, this value is set automatically when needed. 347 */ 348 @Deprecated 349 public static final int MEMORY_TYPE_GPU = 2; 350 /** Memory type: The window's surface doesn't own its buffers and 351 * therefore cannot be locked. Instead the buffers are pushed to 352 * it through native binder calls. */ 353 public static final int MEMORY_TYPE_PUSH_BUFFERS = 3; 354 355 /** 356 * Various behavioral options/flags. Default is none. 357 * 358 * @see #FLAG_BLUR_BEHIND 359 * @see #FLAG_DIM_BEHIND 360 * @see #FLAG_NOT_FOCUSABLE 361 * @see #FLAG_NOT_TOUCHABLE 362 * @see #FLAG_NOT_TOUCH_MODAL 363 * @see #FLAG_LAYOUT_IN_SCREEN 364 * @see #FLAG_DITHER 365 * @see #FLAG_KEEP_SCREEN_ON 366 * @see #FLAG_FULLSCREEN 367 * @see #FLAG_FORCE_NOT_FULLSCREEN 368 * @see #FLAG_IGNORE_CHEEK_PRESSES 369 */ 370 public int flags; 371 372 /** Window flag: everything behind this window will be dimmed. 373 * Use {@link #dimAmount} to control the amount of dim. */ 374 public static final int FLAG_DIM_BEHIND = 0x00000002; 375 376 /** Window flag: blur everything behind this window. */ 377 public static final int FLAG_BLUR_BEHIND = 0x00000004; 378 379 /** Window flag: this window won't ever get key input focus, so the 380 * user can not send key or other button events to it. Those will 381 * instead go to whatever focusable window is behind it. This flag 382 * will also enable {@link #FLAG_NOT_TOUCH_MODAL} whether or not that 383 * is explicitly set. 384 * 385 * <p>Setting this flag also implies that the window will not need to 386 * interact with 387 * a soft input method, so it will be Z-ordered and positioned 388 * independently of any active input method (typically this means it 389 * gets Z-ordered on top of the input method, so it can use the full 390 * screen for its content and cover the input method if needed. You 391 * can use {@link #FLAG_ALT_FOCUSABLE_IM} to modify this behavior. */ 392 public static final int FLAG_NOT_FOCUSABLE = 0x00000008; 393 394 /** Window flag: this window can never receive touch events. */ 395 public static final int FLAG_NOT_TOUCHABLE = 0x00000010; 396 397 /** Window flag: Even when this window is focusable (its 398 * {@link #FLAG_NOT_FOCUSABLE is not set), allow any pointer events 399 * outside of the window to be sent to the windows behind it. Otherwise 400 * it will consume all pointer events itself, regardless of whether they 401 * are inside of the window. */ 402 public static final int FLAG_NOT_TOUCH_MODAL = 0x00000020; 403 404 /** Window flag: When set, if the device is asleep when the touch 405 * screen is pressed, you will receive this first touch event. Usually 406 * the first touch event is consumed by the system since the user can 407 * not see what they are pressing on. 408 */ 409 public static final int FLAG_TOUCHABLE_WHEN_WAKING = 0x00000040; 410 411 /** Window flag: as long as this window is visible to the user, keep 412 * the device's screen turned on and bright. */ 413 public static final int FLAG_KEEP_SCREEN_ON = 0x00000080; 414 415 /** Window flag: place the window within the entire screen, ignoring 416 * decorations around the border (a.k.a. the status bar). The 417 * window must correctly position its contents to take the screen 418 * decoration into account. This flag is normally set for you 419 * by Window as described in {@link Window#setFlags}. */ 420 public static final int FLAG_LAYOUT_IN_SCREEN = 0x00000100; 421 422 /** Window flag: allow window to extend outside of the screen. */ 423 public static final int FLAG_LAYOUT_NO_LIMITS = 0x00000200; 424 425 /** Window flag: Hide all screen decorations (e.g. status bar) while 426 * this window is displayed. This allows the window to use the entire 427 * display space for itself -- the status bar will be hidden when 428 * an app window with this flag set is on the top layer. */ 429 public static final int FLAG_FULLSCREEN = 0x00000400; 430 431 /** Window flag: Override {@link #FLAG_FULLSCREEN and force the 432 * screen decorations (such as status bar) to be shown. */ 433 public static final int FLAG_FORCE_NOT_FULLSCREEN = 0x00000800; 434 435 /** Window flag: turn on dithering when compositing this window to 436 * the screen. */ 437 public static final int FLAG_DITHER = 0x00001000; 438 439 /** Window flag: don't allow screen shots while this window is 440 * displayed. */ 441 public static final int FLAG_SECURE = 0x00002000; 442 443 /** Window flag: a special mode where the layout parameters are used 444 * to perform scaling of the surface when it is composited to the 445 * screen. */ 446 public static final int FLAG_SCALED = 0x00004000; 447 448 /** Window flag: intended for windows that will often be used when the user is 449 * holding the screen against their face, it will aggressively filter the event 450 * stream to prevent unintended presses in this situation that may not be 451 * desired for a particular window, when such an event stream is detected, the 452 * application will receive a CANCEL motion event to indicate this so applications 453 * can handle this accordingly by taking no action on the event 454 * until the finger is released. */ 455 public static final int FLAG_IGNORE_CHEEK_PRESSES = 0x00008000; 456 457 /** Window flag: a special option only for use in combination with 458 * {@link #FLAG_LAYOUT_IN_SCREEN}. When requesting layout in the 459 * screen your window may appear on top of or behind screen decorations 460 * such as the status bar. By also including this flag, the window 461 * manager will report the inset rectangle needed to ensure your 462 * content is not covered by screen decorations. This flag is normally 463 * set for you by Window as described in {@link Window#setFlags}.*/ 464 public static final int FLAG_LAYOUT_INSET_DECOR = 0x00010000; 465 466 /** Window flag: invert the state of {@link #FLAG_NOT_FOCUSABLE} with 467 * respect to how this window interacts with the current method. That 468 * is, if FLAG_NOT_FOCUSABLE is set and this flag is set, then the 469 * window will behave as if it needs to interact with the input method 470 * and thus be placed behind/away from it; if FLAG_NOT_FOCUSABLE is 471 * not set and this flag is set, then the window will behave as if it 472 * doesn't need to interact with the input method and can be placed 473 * to use more space and cover the input method. 474 */ 475 public static final int FLAG_ALT_FOCUSABLE_IM = 0x00020000; 476 477 /** Window flag: if you have set {@link #FLAG_NOT_TOUCH_MODAL}, you 478 * can set this flag to receive a single special MotionEvent with 479 * the action 480 * {@link MotionEvent#ACTION_OUTSIDE MotionEvent.ACTION_OUTSIDE} for 481 * touches that occur outside of your window. Note that you will not 482 * receive the full down/move/up gesture, only the location of the 483 * first down as an ACTION_OUTSIDE. 484 */ 485 public static final int FLAG_WATCH_OUTSIDE_TOUCH = 0x00040000; 486 487 /** Window flag: special flag to let windows be shown when the screen 488 * is locked. This will let application windows take precedence over 489 * key guard or any other lock screens. Can be used with 490 * {@link #FLAG_KEEP_SCREEN_ON} to turn screen on and display windows 491 * directly before showing the key guard window. Can be used with 492 * {@link #FLAG_DISMISS_KEYGUARD} to automatically fully dismisss 493 * non-secure keyguards. This flag only applies to the top-most 494 * full-screen window. 495 */ 496 public static final int FLAG_SHOW_WHEN_LOCKED = 0x00080000; 497 498 /** Window flag: ask that the system wallpaper be shown behind 499 * your window. The window surface must be translucent to be able 500 * to actually see the wallpaper behind it; this flag just ensures 501 * that the wallpaper surface will be there if this window actually 502 * has translucent regions. 503 */ 504 public static final int FLAG_SHOW_WALLPAPER = 0x00100000; 505 506 /** Window flag: when set as a window is being added or made 507 * visible, once the window has been shown then the system will 508 * poke the power manager's user activity (as if the user had woken 509 * up the device) to turn the screen on. */ 510 public static final int FLAG_TURN_SCREEN_ON = 0x00200000; 511 512 /** Window flag: when set the window will cause the keyguard to 513 * be dismissed, only if it is not a secure lock keyguard. Because such 514 * a keyguard is not needed for security, it will never re-appear if 515 * the user navigates to another window (in contrast to 516 * {@link #FLAG_SHOW_WHEN_LOCKED}, which will only temporarily 517 * hide both secure and non-secure keyguards but ensure they reappear 518 * when the user moves to another UI that doesn't hide them). 519 * If the keyguard is currently active and is secure (requires an 520 * unlock pattern) than the user will still need to confirm it before 521 * seeing this window, unless {@link #FLAG_SHOW_WHEN_LOCKED} has 522 * also been set. */ 523 public static final int FLAG_DISMISS_KEYGUARD = 0x00400000; 524 525 /** Window flag: *sigh* The lock screen wants to continue running its 526 * animation while it is fading. A kind-of hack to allow this. Maybe 527 * in the future we just make this the default behavior. 528 * 529 * {@hide} */ 530 public static final int FLAG_KEEP_SURFACE_WHILE_ANIMATING = 0x10000000; 531 532 /** Window flag: special flag to limit the size of the window to be 533 * original size ([320x480] x density). Used to create window for applications 534 * running under compatibility mode. 535 * 536 * {@hide} */ 537 public static final int FLAG_COMPATIBLE_WINDOW = 0x20000000; 538 539 /** Window flag: a special option intended for system dialogs. When 540 * this flag is set, the window will demand focus unconditionally when 541 * it is created. 542 * {@hide} */ 543 public static final int FLAG_SYSTEM_ERROR = 0x40000000; 544 545 /** 546 * Given a particular set of window manager flags, determine whether 547 * such a window may be a target for an input method when it has 548 * focus. In particular, this checks the 549 * {@link #FLAG_NOT_FOCUSABLE} and {@link #FLAG_ALT_FOCUSABLE_IM} 550 * flags and returns true if the combination of the two corresponds 551 * to a window that needs to be behind the input method so that the 552 * user can type into it. 553 * 554 * @param flags The current window manager flags. 555 * 556 * @return Returns true if such a window should be behind/interact 557 * with an input method, false if not. 558 */ mayUseInputMethod(int flags)559 public static boolean mayUseInputMethod(int flags) { 560 switch (flags&(FLAG_NOT_FOCUSABLE|FLAG_ALT_FOCUSABLE_IM)) { 561 case 0: 562 case FLAG_NOT_FOCUSABLE|FLAG_ALT_FOCUSABLE_IM: 563 return true; 564 } 565 return false; 566 } 567 568 /** 569 * Mask for {@link #softInputMode} of the bits that determine the 570 * desired visibility state of the soft input area for this window. 571 */ 572 public static final int SOFT_INPUT_MASK_STATE = 0x0f; 573 574 /** 575 * Visibility state for {@link #softInputMode}: no state has been specified. 576 */ 577 public static final int SOFT_INPUT_STATE_UNSPECIFIED = 0; 578 579 /** 580 * Visibility state for {@link #softInputMode}: please don't change the state of 581 * the soft input area. 582 */ 583 public static final int SOFT_INPUT_STATE_UNCHANGED = 1; 584 585 /** 586 * Visibility state for {@link #softInputMode}: please hide any soft input 587 * area when normally appropriate (when the user is navigating 588 * forward to your window). 589 */ 590 public static final int SOFT_INPUT_STATE_HIDDEN = 2; 591 592 /** 593 * Visibility state for {@link #softInputMode}: please always hide any 594 * soft input area when this window receives focus. 595 */ 596 public static final int SOFT_INPUT_STATE_ALWAYS_HIDDEN = 3; 597 598 /** 599 * Visibility state for {@link #softInputMode}: please show the soft 600 * input area when normally appropriate (when the user is navigating 601 * forward to your window). 602 */ 603 public static final int SOFT_INPUT_STATE_VISIBLE = 4; 604 605 /** 606 * Visibility state for {@link #softInputMode}: please always make the 607 * soft input area visible when this window receives input focus. 608 */ 609 public static final int SOFT_INPUT_STATE_ALWAYS_VISIBLE = 5; 610 611 /** 612 * Mask for {@link #softInputMode} of the bits that determine the 613 * way that the window should be adjusted to accommodate the soft 614 * input window. 615 */ 616 public static final int SOFT_INPUT_MASK_ADJUST = 0xf0; 617 618 /** Adjustment option for {@link #softInputMode}: nothing specified. 619 * The system will try to pick one or 620 * the other depending on the contents of the window. 621 */ 622 public static final int SOFT_INPUT_ADJUST_UNSPECIFIED = 0x00; 623 624 /** Adjustment option for {@link #softInputMode}: set to allow the 625 * window to be resized when an input 626 * method is shown, so that its contents are not covered by the input 627 * method. This can <em>not<em> be combined with 628 * {@link #SOFT_INPUT_ADJUST_PAN}; if 629 * neither of these are set, then the system will try to pick one or 630 * the other depending on the contents of the window. 631 */ 632 public static final int SOFT_INPUT_ADJUST_RESIZE = 0x10; 633 634 /** Adjustment option for {@link #softInputMode}: set to have a window 635 * pan when an input method is 636 * shown, so it doesn't need to deal with resizing but just panned 637 * by the framework to ensure the current input focus is visible. This 638 * can <em>not<em> be combined with {@link #SOFT_INPUT_ADJUST_RESIZE}; if 639 * neither of these are set, then the system will try to pick one or 640 * the other depending on the contents of the window. 641 */ 642 public static final int SOFT_INPUT_ADJUST_PAN = 0x20; 643 644 /** 645 * Bit for {@link #softInputMode}: set when the user has navigated 646 * forward to the window. This is normally set automatically for 647 * you by the system, though you may want to set it in certain cases 648 * when you are displaying a window yourself. This flag will always 649 * be cleared automatically after the window is displayed. 650 */ 651 public static final int SOFT_INPUT_IS_FORWARD_NAVIGATION = 0x100; 652 653 /** 654 * Desired operating mode for any soft input area. May any combination 655 * of: 656 * 657 * <ul> 658 * <li> One of the visibility states 659 * {@link #SOFT_INPUT_STATE_UNSPECIFIED}, {@link #SOFT_INPUT_STATE_UNCHANGED}, 660 * {@link #SOFT_INPUT_STATE_HIDDEN}, {@link #SOFT_INPUT_STATE_ALWAYS_VISIBLE}, or 661 * {@link #SOFT_INPUT_STATE_VISIBLE}. 662 * <li> One of the adjustment options 663 * {@link #SOFT_INPUT_ADJUST_UNSPECIFIED}, 664 * {@link #SOFT_INPUT_ADJUST_RESIZE}, or 665 * {@link #SOFT_INPUT_ADJUST_PAN}. 666 */ 667 public int softInputMode; 668 669 /** 670 * Placement of window within the screen as per {@link Gravity} 671 * 672 * @see Gravity 673 */ 674 public int gravity; 675 676 /** 677 * The horizontal margin, as a percentage of the container's width, 678 * between the container and the widget. 679 */ 680 public float horizontalMargin; 681 682 /** 683 * The vertical margin, as a percentage of the container's height, 684 * between the container and the widget. 685 */ 686 public float verticalMargin; 687 688 /** 689 * The desired bitmap format. May be one of the constants in 690 * {@link android.graphics.PixelFormat}. Default is OPAQUE. 691 */ 692 public int format; 693 694 /** 695 * A style resource defining the animations to use for this window. 696 * This must be a system resource; it can not be an application resource 697 * because the window manager does not have access to applications. 698 */ 699 public int windowAnimations; 700 701 /** 702 * An alpha value to apply to this entire window. 703 * An alpha of 1.0 means fully opaque and 0.0 means fully transparent 704 */ 705 public float alpha = 1.0f; 706 707 /** 708 * When {@link #FLAG_DIM_BEHIND} is set, this is the amount of dimming 709 * to apply. Range is from 1.0 for completely opaque to 0.0 for no 710 * dim. 711 */ 712 public float dimAmount = 1.0f; 713 714 /** 715 * This can be used to override the user's preferred brightness of 716 * the screen. A value of less than 0, the default, means to use the 717 * preferred screen brightness. 0 to 1 adjusts the brightness from 718 * dark to full bright. 719 */ 720 public float screenBrightness = -1.0f; 721 722 /** 723 * Identifier for this window. This will usually be filled in for 724 * you. 725 */ 726 public IBinder token = null; 727 728 /** 729 * Name of the package owning this window. 730 */ 731 public String packageName = null; 732 733 /** 734 * Specific orientation value for a window. 735 * May be any of the same values allowed 736 * for {@link android.content.pm.ActivityInfo#screenOrientation}. 737 * If not set, a default value of 738 * {@link android.content.pm.ActivityInfo#SCREEN_ORIENTATION_UNSPECIFIED} 739 * will be used. 740 */ 741 public int screenOrientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED; 742 743 LayoutParams()744 public LayoutParams() { 745 super(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT); 746 type = TYPE_APPLICATION; 747 format = PixelFormat.OPAQUE; 748 } 749 LayoutParams(int _type)750 public LayoutParams(int _type) { 751 super(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT); 752 type = _type; 753 format = PixelFormat.OPAQUE; 754 } 755 LayoutParams(int _type, int _flags)756 public LayoutParams(int _type, int _flags) { 757 super(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT); 758 type = _type; 759 flags = _flags; 760 format = PixelFormat.OPAQUE; 761 } 762 LayoutParams(int _type, int _flags, int _format)763 public LayoutParams(int _type, int _flags, int _format) { 764 super(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT); 765 type = _type; 766 flags = _flags; 767 format = _format; 768 } 769 LayoutParams(int w, int h, int _type, int _flags, int _format)770 public LayoutParams(int w, int h, int _type, int _flags, int _format) { 771 super(w, h); 772 type = _type; 773 flags = _flags; 774 format = _format; 775 } 776 LayoutParams(int w, int h, int xpos, int ypos, int _type, int _flags, int _format)777 public LayoutParams(int w, int h, int xpos, int ypos, int _type, 778 int _flags, int _format) { 779 super(w, h); 780 x = xpos; 781 y = ypos; 782 type = _type; 783 flags = _flags; 784 format = _format; 785 } 786 setTitle(CharSequence title)787 public final void setTitle(CharSequence title) { 788 if (null == title) 789 title = ""; 790 791 mTitle = TextUtils.stringOrSpannedString(title); 792 } 793 getTitle()794 public final CharSequence getTitle() { 795 return mTitle; 796 } 797 describeContents()798 public int describeContents() { 799 return 0; 800 } 801 writeToParcel(Parcel out, int parcelableFlags)802 public void writeToParcel(Parcel out, int parcelableFlags) { 803 out.writeInt(width); 804 out.writeInt(height); 805 out.writeInt(x); 806 out.writeInt(y); 807 out.writeInt(type); 808 out.writeInt(memoryType); 809 out.writeInt(flags); 810 out.writeInt(softInputMode); 811 out.writeInt(gravity); 812 out.writeFloat(horizontalMargin); 813 out.writeFloat(verticalMargin); 814 out.writeInt(format); 815 out.writeInt(windowAnimations); 816 out.writeFloat(alpha); 817 out.writeFloat(dimAmount); 818 out.writeFloat(screenBrightness); 819 out.writeStrongBinder(token); 820 out.writeString(packageName); 821 TextUtils.writeToParcel(mTitle, out, parcelableFlags); 822 out.writeInt(screenOrientation); 823 } 824 825 public static final Parcelable.Creator<LayoutParams> CREATOR 826 = new Parcelable.Creator<LayoutParams>() { 827 public LayoutParams createFromParcel(Parcel in) { 828 return new LayoutParams(in); 829 } 830 831 public LayoutParams[] newArray(int size) { 832 return new LayoutParams[size]; 833 } 834 }; 835 836 LayoutParams(Parcel in)837 public LayoutParams(Parcel in) { 838 width = in.readInt(); 839 height = in.readInt(); 840 x = in.readInt(); 841 y = in.readInt(); 842 type = in.readInt(); 843 memoryType = in.readInt(); 844 flags = in.readInt(); 845 softInputMode = in.readInt(); 846 gravity = in.readInt(); 847 horizontalMargin = in.readFloat(); 848 verticalMargin = in.readFloat(); 849 format = in.readInt(); 850 windowAnimations = in.readInt(); 851 alpha = in.readFloat(); 852 dimAmount = in.readFloat(); 853 screenBrightness = in.readFloat(); 854 token = in.readStrongBinder(); 855 packageName = in.readString(); 856 mTitle = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(in); 857 screenOrientation = in.readInt(); 858 } 859 860 @SuppressWarnings({"PointlessBitwiseExpression"}) 861 public static final int LAYOUT_CHANGED = 1<<0; 862 public static final int TYPE_CHANGED = 1<<1; 863 public static final int FLAGS_CHANGED = 1<<2; 864 public static final int FORMAT_CHANGED = 1<<3; 865 public static final int ANIMATION_CHANGED = 1<<4; 866 public static final int DIM_AMOUNT_CHANGED = 1<<5; 867 public static final int TITLE_CHANGED = 1<<6; 868 public static final int ALPHA_CHANGED = 1<<7; 869 public static final int MEMORY_TYPE_CHANGED = 1<<8; 870 public static final int SOFT_INPUT_MODE_CHANGED = 1<<9; 871 public static final int SCREEN_ORIENTATION_CHANGED = 1<<10; 872 public static final int SCREEN_BRIGHTNESS_CHANGED = 1<<11; 873 874 // internal buffer to backup/restore parameters under compatibility mode. 875 private int[] mCompatibilityParamsBackup = null; 876 copyFrom(LayoutParams o)877 public final int copyFrom(LayoutParams o) { 878 int changes = 0; 879 880 if (width != o.width) { 881 width = o.width; 882 changes |= LAYOUT_CHANGED; 883 } 884 if (height != o.height) { 885 height = o.height; 886 changes |= LAYOUT_CHANGED; 887 } 888 if (x != o.x) { 889 x = o.x; 890 changes |= LAYOUT_CHANGED; 891 } 892 if (y != o.y) { 893 y = o.y; 894 changes |= LAYOUT_CHANGED; 895 } 896 if (horizontalWeight != o.horizontalWeight) { 897 horizontalWeight = o.horizontalWeight; 898 changes |= LAYOUT_CHANGED; 899 } 900 if (verticalWeight != o.verticalWeight) { 901 verticalWeight = o.verticalWeight; 902 changes |= LAYOUT_CHANGED; 903 } 904 if (horizontalMargin != o.horizontalMargin) { 905 horizontalMargin = o.horizontalMargin; 906 changes |= LAYOUT_CHANGED; 907 } 908 if (verticalMargin != o.verticalMargin) { 909 verticalMargin = o.verticalMargin; 910 changes |= LAYOUT_CHANGED; 911 } 912 if (type != o.type) { 913 type = o.type; 914 changes |= TYPE_CHANGED; 915 } 916 if (memoryType != o.memoryType) { 917 memoryType = o.memoryType; 918 changes |= MEMORY_TYPE_CHANGED; 919 } 920 if (flags != o.flags) { 921 flags = o.flags; 922 changes |= FLAGS_CHANGED; 923 } 924 if (softInputMode != o.softInputMode) { 925 softInputMode = o.softInputMode; 926 changes |= SOFT_INPUT_MODE_CHANGED; 927 } 928 if (gravity != o.gravity) { 929 gravity = o.gravity; 930 changes |= LAYOUT_CHANGED; 931 } 932 if (horizontalMargin != o.horizontalMargin) { 933 horizontalMargin = o.horizontalMargin; 934 changes |= LAYOUT_CHANGED; 935 } 936 if (verticalMargin != o.verticalMargin) { 937 verticalMargin = o.verticalMargin; 938 changes |= LAYOUT_CHANGED; 939 } 940 if (format != o.format) { 941 format = o.format; 942 changes |= FORMAT_CHANGED; 943 } 944 if (windowAnimations != o.windowAnimations) { 945 windowAnimations = o.windowAnimations; 946 changes |= ANIMATION_CHANGED; 947 } 948 if (token == null) { 949 // NOTE: token only copied if the recipient doesn't 950 // already have one. 951 token = o.token; 952 } 953 if (packageName == null) { 954 // NOTE: packageName only copied if the recipient doesn't 955 // already have one. 956 packageName = o.packageName; 957 } 958 if (!mTitle.equals(o.mTitle)) { 959 mTitle = o.mTitle; 960 changes |= TITLE_CHANGED; 961 } 962 if (alpha != o.alpha) { 963 alpha = o.alpha; 964 changes |= ALPHA_CHANGED; 965 } 966 if (dimAmount != o.dimAmount) { 967 dimAmount = o.dimAmount; 968 changes |= DIM_AMOUNT_CHANGED; 969 } 970 if (screenBrightness != o.screenBrightness) { 971 screenBrightness = o.screenBrightness; 972 changes |= SCREEN_BRIGHTNESS_CHANGED; 973 } 974 975 if (screenOrientation != o.screenOrientation) { 976 screenOrientation = o.screenOrientation; 977 changes |= SCREEN_ORIENTATION_CHANGED; 978 } 979 return changes; 980 } 981 982 @Override debug(String output)983 public String debug(String output) { 984 output += "Contents of " + this + ":"; 985 Log.d("Debug", output); 986 output = super.debug(""); 987 Log.d("Debug", output); 988 Log.d("Debug", ""); 989 Log.d("Debug", "WindowManager.LayoutParams={title=" + mTitle + "}"); 990 return ""; 991 } 992 993 @Override toString()994 public String toString() { 995 StringBuilder sb = new StringBuilder(256); 996 sb.append("WM.LayoutParams{"); 997 sb.append("("); 998 sb.append(x); 999 sb.append(','); 1000 sb.append(y); 1001 sb.append(")("); 1002 sb.append((width==FILL_PARENT?"fill":(width==WRAP_CONTENT?"wrap":width))); 1003 sb.append('x'); 1004 sb.append((height==FILL_PARENT?"fill":(height==WRAP_CONTENT?"wrap":height))); 1005 sb.append(")"); 1006 if (softInputMode != 0) { 1007 sb.append(" sim=#"); 1008 sb.append(Integer.toHexString(softInputMode)); 1009 } 1010 if (gravity != 0) { 1011 sb.append(" gr=#"); 1012 sb.append(Integer.toHexString(gravity)); 1013 } 1014 sb.append(" ty="); 1015 sb.append(type); 1016 sb.append(" fl=#"); 1017 sb.append(Integer.toHexString(flags)); 1018 sb.append(" fmt="); 1019 sb.append(format); 1020 if (windowAnimations != 0) { 1021 sb.append(" wanim=0x"); 1022 sb.append(Integer.toHexString(windowAnimations)); 1023 } 1024 if (screenOrientation != ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED) { 1025 sb.append(" or="); 1026 sb.append(screenOrientation); 1027 } 1028 if ((flags & FLAG_COMPATIBLE_WINDOW) != 0) { 1029 sb.append(" compatible=true"); 1030 } 1031 sb.append('}'); 1032 return sb.toString(); 1033 } 1034 1035 /** 1036 * Scale the layout params' coordinates and size. 1037 * @hide 1038 */ scale(float scale)1039 public void scale(float scale) { 1040 x = (int) (x * scale + 0.5f); 1041 y = (int) (y * scale + 0.5f); 1042 if (width > 0) { 1043 width = (int) (width * scale + 0.5f); 1044 } 1045 if (height > 0) { 1046 height = (int) (height * scale + 0.5f); 1047 } 1048 } 1049 1050 /** 1051 * Backup the layout parameters used in compatibility mode. 1052 * @see LayoutParams#restore() 1053 */ backup()1054 void backup() { 1055 int[] backup = mCompatibilityParamsBackup; 1056 if (backup == null) { 1057 // we backup 4 elements, x, y, width, height 1058 backup = mCompatibilityParamsBackup = new int[4]; 1059 } 1060 backup[0] = x; 1061 backup[1] = y; 1062 backup[2] = width; 1063 backup[3] = height; 1064 } 1065 1066 /** 1067 * Restore the layout params' coordinates, size and gravity 1068 * @see LayoutParams#backup() 1069 */ restore()1070 void restore() { 1071 int[] backup = mCompatibilityParamsBackup; 1072 if (backup != null) { 1073 x = backup[0]; 1074 y = backup[1]; 1075 width = backup[2]; 1076 height = backup[3]; 1077 } 1078 } 1079 1080 private CharSequence mTitle = ""; 1081 } 1082 } 1083