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.app.Presentation; 20 import android.content.Context; 21 import android.content.pm.ActivityInfo; 22 import android.graphics.PixelFormat; 23 import android.os.IBinder; 24 import android.os.Parcel; 25 import android.os.Parcelable; 26 import android.text.TextUtils; 27 import android.util.Log; 28 29 30 /** 31 * The interface that apps use to talk to the window manager. 32 * <p> 33 * Use <code>Context.getSystemService(Context.WINDOW_SERVICE)</code> to get one of these. 34 * </p><p> 35 * Each window manager instance is bound to a particular {@link Display}. 36 * To obtain a {@link WindowManager} for a different display, use 37 * {@link Context#createDisplayContext} to obtain a {@link Context} for that 38 * display, then use <code>Context.getSystemService(Context.WINDOW_SERVICE)</code> 39 * to get the WindowManager. 40 * </p><p> 41 * The simplest way to show a window on another display is to create a 42 * {@link Presentation}. The presentation will automatically obtain a 43 * {@link WindowManager} and {@link Context} for that display. 44 * </p> 45 * 46 * @see android.content.Context#getSystemService 47 * @see android.content.Context#WINDOW_SERVICE 48 */ 49 public interface WindowManager extends ViewManager { 50 /** 51 * Exception that is thrown when trying to add view whose 52 * {@link WindowManager.LayoutParams} {@link WindowManager.LayoutParams#token} 53 * is invalid. 54 */ 55 public static class BadTokenException extends RuntimeException { BadTokenException()56 public BadTokenException() { 57 } 58 BadTokenException(String name)59 public BadTokenException(String name) { 60 super(name); 61 } 62 } 63 64 /** 65 * Exception that is thrown when calling {@link #addView} to a secondary display that cannot 66 * be found. See {@link android.app.Presentation} for more information on secondary displays. 67 */ 68 public static class InvalidDisplayException extends RuntimeException { InvalidDisplayException()69 public InvalidDisplayException() { 70 } 71 InvalidDisplayException(String name)72 public InvalidDisplayException(String name) { 73 super(name); 74 } 75 } 76 77 /** 78 * Returns the {@link Display} upon which this {@link WindowManager} instance 79 * will create new windows. 80 * <p> 81 * Despite the name of this method, the display that is returned is not 82 * necessarily the primary display of the system (see {@link Display#DEFAULT_DISPLAY}). 83 * The returned display could instead be a secondary display that this 84 * window manager instance is managing. Think of it as the display that 85 * this {@link WindowManager} instance uses by default. 86 * </p><p> 87 * To create windows on a different display, you need to obtain a 88 * {@link WindowManager} for that {@link Display}. (See the {@link WindowManager} 89 * class documentation for more information.) 90 * </p> 91 * 92 * @return The display that this window manager is managing. 93 */ getDefaultDisplay()94 public Display getDefaultDisplay(); 95 96 /** 97 * Special variation of {@link #removeView} that immediately invokes 98 * the given view hierarchy's {@link View#onDetachedFromWindow() 99 * View.onDetachedFromWindow()} methods before returning. This is not 100 * for normal applications; using it correctly requires great care. 101 * 102 * @param view The view to be removed. 103 */ removeViewImmediate(View view)104 public void removeViewImmediate(View view); 105 106 public static class LayoutParams extends ViewGroup.LayoutParams 107 implements Parcelable { 108 /** 109 * X position for this window. With the default gravity it is ignored. 110 * When using {@link Gravity#LEFT} or {@link Gravity#START} or {@link Gravity#RIGHT} or 111 * {@link Gravity#END} it provides an offset from the given edge. 112 */ 113 @ViewDebug.ExportedProperty 114 public int x; 115 116 /** 117 * Y position for this window. With the default gravity it is ignored. 118 * When using {@link Gravity#TOP} or {@link Gravity#BOTTOM} it provides 119 * an offset from the given edge. 120 */ 121 @ViewDebug.ExportedProperty 122 public int y; 123 124 /** 125 * Indicates how much of the extra space will be allocated horizontally 126 * to the view associated with these LayoutParams. Specify 0 if the view 127 * should not be stretched. Otherwise the extra pixels will be pro-rated 128 * among all views whose weight is greater than 0. 129 */ 130 @ViewDebug.ExportedProperty 131 public float horizontalWeight; 132 133 /** 134 * Indicates how much of the extra space will be allocated vertically 135 * to the view associated with these LayoutParams. Specify 0 if the view 136 * should not be stretched. Otherwise the extra pixels will be pro-rated 137 * among all views whose weight is greater than 0. 138 */ 139 @ViewDebug.ExportedProperty 140 public float verticalWeight; 141 142 /** 143 * The general type of window. There are three main classes of 144 * window types: 145 * <ul> 146 * <li> <strong>Application windows</strong> (ranging from 147 * {@link #FIRST_APPLICATION_WINDOW} to 148 * {@link #LAST_APPLICATION_WINDOW}) are normal top-level application 149 * windows. For these types of windows, the {@link #token} must be 150 * set to the token of the activity they are a part of (this will 151 * normally be done for you if {@link #token} is null). 152 * <li> <strong>Sub-windows</strong> (ranging from 153 * {@link #FIRST_SUB_WINDOW} to 154 * {@link #LAST_SUB_WINDOW}) are associated with another top-level 155 * window. For these types of windows, the {@link #token} must be 156 * the token of the window it is attached to. 157 * <li> <strong>System windows</strong> (ranging from 158 * {@link #FIRST_SYSTEM_WINDOW} to 159 * {@link #LAST_SYSTEM_WINDOW}) are special types of windows for 160 * use by the system for specific purposes. They should not normally 161 * be used by applications, and a special permission is required 162 * to use them. 163 * </ul> 164 * 165 * @see #TYPE_BASE_APPLICATION 166 * @see #TYPE_APPLICATION 167 * @see #TYPE_APPLICATION_STARTING 168 * @see #TYPE_APPLICATION_PANEL 169 * @see #TYPE_APPLICATION_MEDIA 170 * @see #TYPE_APPLICATION_SUB_PANEL 171 * @see #TYPE_APPLICATION_ATTACHED_DIALOG 172 * @see #TYPE_STATUS_BAR 173 * @see #TYPE_SEARCH_BAR 174 * @see #TYPE_PHONE 175 * @see #TYPE_SYSTEM_ALERT 176 * @see #TYPE_KEYGUARD 177 * @see #TYPE_TOAST 178 * @see #TYPE_SYSTEM_OVERLAY 179 * @see #TYPE_PRIORITY_PHONE 180 * @see #TYPE_STATUS_BAR_PANEL 181 * @see #TYPE_SYSTEM_DIALOG 182 * @see #TYPE_KEYGUARD_DIALOG 183 * @see #TYPE_SYSTEM_ERROR 184 * @see #TYPE_INPUT_METHOD 185 * @see #TYPE_INPUT_METHOD_DIALOG 186 */ 187 @ViewDebug.ExportedProperty(mapping = { 188 @ViewDebug.IntToString(from = TYPE_BASE_APPLICATION, to = "TYPE_BASE_APPLICATION"), 189 @ViewDebug.IntToString(from = TYPE_APPLICATION, to = "TYPE_APPLICATION"), 190 @ViewDebug.IntToString(from = TYPE_APPLICATION_STARTING, to = "TYPE_APPLICATION_STARTING"), 191 @ViewDebug.IntToString(from = TYPE_APPLICATION_PANEL, to = "TYPE_APPLICATION_PANEL"), 192 @ViewDebug.IntToString(from = TYPE_APPLICATION_MEDIA, to = "TYPE_APPLICATION_MEDIA"), 193 @ViewDebug.IntToString(from = TYPE_APPLICATION_SUB_PANEL, to = "TYPE_APPLICATION_SUB_PANEL"), 194 @ViewDebug.IntToString(from = TYPE_APPLICATION_ATTACHED_DIALOG, to = "TYPE_APPLICATION_ATTACHED_DIALOG"), 195 @ViewDebug.IntToString(from = TYPE_APPLICATION_MEDIA_OVERLAY, to = "TYPE_APPLICATION_MEDIA_OVERLAY"), 196 @ViewDebug.IntToString(from = TYPE_STATUS_BAR, to = "TYPE_STATUS_BAR"), 197 @ViewDebug.IntToString(from = TYPE_SEARCH_BAR, to = "TYPE_SEARCH_BAR"), 198 @ViewDebug.IntToString(from = TYPE_PHONE, to = "TYPE_PHONE"), 199 @ViewDebug.IntToString(from = TYPE_SYSTEM_ALERT, to = "TYPE_SYSTEM_ALERT"), 200 @ViewDebug.IntToString(from = TYPE_KEYGUARD, to = "TYPE_KEYGUARD"), 201 @ViewDebug.IntToString(from = TYPE_TOAST, to = "TYPE_TOAST"), 202 @ViewDebug.IntToString(from = TYPE_SYSTEM_OVERLAY, to = "TYPE_SYSTEM_OVERLAY"), 203 @ViewDebug.IntToString(from = TYPE_PRIORITY_PHONE, to = "TYPE_PRIORITY_PHONE"), 204 @ViewDebug.IntToString(from = TYPE_SYSTEM_DIALOG, to = "TYPE_SYSTEM_DIALOG"), 205 @ViewDebug.IntToString(from = TYPE_KEYGUARD_DIALOG, to = "TYPE_KEYGUARD_DIALOG"), 206 @ViewDebug.IntToString(from = TYPE_SYSTEM_ERROR, to = "TYPE_SYSTEM_ERROR"), 207 @ViewDebug.IntToString(from = TYPE_INPUT_METHOD, to = "TYPE_INPUT_METHOD"), 208 @ViewDebug.IntToString(from = TYPE_INPUT_METHOD_DIALOG, to = "TYPE_INPUT_METHOD_DIALOG"), 209 @ViewDebug.IntToString(from = TYPE_WALLPAPER, to = "TYPE_WALLPAPER"), 210 @ViewDebug.IntToString(from = TYPE_STATUS_BAR_PANEL, to = "TYPE_STATUS_BAR_PANEL"), 211 @ViewDebug.IntToString(from = TYPE_SECURE_SYSTEM_OVERLAY, to = "TYPE_SECURE_SYSTEM_OVERLAY"), 212 @ViewDebug.IntToString(from = TYPE_DRAG, to = "TYPE_DRAG"), 213 @ViewDebug.IntToString(from = TYPE_STATUS_BAR_SUB_PANEL, to = "TYPE_STATUS_BAR_SUB_PANEL"), 214 @ViewDebug.IntToString(from = TYPE_POINTER, to = "TYPE_POINTER"), 215 @ViewDebug.IntToString(from = TYPE_NAVIGATION_BAR, to = "TYPE_NAVIGATION_BAR"), 216 @ViewDebug.IntToString(from = TYPE_VOLUME_OVERLAY, to = "TYPE_VOLUME_OVERLAY"), 217 @ViewDebug.IntToString(from = TYPE_BOOT_PROGRESS, to = "TYPE_BOOT_PROGRESS"), 218 @ViewDebug.IntToString(from = TYPE_HIDDEN_NAV_CONSUMER, to = "TYPE_HIDDEN_NAV_CONSUMER"), 219 @ViewDebug.IntToString(from = TYPE_DREAM, to = "TYPE_DREAM"), 220 @ViewDebug.IntToString(from = TYPE_NAVIGATION_BAR_PANEL, to = "TYPE_NAVIGATION_BAR_PANEL"), 221 @ViewDebug.IntToString(from = TYPE_DISPLAY_OVERLAY, to = "TYPE_DISPLAY_OVERLAY"), 222 @ViewDebug.IntToString(from = TYPE_MAGNIFICATION_OVERLAY, to = "TYPE_MAGNIFICATION_OVERLAY"), 223 @ViewDebug.IntToString(from = TYPE_PRIVATE_PRESENTATION, to = "TYPE_PRIVATE_PRESENTATION") 224 }) 225 public int type; 226 227 /** 228 * Start of window types that represent normal application windows. 229 */ 230 public static final int FIRST_APPLICATION_WINDOW = 1; 231 232 /** 233 * Window type: an application window that serves as the "base" window 234 * of the overall application; all other application windows will 235 * appear on top of it. 236 * In multiuser systems shows only on the owning user's window. 237 */ 238 public static final int TYPE_BASE_APPLICATION = 1; 239 240 /** 241 * Window type: a normal application window. The {@link #token} must be 242 * an Activity token identifying who the window belongs to. 243 * In multiuser systems shows only on the owning user's window. 244 */ 245 public static final int TYPE_APPLICATION = 2; 246 247 /** 248 * Window type: special application window that is displayed while the 249 * application is starting. Not for use by applications themselves; 250 * this is used by the system to display something until the 251 * application can show its own windows. 252 * In multiuser systems shows on all users' windows. 253 */ 254 public static final int TYPE_APPLICATION_STARTING = 3; 255 256 /** 257 * End of types of application windows. 258 */ 259 public static final int LAST_APPLICATION_WINDOW = 99; 260 261 /** 262 * Start of types of sub-windows. The {@link #token} of these windows 263 * must be set to the window they are attached to. These types of 264 * windows are kept next to their attached window in Z-order, and their 265 * coordinate space is relative to their attached window. 266 */ 267 public static final int FIRST_SUB_WINDOW = 1000; 268 269 /** 270 * Window type: a panel on top of an application window. These windows 271 * appear on top of their attached window. 272 */ 273 public static final int TYPE_APPLICATION_PANEL = FIRST_SUB_WINDOW; 274 275 /** 276 * Window type: window for showing media (such as video). These windows 277 * are displayed behind their attached window. 278 */ 279 public static final int TYPE_APPLICATION_MEDIA = FIRST_SUB_WINDOW+1; 280 281 /** 282 * Window type: a sub-panel on top of an application window. These 283 * windows are displayed on top their attached window and any 284 * {@link #TYPE_APPLICATION_PANEL} panels. 285 */ 286 public static final int TYPE_APPLICATION_SUB_PANEL = FIRST_SUB_WINDOW+2; 287 288 /** Window type: like {@link #TYPE_APPLICATION_PANEL}, but layout 289 * of the window happens as that of a top-level window, <em>not</em> 290 * as a child of its container. 291 */ 292 public static final int TYPE_APPLICATION_ATTACHED_DIALOG = FIRST_SUB_WINDOW+3; 293 294 /** 295 * Window type: window for showing overlays on top of media windows. 296 * These windows are displayed between TYPE_APPLICATION_MEDIA and the 297 * application window. They should be translucent to be useful. This 298 * is a big ugly hack so: 299 * @hide 300 */ 301 public static final int TYPE_APPLICATION_MEDIA_OVERLAY = FIRST_SUB_WINDOW+4; 302 303 /** 304 * End of types of sub-windows. 305 */ 306 public static final int LAST_SUB_WINDOW = 1999; 307 308 /** 309 * Start of system-specific window types. These are not normally 310 * created by applications. 311 */ 312 public static final int FIRST_SYSTEM_WINDOW = 2000; 313 314 /** 315 * Window type: the status bar. There can be only one status bar 316 * window; it is placed at the top of the screen, and all other 317 * windows are shifted down so they are below it. 318 * In multiuser systems shows on all users' windows. 319 */ 320 public static final int TYPE_STATUS_BAR = FIRST_SYSTEM_WINDOW; 321 322 /** 323 * Window type: the search bar. There can be only one search bar 324 * window; it is placed at the top of the screen. 325 * In multiuser systems shows on all users' windows. 326 */ 327 public static final int TYPE_SEARCH_BAR = FIRST_SYSTEM_WINDOW+1; 328 329 /** 330 * Window type: phone. These are non-application windows providing 331 * user interaction with the phone (in particular incoming calls). 332 * These windows are normally placed above all applications, but behind 333 * the status bar. 334 * In multiuser systems shows on all users' windows. 335 */ 336 public static final int TYPE_PHONE = FIRST_SYSTEM_WINDOW+2; 337 338 /** 339 * Window type: system window, such as low power alert. These windows 340 * are always on top of application windows. 341 * In multiuser systems shows only on the owning user's window. 342 */ 343 public static final int TYPE_SYSTEM_ALERT = FIRST_SYSTEM_WINDOW+3; 344 345 /** 346 * Window type: keyguard window. 347 * In multiuser systems shows on all users' windows. 348 */ 349 public static final int TYPE_KEYGUARD = FIRST_SYSTEM_WINDOW+4; 350 351 /** 352 * Window type: transient notifications. 353 * In multiuser systems shows only on the owning user's window. 354 */ 355 public static final int TYPE_TOAST = FIRST_SYSTEM_WINDOW+5; 356 357 /** 358 * Window type: system overlay windows, which need to be displayed 359 * on top of everything else. These windows must not take input 360 * focus, or they will interfere with the keyguard. 361 * In multiuser systems shows only on the owning user's window. 362 */ 363 public static final int TYPE_SYSTEM_OVERLAY = FIRST_SYSTEM_WINDOW+6; 364 365 /** 366 * Window type: priority phone UI, which needs to be displayed even if 367 * the keyguard is active. These windows must not take input 368 * focus, or they will interfere with the keyguard. 369 * In multiuser systems shows on all users' windows. 370 */ 371 public static final int TYPE_PRIORITY_PHONE = FIRST_SYSTEM_WINDOW+7; 372 373 /** 374 * Window type: panel that slides out from the status bar 375 * In multiuser systems shows on all users' windows. 376 */ 377 public static final int TYPE_SYSTEM_DIALOG = FIRST_SYSTEM_WINDOW+8; 378 379 /** 380 * Window type: dialogs that the keyguard shows 381 * In multiuser systems shows on all users' windows. 382 */ 383 public static final int TYPE_KEYGUARD_DIALOG = FIRST_SYSTEM_WINDOW+9; 384 385 /** 386 * Window type: internal system error windows, appear on top of 387 * everything they can. 388 * In multiuser systems shows only on the owning user's window. 389 */ 390 public static final int TYPE_SYSTEM_ERROR = FIRST_SYSTEM_WINDOW+10; 391 392 /** 393 * Window type: internal input methods windows, which appear above 394 * the normal UI. Application windows may be resized or panned to keep 395 * the input focus visible while this window is displayed. 396 * In multiuser systems shows only on the owning user's window. 397 */ 398 public static final int TYPE_INPUT_METHOD = FIRST_SYSTEM_WINDOW+11; 399 400 /** 401 * Window type: internal input methods dialog windows, which appear above 402 * the current input method window. 403 * In multiuser systems shows only on the owning user's window. 404 */ 405 public static final int TYPE_INPUT_METHOD_DIALOG= FIRST_SYSTEM_WINDOW+12; 406 407 /** 408 * Window type: wallpaper window, placed behind any window that wants 409 * to sit on top of the wallpaper. 410 * In multiuser systems shows only on the owning user's window. 411 */ 412 public static final int TYPE_WALLPAPER = FIRST_SYSTEM_WINDOW+13; 413 414 /** 415 * Window type: panel that slides out from over the status bar 416 * In multiuser systems shows on all users' windows. 417 */ 418 public static final int TYPE_STATUS_BAR_PANEL = FIRST_SYSTEM_WINDOW+14; 419 420 /** 421 * Window type: secure system overlay windows, which need to be displayed 422 * on top of everything else. These windows must not take input 423 * focus, or they will interfere with the keyguard. 424 * 425 * This is exactly like {@link #TYPE_SYSTEM_OVERLAY} except that only the 426 * system itself is allowed to create these overlays. Applications cannot 427 * obtain permission to create secure system overlays. 428 * 429 * In multiuser systems shows only on the owning user's window. 430 * @hide 431 */ 432 public static final int TYPE_SECURE_SYSTEM_OVERLAY = FIRST_SYSTEM_WINDOW+15; 433 434 /** 435 * Window type: the drag-and-drop pseudowindow. There is only one 436 * drag layer (at most), and it is placed on top of all other windows. 437 * In multiuser systems shows only on the owning user's window. 438 * @hide 439 */ 440 public static final int TYPE_DRAG = FIRST_SYSTEM_WINDOW+16; 441 442 /** 443 * Window type: panel that slides out from under the status bar 444 * In multiuser systems shows on all users' windows. 445 * @hide 446 */ 447 public static final int TYPE_STATUS_BAR_SUB_PANEL = FIRST_SYSTEM_WINDOW+17; 448 449 /** 450 * Window type: (mouse) pointer 451 * In multiuser systems shows on all users' windows. 452 * @hide 453 */ 454 public static final int TYPE_POINTER = FIRST_SYSTEM_WINDOW+18; 455 456 /** 457 * Window type: Navigation bar (when distinct from status bar) 458 * In multiuser systems shows on all users' windows. 459 * @hide 460 */ 461 public static final int TYPE_NAVIGATION_BAR = FIRST_SYSTEM_WINDOW+19; 462 463 /** 464 * Window type: The volume level overlay/dialog shown when the user 465 * changes the system volume. 466 * In multiuser systems shows on all users' windows. 467 * @hide 468 */ 469 public static final int TYPE_VOLUME_OVERLAY = FIRST_SYSTEM_WINDOW+20; 470 471 /** 472 * Window type: The boot progress dialog, goes on top of everything 473 * in the world. 474 * In multiuser systems shows on all users' windows. 475 * @hide 476 */ 477 public static final int TYPE_BOOT_PROGRESS = FIRST_SYSTEM_WINDOW+21; 478 479 /** 480 * Window type: Fake window to consume touch events when the navigation 481 * bar is hidden. 482 * In multiuser systems shows on all users' windows. 483 * @hide 484 */ 485 public static final int TYPE_HIDDEN_NAV_CONSUMER = FIRST_SYSTEM_WINDOW+22; 486 487 /** 488 * Window type: Dreams (screen saver) window, just above keyguard. 489 * In multiuser systems shows only on the owning user's window. 490 * @hide 491 */ 492 public static final int TYPE_DREAM = FIRST_SYSTEM_WINDOW+23; 493 494 /** 495 * Window type: Navigation bar panel (when navigation bar is distinct from status bar) 496 * In multiuser systems shows on all users' windows. 497 * @hide 498 */ 499 public static final int TYPE_NAVIGATION_BAR_PANEL = FIRST_SYSTEM_WINDOW+24; 500 501 /** 502 * Window type: Behind the universe of the real windows. 503 * In multiuser systems shows on all users' windows. 504 * @hide 505 */ 506 public static final int TYPE_UNIVERSE_BACKGROUND = FIRST_SYSTEM_WINDOW+25; 507 508 /** 509 * Window type: Display overlay window. Used to simulate secondary display devices. 510 * In multiuser systems shows on all users' windows. 511 * @hide 512 */ 513 public static final int TYPE_DISPLAY_OVERLAY = FIRST_SYSTEM_WINDOW+26; 514 515 /** 516 * Window type: Magnification overlay window. Used to highlight the magnified 517 * portion of a display when accessibility magnification is enabled. 518 * In multiuser systems shows on all users' windows. 519 * @hide 520 */ 521 public static final int TYPE_MAGNIFICATION_OVERLAY = FIRST_SYSTEM_WINDOW+27; 522 523 /** 524 * Window type: Recents. Same layer as {@link #TYPE_SYSTEM_DIALOG} but only appears on 525 * one user's screen. 526 * In multiuser systems shows on all users' windows. 527 * @hide 528 */ 529 public static final int TYPE_RECENTS_OVERLAY = FIRST_SYSTEM_WINDOW+28; 530 531 532 /** 533 * Window type: keyguard scrim window. Shows if keyguard needs to be restarted. 534 * In multiuser systems shows on all users' windows. 535 * @hide 536 */ 537 public static final int TYPE_KEYGUARD_SCRIM = FIRST_SYSTEM_WINDOW+29; 538 539 /** 540 * Window type: Window for Presentation on top of private 541 * virtual display. 542 */ 543 public static final int TYPE_PRIVATE_PRESENTATION = FIRST_SYSTEM_WINDOW+30; 544 545 /** 546 * End of types of system windows. 547 */ 548 public static final int LAST_SYSTEM_WINDOW = 2999; 549 550 /** @deprecated this is ignored, this value is set automatically when needed. */ 551 @Deprecated 552 public static final int MEMORY_TYPE_NORMAL = 0; 553 /** @deprecated this is ignored, this value is set automatically when needed. */ 554 @Deprecated 555 public static final int MEMORY_TYPE_HARDWARE = 1; 556 /** @deprecated this is ignored, this value is set automatically when needed. */ 557 @Deprecated 558 public static final int MEMORY_TYPE_GPU = 2; 559 /** @deprecated this is ignored, this value is set automatically when needed. */ 560 @Deprecated 561 public static final int MEMORY_TYPE_PUSH_BUFFERS = 3; 562 563 /** 564 * @deprecated this is ignored 565 */ 566 @Deprecated 567 public int memoryType; 568 569 /** Window flag: as long as this window is visible to the user, allow 570 * the lock screen to activate while the screen is on. 571 * This can be used independently, or in combination with 572 * {@link #FLAG_KEEP_SCREEN_ON} and/or {@link #FLAG_SHOW_WHEN_LOCKED} */ 573 public static final int FLAG_ALLOW_LOCK_WHILE_SCREEN_ON = 0x00000001; 574 575 /** Window flag: everything behind this window will be dimmed. 576 * Use {@link #dimAmount} to control the amount of dim. */ 577 public static final int FLAG_DIM_BEHIND = 0x00000002; 578 579 /** Window flag: blur everything behind this window. 580 * @deprecated Blurring is no longer supported. */ 581 @Deprecated 582 public static final int FLAG_BLUR_BEHIND = 0x00000004; 583 584 /** Window flag: this window won't ever get key input focus, so the 585 * user can not send key or other button events to it. Those will 586 * instead go to whatever focusable window is behind it. This flag 587 * will also enable {@link #FLAG_NOT_TOUCH_MODAL} whether or not that 588 * is explicitly set. 589 * 590 * <p>Setting this flag also implies that the window will not need to 591 * interact with 592 * a soft input method, so it will be Z-ordered and positioned 593 * independently of any active input method (typically this means it 594 * gets Z-ordered on top of the input method, so it can use the full 595 * screen for its content and cover the input method if needed. You 596 * can use {@link #FLAG_ALT_FOCUSABLE_IM} to modify this behavior. */ 597 public static final int FLAG_NOT_FOCUSABLE = 0x00000008; 598 599 /** Window flag: this window can never receive touch events. */ 600 public static final int FLAG_NOT_TOUCHABLE = 0x00000010; 601 602 /** Window flag: even when this window is focusable (its 603 * {@link #FLAG_NOT_FOCUSABLE} is not set), allow any pointer events 604 * outside of the window to be sent to the windows behind it. Otherwise 605 * it will consume all pointer events itself, regardless of whether they 606 * are inside of the window. */ 607 public static final int FLAG_NOT_TOUCH_MODAL = 0x00000020; 608 609 /** Window flag: when set, if the device is asleep when the touch 610 * screen is pressed, you will receive this first touch event. Usually 611 * the first touch event is consumed by the system since the user can 612 * not see what they are pressing on. 613 */ 614 public static final int FLAG_TOUCHABLE_WHEN_WAKING = 0x00000040; 615 616 /** Window flag: as long as this window is visible to the user, keep 617 * the device's screen turned on and bright. */ 618 public static final int FLAG_KEEP_SCREEN_ON = 0x00000080; 619 620 /** Window flag: place the window within the entire screen, ignoring 621 * decorations around the border (such as the status bar). The 622 * window must correctly position its contents to take the screen 623 * decoration into account. This flag is normally set for you 624 * by Window as described in {@link Window#setFlags}. */ 625 public static final int FLAG_LAYOUT_IN_SCREEN = 0x00000100; 626 627 /** Window flag: allow window to extend outside of the screen. */ 628 public static final int FLAG_LAYOUT_NO_LIMITS = 0x00000200; 629 630 /** 631 * Window flag: hide all screen decorations (such as the status bar) while 632 * this window is displayed. This allows the window to use the entire 633 * display space for itself -- the status bar will be hidden when 634 * an app window with this flag set is on the top layer. A fullscreen window 635 * will ignore a value of {@link #SOFT_INPUT_ADJUST_RESIZE} for the window's 636 * {@link #softInputMode} field; the window will stay fullscreen 637 * and will not resize. 638 * 639 * <p>This flag can be controlled in your theme through the 640 * {@link android.R.attr#windowFullscreen} attribute; this attribute 641 * is automatically set for you in the standard fullscreen themes 642 * such as {@link android.R.style#Theme_NoTitleBar_Fullscreen}, 643 * {@link android.R.style#Theme_Black_NoTitleBar_Fullscreen}, 644 * {@link android.R.style#Theme_Light_NoTitleBar_Fullscreen}, 645 * {@link android.R.style#Theme_Holo_NoActionBar_Fullscreen}, 646 * {@link android.R.style#Theme_Holo_Light_NoActionBar_Fullscreen}, 647 * {@link android.R.style#Theme_DeviceDefault_NoActionBar_Fullscreen}, and 648 * {@link android.R.style#Theme_DeviceDefault_Light_NoActionBar_Fullscreen}.</p> 649 */ 650 public static final int FLAG_FULLSCREEN = 0x00000400; 651 652 /** Window flag: override {@link #FLAG_FULLSCREEN} and force the 653 * screen decorations (such as the status bar) to be shown. */ 654 public static final int FLAG_FORCE_NOT_FULLSCREEN = 0x00000800; 655 656 /** Window flag: turn on dithering when compositing this window to 657 * the screen. 658 * @deprecated This flag is no longer used. */ 659 @Deprecated 660 public static final int FLAG_DITHER = 0x00001000; 661 662 /** Window flag: treat the content of the window as secure, preventing 663 * it from appearing in screenshots or from being viewed on non-secure 664 * displays. 665 * 666 * <p>See {@link android.view.Display#FLAG_SECURE} for more details about 667 * secure surfaces and secure displays. 668 */ 669 public static final int FLAG_SECURE = 0x00002000; 670 671 /** Window flag: a special mode where the layout parameters are used 672 * to perform scaling of the surface when it is composited to the 673 * screen. */ 674 public static final int FLAG_SCALED = 0x00004000; 675 676 /** Window flag: intended for windows that will often be used when the user is 677 * holding the screen against their face, it will aggressively filter the event 678 * stream to prevent unintended presses in this situation that may not be 679 * desired for a particular window, when such an event stream is detected, the 680 * application will receive a CANCEL motion event to indicate this so applications 681 * can handle this accordingly by taking no action on the event 682 * until the finger is released. */ 683 public static final int FLAG_IGNORE_CHEEK_PRESSES = 0x00008000; 684 685 /** Window flag: a special option only for use in combination with 686 * {@link #FLAG_LAYOUT_IN_SCREEN}. When requesting layout in the 687 * screen your window may appear on top of or behind screen decorations 688 * such as the status bar. By also including this flag, the window 689 * manager will report the inset rectangle needed to ensure your 690 * content is not covered by screen decorations. This flag is normally 691 * set for you by Window as described in {@link Window#setFlags}.*/ 692 public static final int FLAG_LAYOUT_INSET_DECOR = 0x00010000; 693 694 /** Window flag: invert the state of {@link #FLAG_NOT_FOCUSABLE} with 695 * respect to how this window interacts with the current method. That 696 * is, if FLAG_NOT_FOCUSABLE is set and this flag is set, then the 697 * window will behave as if it needs to interact with the input method 698 * and thus be placed behind/away from it; if FLAG_NOT_FOCUSABLE is 699 * not set and this flag is set, then the window will behave as if it 700 * doesn't need to interact with the input method and can be placed 701 * to use more space and cover the input method. 702 */ 703 public static final int FLAG_ALT_FOCUSABLE_IM = 0x00020000; 704 705 /** Window flag: if you have set {@link #FLAG_NOT_TOUCH_MODAL}, you 706 * can set this flag to receive a single special MotionEvent with 707 * the action 708 * {@link MotionEvent#ACTION_OUTSIDE MotionEvent.ACTION_OUTSIDE} for 709 * touches that occur outside of your window. Note that you will not 710 * receive the full down/move/up gesture, only the location of the 711 * first down as an ACTION_OUTSIDE. 712 */ 713 public static final int FLAG_WATCH_OUTSIDE_TOUCH = 0x00040000; 714 715 /** Window flag: special flag to let windows be shown when the screen 716 * is locked. This will let application windows take precedence over 717 * key guard or any other lock screens. Can be used with 718 * {@link #FLAG_KEEP_SCREEN_ON} to turn screen on and display windows 719 * directly before showing the key guard window. Can be used with 720 * {@link #FLAG_DISMISS_KEYGUARD} to automatically fully dismisss 721 * non-secure keyguards. This flag only applies to the top-most 722 * full-screen window. 723 */ 724 public static final int FLAG_SHOW_WHEN_LOCKED = 0x00080000; 725 726 /** Window flag: ask that the system wallpaper be shown behind 727 * your window. The window surface must be translucent to be able 728 * to actually see the wallpaper behind it; this flag just ensures 729 * that the wallpaper surface will be there if this window actually 730 * has translucent regions. 731 * 732 * <p>This flag can be controlled in your theme through the 733 * {@link android.R.attr#windowShowWallpaper} attribute; this attribute 734 * is automatically set for you in the standard wallpaper themes 735 * such as {@link android.R.style#Theme_Wallpaper}, 736 * {@link android.R.style#Theme_Wallpaper_NoTitleBar}, 737 * {@link android.R.style#Theme_Wallpaper_NoTitleBar_Fullscreen}, 738 * {@link android.R.style#Theme_Holo_Wallpaper}, 739 * {@link android.R.style#Theme_Holo_Wallpaper_NoTitleBar}, 740 * {@link android.R.style#Theme_DeviceDefault_Wallpaper}, and 741 * {@link android.R.style#Theme_DeviceDefault_Wallpaper_NoTitleBar}.</p> 742 */ 743 public static final int FLAG_SHOW_WALLPAPER = 0x00100000; 744 745 /** Window flag: when set as a window is being added or made 746 * visible, once the window has been shown then the system will 747 * poke the power manager's user activity (as if the user had woken 748 * up the device) to turn the screen on. */ 749 public static final int FLAG_TURN_SCREEN_ON = 0x00200000; 750 751 /** Window flag: when set the window will cause the keyguard to 752 * be dismissed, only if it is not a secure lock keyguard. Because such 753 * a keyguard is not needed for security, it will never re-appear if 754 * the user navigates to another window (in contrast to 755 * {@link #FLAG_SHOW_WHEN_LOCKED}, which will only temporarily 756 * hide both secure and non-secure keyguards but ensure they reappear 757 * when the user moves to another UI that doesn't hide them). 758 * If the keyguard is currently active and is secure (requires an 759 * unlock pattern) than the user will still need to confirm it before 760 * seeing this window, unless {@link #FLAG_SHOW_WHEN_LOCKED} has 761 * also been set. 762 */ 763 public static final int FLAG_DISMISS_KEYGUARD = 0x00400000; 764 765 /** Window flag: when set the window will accept for touch events 766 * outside of its bounds to be sent to other windows that also 767 * support split touch. When this flag is not set, the first pointer 768 * that goes down determines the window to which all subsequent touches 769 * go until all pointers go up. When this flag is set, each pointer 770 * (not necessarily the first) that goes down determines the window 771 * to which all subsequent touches of that pointer will go until that 772 * pointer goes up thereby enabling touches with multiple pointers 773 * to be split across multiple windows. 774 */ 775 public static final int FLAG_SPLIT_TOUCH = 0x00800000; 776 777 /** 778 * <p>Indicates whether this window should be hardware accelerated. 779 * Requesting hardware acceleration does not guarantee it will happen.</p> 780 * 781 * <p>This flag can be controlled programmatically <em>only</em> to enable 782 * hardware acceleration. To enable hardware acceleration for a given 783 * window programmatically, do the following:</p> 784 * 785 * <pre> 786 * Window w = activity.getWindow(); // in Activity's onCreate() for instance 787 * w.setFlags(WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED, 788 * WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED); 789 * </pre> 790 * 791 * <p>It is important to remember that this flag <strong>must</strong> 792 * be set before setting the content view of your activity or dialog.</p> 793 * 794 * <p>This flag cannot be used to disable hardware acceleration after it 795 * was enabled in your manifest using 796 * {@link android.R.attr#hardwareAccelerated}. If you need to selectively 797 * and programmatically disable hardware acceleration (for automated testing 798 * for instance), make sure it is turned off in your manifest and enable it 799 * on your activity or dialog when you need it instead, using the method 800 * described above.</p> 801 * 802 * <p>This flag is automatically set by the system if the 803 * {@link android.R.attr#hardwareAccelerated android:hardwareAccelerated} 804 * XML attribute is set to true on an activity or on the application.</p> 805 */ 806 public static final int FLAG_HARDWARE_ACCELERATED = 0x01000000; 807 808 /** 809 * Window flag: allow window contents to extend in to the screen's 810 * overscan area, if there is one. The window should still correctly 811 * position its contents to take the overscan area into account. 812 * 813 * <p>This flag can be controlled in your theme through the 814 * {@link android.R.attr#windowOverscan} attribute; this attribute 815 * is automatically set for you in the standard overscan themes 816 * such as 817 * {@link android.R.style#Theme_Holo_NoActionBar_Overscan}, 818 * {@link android.R.style#Theme_Holo_Light_NoActionBar_Overscan}, 819 * {@link android.R.style#Theme_DeviceDefault_NoActionBar_Overscan}, and 820 * {@link android.R.style#Theme_DeviceDefault_Light_NoActionBar_Overscan}.</p> 821 * 822 * <p>When this flag is enabled for a window, its normal content may be obscured 823 * to some degree by the overscan region of the display. To ensure key parts of 824 * that content are visible to the user, you can use 825 * {@link View#setFitsSystemWindows(boolean) View.setFitsSystemWindows(boolean)} 826 * to set the point in the view hierarchy where the appropriate offsets should 827 * be applied. (This can be done either by directly calling this function, using 828 * the {@link android.R.attr#fitsSystemWindows} attribute in your view hierarchy, 829 * or implementing you own {@link View#fitSystemWindows(android.graphics.Rect) 830 * View.fitSystemWindows(Rect)} method).</p> 831 * 832 * <p>This mechanism for positioning content elements is identical to its equivalent 833 * use with layout and {@link View#setSystemUiVisibility(int) 834 * View.setSystemUiVisibility(int)}; here is an example layout that will correctly 835 * position its UI elements with this overscan flag is set:</p> 836 * 837 * {@sample development/samples/ApiDemos/res/layout/overscan_activity.xml complete} 838 */ 839 public static final int FLAG_LAYOUT_IN_OVERSCAN = 0x02000000; 840 841 /** 842 * Window flag: request a translucent status bar with minimal system-provided 843 * background protection. 844 * 845 * <p>This flag can be controlled in your theme through the 846 * {@link android.R.attr#windowTranslucentStatus} attribute; this attribute 847 * is automatically set for you in the standard translucent decor themes 848 * such as 849 * {@link android.R.style#Theme_Holo_NoActionBar_TranslucentDecor}, 850 * {@link android.R.style#Theme_Holo_Light_NoActionBar_TranslucentDecor}, 851 * {@link android.R.style#Theme_DeviceDefault_NoActionBar_TranslucentDecor}, and 852 * {@link android.R.style#Theme_DeviceDefault_Light_NoActionBar_TranslucentDecor}.</p> 853 * 854 * <p>When this flag is enabled for a window, it automatically sets 855 * the system UI visibility flags {@link View#SYSTEM_UI_FLAG_LAYOUT_STABLE} and 856 * {@link View#SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN}.</p> 857 */ 858 public static final int FLAG_TRANSLUCENT_STATUS = 0x04000000; 859 860 /** 861 * Window flag: request a translucent navigation bar with minimal system-provided 862 * background protection. 863 * 864 * <p>This flag can be controlled in your theme through the 865 * {@link android.R.attr#windowTranslucentNavigation} attribute; this attribute 866 * is automatically set for you in the standard translucent decor themes 867 * such as 868 * {@link android.R.style#Theme_Holo_NoActionBar_TranslucentDecor}, 869 * {@link android.R.style#Theme_Holo_Light_NoActionBar_TranslucentDecor}, 870 * {@link android.R.style#Theme_DeviceDefault_NoActionBar_TranslucentDecor}, and 871 * {@link android.R.style#Theme_DeviceDefault_Light_NoActionBar_TranslucentDecor}.</p> 872 * 873 * <p>When this flag is enabled for a window, it automatically sets 874 * the system UI visibility flags {@link View#SYSTEM_UI_FLAG_LAYOUT_STABLE} and 875 * {@link View#SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION}.</p> 876 */ 877 public static final int FLAG_TRANSLUCENT_NAVIGATION = 0x08000000; 878 879 // ----- HIDDEN FLAGS. 880 // These start at the high bit and go down. 881 882 /** 883 * Flag for a window in local focus mode. 884 * Window in local focus mode can control focus independent of window manager using 885 * {@link Window#setLocalFocus(boolean, boolean)}. 886 * Usually window in this mode will not get touch/key events from window manager, but will 887 * get events only via local injection using {@link Window#injectInputEvent(InputEvent)}. 888 */ 889 public static final int FLAG_LOCAL_FOCUS_MODE = 0x10000000; 890 891 /** Window flag: Enable touches to slide out of a window into neighboring 892 * windows in mid-gesture instead of being captured for the duration of 893 * the gesture. 894 * 895 * This flag changes the behavior of touch focus for this window only. 896 * Touches can slide out of the window but they cannot necessarily slide 897 * back in (unless the other window with touch focus permits it). 898 * 899 * {@hide} 900 */ 901 public static final int FLAG_SLIPPERY = 0x20000000; 902 903 /** 904 * Flag for a window belonging to an activity that responds to {@link KeyEvent#KEYCODE_MENU} 905 * and therefore needs a Menu key. For devices where Menu is a physical button this flag is 906 * ignored, but on devices where the Menu key is drawn in software it may be hidden unless 907 * this flag is set. 908 * 909 * (Note that Action Bars, when available, are the preferred way to offer additional 910 * functions otherwise accessed via an options menu.) 911 * 912 * {@hide} 913 */ 914 public static final int FLAG_NEEDS_MENU_KEY = 0x40000000; 915 916 917 /** 918 * Various behavioral options/flags. Default is none. 919 * 920 * @see #FLAG_ALLOW_LOCK_WHILE_SCREEN_ON 921 * @see #FLAG_DIM_BEHIND 922 * @see #FLAG_NOT_FOCUSABLE 923 * @see #FLAG_NOT_TOUCHABLE 924 * @see #FLAG_NOT_TOUCH_MODAL 925 * @see #FLAG_TOUCHABLE_WHEN_WAKING 926 * @see #FLAG_KEEP_SCREEN_ON 927 * @see #FLAG_LAYOUT_IN_SCREEN 928 * @see #FLAG_LAYOUT_NO_LIMITS 929 * @see #FLAG_FULLSCREEN 930 * @see #FLAG_FORCE_NOT_FULLSCREEN 931 * @see #FLAG_SECURE 932 * @see #FLAG_SCALED 933 * @see #FLAG_IGNORE_CHEEK_PRESSES 934 * @see #FLAG_LAYOUT_INSET_DECOR 935 * @see #FLAG_ALT_FOCUSABLE_IM 936 * @see #FLAG_WATCH_OUTSIDE_TOUCH 937 * @see #FLAG_SHOW_WHEN_LOCKED 938 * @see #FLAG_SHOW_WALLPAPER 939 * @see #FLAG_TURN_SCREEN_ON 940 * @see #FLAG_DISMISS_KEYGUARD 941 * @see #FLAG_SPLIT_TOUCH 942 * @see #FLAG_HARDWARE_ACCELERATED 943 * @see #FLAG_LOCAL_FOCUS_MODE 944 */ 945 @ViewDebug.ExportedProperty(flagMapping = { 946 @ViewDebug.FlagToString(mask = FLAG_ALLOW_LOCK_WHILE_SCREEN_ON, equals = FLAG_ALLOW_LOCK_WHILE_SCREEN_ON, 947 name = "FLAG_ALLOW_LOCK_WHILE_SCREEN_ON"), 948 @ViewDebug.FlagToString(mask = FLAG_DIM_BEHIND, equals = FLAG_DIM_BEHIND, 949 name = "FLAG_DIM_BEHIND"), 950 @ViewDebug.FlagToString(mask = FLAG_BLUR_BEHIND, equals = FLAG_BLUR_BEHIND, 951 name = "FLAG_BLUR_BEHIND"), 952 @ViewDebug.FlagToString(mask = FLAG_NOT_FOCUSABLE, equals = FLAG_NOT_FOCUSABLE, 953 name = "FLAG_NOT_FOCUSABLE"), 954 @ViewDebug.FlagToString(mask = FLAG_NOT_TOUCHABLE, equals = FLAG_NOT_TOUCHABLE, 955 name = "FLAG_NOT_TOUCHABLE"), 956 @ViewDebug.FlagToString(mask = FLAG_NOT_TOUCH_MODAL, equals = FLAG_NOT_TOUCH_MODAL, 957 name = "FLAG_NOT_TOUCH_MODAL"), 958 @ViewDebug.FlagToString(mask = FLAG_TOUCHABLE_WHEN_WAKING, equals = FLAG_TOUCHABLE_WHEN_WAKING, 959 name = "FLAG_TOUCHABLE_WHEN_WAKING"), 960 @ViewDebug.FlagToString(mask = FLAG_KEEP_SCREEN_ON, equals = FLAG_KEEP_SCREEN_ON, 961 name = "FLAG_KEEP_SCREEN_ON"), 962 @ViewDebug.FlagToString(mask = FLAG_LAYOUT_IN_SCREEN, equals = FLAG_LAYOUT_IN_SCREEN, 963 name = "FLAG_LAYOUT_IN_SCREEN"), 964 @ViewDebug.FlagToString(mask = FLAG_LAYOUT_NO_LIMITS, equals = FLAG_LAYOUT_NO_LIMITS, 965 name = "FLAG_LAYOUT_NO_LIMITS"), 966 @ViewDebug.FlagToString(mask = FLAG_FULLSCREEN, equals = FLAG_FULLSCREEN, 967 name = "FLAG_FULLSCREEN"), 968 @ViewDebug.FlagToString(mask = FLAG_FORCE_NOT_FULLSCREEN, equals = FLAG_FORCE_NOT_FULLSCREEN, 969 name = "FLAG_FORCE_NOT_FULLSCREEN"), 970 @ViewDebug.FlagToString(mask = FLAG_DITHER, equals = FLAG_DITHER, 971 name = "FLAG_DITHER"), 972 @ViewDebug.FlagToString(mask = FLAG_SECURE, equals = FLAG_SECURE, 973 name = "FLAG_SECURE"), 974 @ViewDebug.FlagToString(mask = FLAG_SCALED, equals = FLAG_SCALED, 975 name = "FLAG_SCALED"), 976 @ViewDebug.FlagToString(mask = FLAG_IGNORE_CHEEK_PRESSES, equals = FLAG_IGNORE_CHEEK_PRESSES, 977 name = "FLAG_IGNORE_CHEEK_PRESSES"), 978 @ViewDebug.FlagToString(mask = FLAG_LAYOUT_INSET_DECOR, equals = FLAG_LAYOUT_INSET_DECOR, 979 name = "FLAG_LAYOUT_INSET_DECOR"), 980 @ViewDebug.FlagToString(mask = FLAG_ALT_FOCUSABLE_IM, equals = FLAG_ALT_FOCUSABLE_IM, 981 name = "FLAG_ALT_FOCUSABLE_IM"), 982 @ViewDebug.FlagToString(mask = FLAG_WATCH_OUTSIDE_TOUCH, equals = FLAG_WATCH_OUTSIDE_TOUCH, 983 name = "FLAG_WATCH_OUTSIDE_TOUCH"), 984 @ViewDebug.FlagToString(mask = FLAG_SHOW_WHEN_LOCKED, equals = FLAG_SHOW_WHEN_LOCKED, 985 name = "FLAG_SHOW_WHEN_LOCKED"), 986 @ViewDebug.FlagToString(mask = FLAG_SHOW_WALLPAPER, equals = FLAG_SHOW_WALLPAPER, 987 name = "FLAG_SHOW_WALLPAPER"), 988 @ViewDebug.FlagToString(mask = FLAG_TURN_SCREEN_ON, equals = FLAG_TURN_SCREEN_ON, 989 name = "FLAG_TURN_SCREEN_ON"), 990 @ViewDebug.FlagToString(mask = FLAG_DISMISS_KEYGUARD, equals = FLAG_DISMISS_KEYGUARD, 991 name = "FLAG_DISMISS_KEYGUARD"), 992 @ViewDebug.FlagToString(mask = FLAG_SPLIT_TOUCH, equals = FLAG_SPLIT_TOUCH, 993 name = "FLAG_SPLIT_TOUCH"), 994 @ViewDebug.FlagToString(mask = FLAG_HARDWARE_ACCELERATED, equals = FLAG_HARDWARE_ACCELERATED, 995 name = "FLAG_HARDWARE_ACCELERATED"), 996 @ViewDebug.FlagToString(mask = FLAG_LOCAL_FOCUS_MODE, equals = FLAG_LOCAL_FOCUS_MODE, 997 name = "FLAG_LOCAL_FOCUS_MODE"), 998 @ViewDebug.FlagToString(mask = FLAG_TRANSLUCENT_STATUS, equals = FLAG_TRANSLUCENT_STATUS, 999 name = "FLAG_TRANSLUCENT_STATUS"), 1000 @ViewDebug.FlagToString(mask = FLAG_TRANSLUCENT_NAVIGATION, equals = FLAG_TRANSLUCENT_NAVIGATION, 1001 name = "FLAG_TRANSLUCENT_NAVIGATION") 1002 }) 1003 public int flags; 1004 1005 /** 1006 * If the window has requested hardware acceleration, but this is not 1007 * allowed in the process it is in, then still render it as if it is 1008 * hardware accelerated. This is used for the starting preview windows 1009 * in the system process, which don't need to have the overhead of 1010 * hardware acceleration (they are just a static rendering), but should 1011 * be rendered as such to match the actual window of the app even if it 1012 * is hardware accelerated. 1013 * Even if the window isn't hardware accelerated, still do its rendering 1014 * as if it was. 1015 * Like {@link #FLAG_HARDWARE_ACCELERATED} except for trusted system windows 1016 * that need hardware acceleration (e.g. LockScreen), where hardware acceleration 1017 * is generally disabled. This flag must be specified in addition to 1018 * {@link #FLAG_HARDWARE_ACCELERATED} to enable hardware acceleration for system 1019 * windows. 1020 * 1021 * @hide 1022 */ 1023 public static final int PRIVATE_FLAG_FAKE_HARDWARE_ACCELERATED = 0x00000001; 1024 1025 /** 1026 * In the system process, we globally do not use hardware acceleration 1027 * because there are many threads doing UI there and they conflict. 1028 * If certain parts of the UI that really do want to use hardware 1029 * acceleration, this flag can be set to force it. This is basically 1030 * for the lock screen. Anyone else using it, you are probably wrong. 1031 * 1032 * @hide 1033 */ 1034 public static final int PRIVATE_FLAG_FORCE_HARDWARE_ACCELERATED = 0x00000002; 1035 1036 /** 1037 * By default, wallpapers are sent new offsets when the wallpaper is scrolled. Wallpapers 1038 * may elect to skip these notifications if they are not doing anything productive with 1039 * them (they do not affect the wallpaper scrolling operation) by calling 1040 * {@link 1041 * android.service.wallpaper.WallpaperService.Engine#setOffsetNotificationsEnabled(boolean)}. 1042 * 1043 * @hide 1044 */ 1045 public static final int PRIVATE_FLAG_WANTS_OFFSET_NOTIFICATIONS = 0x00000004; 1046 1047 /** 1048 * This is set for a window that has explicitly specified its 1049 * FLAG_NEEDS_MENU_KEY, so we know the value on this window is the 1050 * appropriate one to use. If this is not set, we should look at 1051 * windows behind it to determine the appropriate value. 1052 * 1053 * @hide 1054 */ 1055 public static final int PRIVATE_FLAG_SET_NEEDS_MENU_KEY = 0x00000008; 1056 1057 /** In a multiuser system if this flag is set and the owner is a system process then this 1058 * window will appear on all user screens. This overrides the default behavior of window 1059 * types that normally only appear on the owning user's screen. Refer to each window type 1060 * to determine its default behavior. 1061 * 1062 * {@hide} */ 1063 public static final int PRIVATE_FLAG_SHOW_FOR_ALL_USERS = 0x00000010; 1064 1065 /** 1066 * Never animate position changes of the window. 1067 * 1068 * {@hide} */ 1069 public static final int PRIVATE_FLAG_NO_MOVE_ANIMATION = 0x00000040; 1070 1071 /** Window flag: special flag to limit the size of the window to be 1072 * original size ([320x480] x density). Used to create window for applications 1073 * running under compatibility mode. 1074 * 1075 * {@hide} */ 1076 public static final int PRIVATE_FLAG_COMPATIBLE_WINDOW = 0x00000080; 1077 1078 /** Window flag: a special option intended for system dialogs. When 1079 * this flag is set, the window will demand focus unconditionally when 1080 * it is created. 1081 * {@hide} */ 1082 public static final int PRIVATE_FLAG_SYSTEM_ERROR = 0x00000100; 1083 1084 /** Window flag: maintain the previous translucent decor state when this window 1085 * becomes top-most. 1086 * {@hide} */ 1087 public static final int PRIVATE_FLAG_INHERIT_TRANSLUCENT_DECOR = 0x00000200; 1088 1089 /** 1090 * Control flags that are private to the platform. 1091 * @hide 1092 */ 1093 public int privateFlags; 1094 1095 /** 1096 * Given a particular set of window manager flags, determine whether 1097 * such a window may be a target for an input method when it has 1098 * focus. In particular, this checks the 1099 * {@link #FLAG_NOT_FOCUSABLE} and {@link #FLAG_ALT_FOCUSABLE_IM} 1100 * flags and returns true if the combination of the two corresponds 1101 * to a window that needs to be behind the input method so that the 1102 * user can type into it. 1103 * 1104 * @param flags The current window manager flags. 1105 * 1106 * @return Returns true if such a window should be behind/interact 1107 * with an input method, false if not. 1108 */ mayUseInputMethod(int flags)1109 public static boolean mayUseInputMethod(int flags) { 1110 switch (flags&(FLAG_NOT_FOCUSABLE|FLAG_ALT_FOCUSABLE_IM)) { 1111 case 0: 1112 case FLAG_NOT_FOCUSABLE|FLAG_ALT_FOCUSABLE_IM: 1113 return true; 1114 } 1115 return false; 1116 } 1117 1118 /** 1119 * Mask for {@link #softInputMode} of the bits that determine the 1120 * desired visibility state of the soft input area for this window. 1121 */ 1122 public static final int SOFT_INPUT_MASK_STATE = 0x0f; 1123 1124 /** 1125 * Visibility state for {@link #softInputMode}: no state has been specified. 1126 */ 1127 public static final int SOFT_INPUT_STATE_UNSPECIFIED = 0; 1128 1129 /** 1130 * Visibility state for {@link #softInputMode}: please don't change the state of 1131 * the soft input area. 1132 */ 1133 public static final int SOFT_INPUT_STATE_UNCHANGED = 1; 1134 1135 /** 1136 * Visibility state for {@link #softInputMode}: please hide any soft input 1137 * area when normally appropriate (when the user is navigating 1138 * forward to your window). 1139 */ 1140 public static final int SOFT_INPUT_STATE_HIDDEN = 2; 1141 1142 /** 1143 * Visibility state for {@link #softInputMode}: please always hide any 1144 * soft input area when this window receives focus. 1145 */ 1146 public static final int SOFT_INPUT_STATE_ALWAYS_HIDDEN = 3; 1147 1148 /** 1149 * Visibility state for {@link #softInputMode}: please show the soft 1150 * input area when normally appropriate (when the user is navigating 1151 * forward to your window). 1152 */ 1153 public static final int SOFT_INPUT_STATE_VISIBLE = 4; 1154 1155 /** 1156 * Visibility state for {@link #softInputMode}: please always make the 1157 * soft input area visible when this window receives input focus. 1158 */ 1159 public static final int SOFT_INPUT_STATE_ALWAYS_VISIBLE = 5; 1160 1161 /** 1162 * Mask for {@link #softInputMode} of the bits that determine the 1163 * way that the window should be adjusted to accommodate the soft 1164 * input window. 1165 */ 1166 public static final int SOFT_INPUT_MASK_ADJUST = 0xf0; 1167 1168 /** Adjustment option for {@link #softInputMode}: nothing specified. 1169 * The system will try to pick one or 1170 * the other depending on the contents of the window. 1171 */ 1172 public static final int SOFT_INPUT_ADJUST_UNSPECIFIED = 0x00; 1173 1174 /** Adjustment option for {@link #softInputMode}: set to allow the 1175 * window to be resized when an input 1176 * method is shown, so that its contents are not covered by the input 1177 * method. This can <em>not</em> be combined with 1178 * {@link #SOFT_INPUT_ADJUST_PAN}; if 1179 * neither of these are set, then the system will try to pick one or 1180 * the other depending on the contents of the window. If the window's 1181 * layout parameter flags include {@link #FLAG_FULLSCREEN}, this 1182 * value for {@link #softInputMode} will be ignored; the window will 1183 * not resize, but will stay fullscreen. 1184 */ 1185 public static final int SOFT_INPUT_ADJUST_RESIZE = 0x10; 1186 1187 /** Adjustment option for {@link #softInputMode}: set to have a window 1188 * pan when an input method is 1189 * shown, so it doesn't need to deal with resizing but just panned 1190 * by the framework to ensure the current input focus is visible. This 1191 * can <em>not</em> be combined with {@link #SOFT_INPUT_ADJUST_RESIZE}; if 1192 * neither of these are set, then the system will try to pick one or 1193 * the other depending on the contents of the window. 1194 */ 1195 public static final int SOFT_INPUT_ADJUST_PAN = 0x20; 1196 1197 /** Adjustment option for {@link #softInputMode}: set to have a window 1198 * not adjust for a shown input method. The window will not be resized, 1199 * and it will not be panned to make its focus visible. 1200 */ 1201 public static final int SOFT_INPUT_ADJUST_NOTHING = 0x30; 1202 1203 /** 1204 * Bit for {@link #softInputMode}: set when the user has navigated 1205 * forward to the window. This is normally set automatically for 1206 * you by the system, though you may want to set it in certain cases 1207 * when you are displaying a window yourself. This flag will always 1208 * be cleared automatically after the window is displayed. 1209 */ 1210 public static final int SOFT_INPUT_IS_FORWARD_NAVIGATION = 0x100; 1211 1212 /** 1213 * Desired operating mode for any soft input area. May be any combination 1214 * of: 1215 * 1216 * <ul> 1217 * <li> One of the visibility states 1218 * {@link #SOFT_INPUT_STATE_UNSPECIFIED}, {@link #SOFT_INPUT_STATE_UNCHANGED}, 1219 * {@link #SOFT_INPUT_STATE_HIDDEN}, {@link #SOFT_INPUT_STATE_ALWAYS_VISIBLE}, or 1220 * {@link #SOFT_INPUT_STATE_VISIBLE}. 1221 * <li> One of the adjustment options 1222 * {@link #SOFT_INPUT_ADJUST_UNSPECIFIED}, 1223 * {@link #SOFT_INPUT_ADJUST_RESIZE}, or 1224 * {@link #SOFT_INPUT_ADJUST_PAN}. 1225 * </ul> 1226 * 1227 * 1228 * <p>This flag can be controlled in your theme through the 1229 * {@link android.R.attr#windowSoftInputMode} attribute.</p> 1230 */ 1231 public int softInputMode; 1232 1233 /** 1234 * Placement of window within the screen as per {@link Gravity}. Both 1235 * {@link Gravity#apply(int, int, int, android.graphics.Rect, int, int, 1236 * android.graphics.Rect) Gravity.apply} and 1237 * {@link Gravity#applyDisplay(int, android.graphics.Rect, android.graphics.Rect) 1238 * Gravity.applyDisplay} are used during window layout, with this value 1239 * given as the desired gravity. For example you can specify 1240 * {@link Gravity#DISPLAY_CLIP_HORIZONTAL Gravity.DISPLAY_CLIP_HORIZONTAL} and 1241 * {@link Gravity#DISPLAY_CLIP_VERTICAL Gravity.DISPLAY_CLIP_VERTICAL} here 1242 * to control the behavior of 1243 * {@link Gravity#applyDisplay(int, android.graphics.Rect, android.graphics.Rect) 1244 * Gravity.applyDisplay}. 1245 * 1246 * @see Gravity 1247 */ 1248 public int gravity; 1249 1250 /** 1251 * The horizontal margin, as a percentage of the container's width, 1252 * between the container and the widget. See 1253 * {@link Gravity#apply(int, int, int, android.graphics.Rect, int, int, 1254 * android.graphics.Rect) Gravity.apply} for how this is used. This 1255 * field is added with {@link #x} to supply the <var>xAdj</var> parameter. 1256 */ 1257 public float horizontalMargin; 1258 1259 /** 1260 * The vertical margin, as a percentage of the container's height, 1261 * between the container and the widget. See 1262 * {@link Gravity#apply(int, int, int, android.graphics.Rect, int, int, 1263 * android.graphics.Rect) Gravity.apply} for how this is used. This 1264 * field is added with {@link #y} to supply the <var>yAdj</var> parameter. 1265 */ 1266 public float verticalMargin; 1267 1268 /** 1269 * The desired bitmap format. May be one of the constants in 1270 * {@link android.graphics.PixelFormat}. Default is OPAQUE. 1271 */ 1272 public int format; 1273 1274 /** 1275 * A style resource defining the animations to use for this window. 1276 * This must be a system resource; it can not be an application resource 1277 * because the window manager does not have access to applications. 1278 */ 1279 public int windowAnimations; 1280 1281 /** 1282 * An alpha value to apply to this entire window. 1283 * An alpha of 1.0 means fully opaque and 0.0 means fully transparent 1284 */ 1285 public float alpha = 1.0f; 1286 1287 /** 1288 * When {@link #FLAG_DIM_BEHIND} is set, this is the amount of dimming 1289 * to apply. Range is from 1.0 for completely opaque to 0.0 for no 1290 * dim. 1291 */ 1292 public float dimAmount = 1.0f; 1293 1294 /** 1295 * Default value for {@link #screenBrightness} and {@link #buttonBrightness} 1296 * indicating that the brightness value is not overridden for this window 1297 * and normal brightness policy should be used. 1298 */ 1299 public static final float BRIGHTNESS_OVERRIDE_NONE = -1.0f; 1300 1301 /** 1302 * Value for {@link #screenBrightness} and {@link #buttonBrightness} 1303 * indicating that the screen or button backlight brightness should be set 1304 * to the lowest value when this window is in front. 1305 */ 1306 public static final float BRIGHTNESS_OVERRIDE_OFF = 0.0f; 1307 1308 /** 1309 * Value for {@link #screenBrightness} and {@link #buttonBrightness} 1310 * indicating that the screen or button backlight brightness should be set 1311 * to the hightest value when this window is in front. 1312 */ 1313 public static final float BRIGHTNESS_OVERRIDE_FULL = 1.0f; 1314 1315 /** 1316 * This can be used to override the user's preferred brightness of 1317 * the screen. A value of less than 0, the default, means to use the 1318 * preferred screen brightness. 0 to 1 adjusts the brightness from 1319 * dark to full bright. 1320 */ 1321 public float screenBrightness = BRIGHTNESS_OVERRIDE_NONE; 1322 1323 /** 1324 * This can be used to override the standard behavior of the button and 1325 * keyboard backlights. A value of less than 0, the default, means to 1326 * use the standard backlight behavior. 0 to 1 adjusts the brightness 1327 * from dark to full bright. 1328 */ 1329 public float buttonBrightness = BRIGHTNESS_OVERRIDE_NONE; 1330 1331 /** 1332 * Value for {@link #rotationAnimation} to define the animation used to 1333 * specify that this window will rotate in or out following a rotation. 1334 */ 1335 public static final int ROTATION_ANIMATION_ROTATE = 0; 1336 1337 /** 1338 * Value for {@link #rotationAnimation} to define the animation used to 1339 * specify that this window will fade in or out following a rotation. 1340 */ 1341 public static final int ROTATION_ANIMATION_CROSSFADE = 1; 1342 1343 /** 1344 * Value for {@link #rotationAnimation} to define the animation used to 1345 * specify that this window will immediately disappear or appear following 1346 * a rotation. 1347 */ 1348 public static final int ROTATION_ANIMATION_JUMPCUT = 2; 1349 1350 /** 1351 * Define the exit and entry animations used on this window when the device is rotated. 1352 * This only has an affect if the incoming and outgoing topmost 1353 * opaque windows have the #FLAG_FULLSCREEN bit set and are not covered 1354 * by other windows. All other situations default to the 1355 * {@link #ROTATION_ANIMATION_ROTATE} behavior. 1356 * 1357 * @see #ROTATION_ANIMATION_ROTATE 1358 * @see #ROTATION_ANIMATION_CROSSFADE 1359 * @see #ROTATION_ANIMATION_JUMPCUT 1360 */ 1361 public int rotationAnimation = ROTATION_ANIMATION_ROTATE; 1362 1363 /** 1364 * Identifier for this window. This will usually be filled in for 1365 * you. 1366 */ 1367 public IBinder token = null; 1368 1369 /** 1370 * Name of the package owning this window. 1371 */ 1372 public String packageName = null; 1373 1374 /** 1375 * Specific orientation value for a window. 1376 * May be any of the same values allowed 1377 * for {@link android.content.pm.ActivityInfo#screenOrientation}. 1378 * If not set, a default value of 1379 * {@link android.content.pm.ActivityInfo#SCREEN_ORIENTATION_UNSPECIFIED} 1380 * will be used. 1381 */ 1382 public int screenOrientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED; 1383 1384 /** 1385 * Control the visibility of the status bar. 1386 * 1387 * @see View#STATUS_BAR_VISIBLE 1388 * @see View#STATUS_BAR_HIDDEN 1389 */ 1390 public int systemUiVisibility; 1391 1392 /** 1393 * @hide 1394 * The ui visibility as requested by the views in this hierarchy. 1395 * the combined value should be systemUiVisibility | subtreeSystemUiVisibility. 1396 */ 1397 public int subtreeSystemUiVisibility; 1398 1399 /** 1400 * Get callbacks about the system ui visibility changing. 1401 * 1402 * TODO: Maybe there should be a bitfield of optional callbacks that we need. 1403 * 1404 * @hide 1405 */ 1406 public boolean hasSystemUiListeners; 1407 1408 /** 1409 * When this window has focus, disable touch pad pointer gesture processing. 1410 * The window will receive raw position updates from the touch pad instead 1411 * of pointer movements and synthetic touch events. 1412 * 1413 * @hide 1414 */ 1415 public static final int INPUT_FEATURE_DISABLE_POINTER_GESTURES = 0x00000001; 1416 1417 /** 1418 * Does not construct an input channel for this window. The channel will therefore 1419 * be incapable of receiving input. 1420 * 1421 * @hide 1422 */ 1423 public static final int INPUT_FEATURE_NO_INPUT_CHANNEL = 0x00000002; 1424 1425 /** 1426 * When this window has focus, does not call user activity for all input events so 1427 * the application will have to do it itself. Should only be used by 1428 * the keyguard and phone app. 1429 * <p> 1430 * Should only be used by the keyguard and phone app. 1431 * </p> 1432 * 1433 * @hide 1434 */ 1435 public static final int INPUT_FEATURE_DISABLE_USER_ACTIVITY = 0x00000004; 1436 1437 /** 1438 * Control special features of the input subsystem. 1439 * 1440 * @see #INPUT_FEATURE_DISABLE_POINTER_GESTURES 1441 * @see #INPUT_FEATURE_NO_INPUT_CHANNEL 1442 * @see #INPUT_FEATURE_DISABLE_USER_ACTIVITY 1443 * @hide 1444 */ 1445 public int inputFeatures; 1446 1447 /** 1448 * Sets the number of milliseconds before the user activity timeout occurs 1449 * when this window has focus. A value of -1 uses the standard timeout. 1450 * A value of 0 uses the minimum support display timeout. 1451 * <p> 1452 * This property can only be used to reduce the user specified display timeout; 1453 * it can never make the timeout longer than it normally would be. 1454 * </p><p> 1455 * Should only be used by the keyguard and phone app. 1456 * </p> 1457 * 1458 * @hide 1459 */ 1460 public long userActivityTimeout = -1; 1461 LayoutParams()1462 public LayoutParams() { 1463 super(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT); 1464 type = TYPE_APPLICATION; 1465 format = PixelFormat.OPAQUE; 1466 } 1467 LayoutParams(int _type)1468 public LayoutParams(int _type) { 1469 super(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT); 1470 type = _type; 1471 format = PixelFormat.OPAQUE; 1472 } 1473 LayoutParams(int _type, int _flags)1474 public LayoutParams(int _type, int _flags) { 1475 super(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT); 1476 type = _type; 1477 flags = _flags; 1478 format = PixelFormat.OPAQUE; 1479 } 1480 LayoutParams(int _type, int _flags, int _format)1481 public LayoutParams(int _type, int _flags, int _format) { 1482 super(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT); 1483 type = _type; 1484 flags = _flags; 1485 format = _format; 1486 } 1487 LayoutParams(int w, int h, int _type, int _flags, int _format)1488 public LayoutParams(int w, int h, int _type, int _flags, int _format) { 1489 super(w, h); 1490 type = _type; 1491 flags = _flags; 1492 format = _format; 1493 } 1494 LayoutParams(int w, int h, int xpos, int ypos, int _type, int _flags, int _format)1495 public LayoutParams(int w, int h, int xpos, int ypos, int _type, 1496 int _flags, int _format) { 1497 super(w, h); 1498 x = xpos; 1499 y = ypos; 1500 type = _type; 1501 flags = _flags; 1502 format = _format; 1503 } 1504 setTitle(CharSequence title)1505 public final void setTitle(CharSequence title) { 1506 if (null == title) 1507 title = ""; 1508 1509 mTitle = TextUtils.stringOrSpannedString(title); 1510 } 1511 getTitle()1512 public final CharSequence getTitle() { 1513 return mTitle; 1514 } 1515 describeContents()1516 public int describeContents() { 1517 return 0; 1518 } 1519 writeToParcel(Parcel out, int parcelableFlags)1520 public void writeToParcel(Parcel out, int parcelableFlags) { 1521 out.writeInt(width); 1522 out.writeInt(height); 1523 out.writeInt(x); 1524 out.writeInt(y); 1525 out.writeInt(type); 1526 out.writeInt(flags); 1527 out.writeInt(privateFlags); 1528 out.writeInt(softInputMode); 1529 out.writeInt(gravity); 1530 out.writeFloat(horizontalMargin); 1531 out.writeFloat(verticalMargin); 1532 out.writeInt(format); 1533 out.writeInt(windowAnimations); 1534 out.writeFloat(alpha); 1535 out.writeFloat(dimAmount); 1536 out.writeFloat(screenBrightness); 1537 out.writeFloat(buttonBrightness); 1538 out.writeInt(rotationAnimation); 1539 out.writeStrongBinder(token); 1540 out.writeString(packageName); 1541 TextUtils.writeToParcel(mTitle, out, parcelableFlags); 1542 out.writeInt(screenOrientation); 1543 out.writeInt(systemUiVisibility); 1544 out.writeInt(subtreeSystemUiVisibility); 1545 out.writeInt(hasSystemUiListeners ? 1 : 0); 1546 out.writeInt(inputFeatures); 1547 out.writeLong(userActivityTimeout); 1548 } 1549 1550 public static final Parcelable.Creator<LayoutParams> CREATOR 1551 = new Parcelable.Creator<LayoutParams>() { 1552 public LayoutParams createFromParcel(Parcel in) { 1553 return new LayoutParams(in); 1554 } 1555 1556 public LayoutParams[] newArray(int size) { 1557 return new LayoutParams[size]; 1558 } 1559 }; 1560 1561 LayoutParams(Parcel in)1562 public LayoutParams(Parcel in) { 1563 width = in.readInt(); 1564 height = in.readInt(); 1565 x = in.readInt(); 1566 y = in.readInt(); 1567 type = in.readInt(); 1568 flags = in.readInt(); 1569 privateFlags = in.readInt(); 1570 softInputMode = in.readInt(); 1571 gravity = in.readInt(); 1572 horizontalMargin = in.readFloat(); 1573 verticalMargin = in.readFloat(); 1574 format = in.readInt(); 1575 windowAnimations = in.readInt(); 1576 alpha = in.readFloat(); 1577 dimAmount = in.readFloat(); 1578 screenBrightness = in.readFloat(); 1579 buttonBrightness = in.readFloat(); 1580 rotationAnimation = in.readInt(); 1581 token = in.readStrongBinder(); 1582 packageName = in.readString(); 1583 mTitle = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(in); 1584 screenOrientation = in.readInt(); 1585 systemUiVisibility = in.readInt(); 1586 subtreeSystemUiVisibility = in.readInt(); 1587 hasSystemUiListeners = in.readInt() != 0; 1588 inputFeatures = in.readInt(); 1589 userActivityTimeout = in.readLong(); 1590 } 1591 1592 @SuppressWarnings({"PointlessBitwiseExpression"}) 1593 public static final int LAYOUT_CHANGED = 1<<0; 1594 public static final int TYPE_CHANGED = 1<<1; 1595 public static final int FLAGS_CHANGED = 1<<2; 1596 public static final int FORMAT_CHANGED = 1<<3; 1597 public static final int ANIMATION_CHANGED = 1<<4; 1598 public static final int DIM_AMOUNT_CHANGED = 1<<5; 1599 public static final int TITLE_CHANGED = 1<<6; 1600 public static final int ALPHA_CHANGED = 1<<7; 1601 public static final int MEMORY_TYPE_CHANGED = 1<<8; 1602 public static final int SOFT_INPUT_MODE_CHANGED = 1<<9; 1603 public static final int SCREEN_ORIENTATION_CHANGED = 1<<10; 1604 public static final int SCREEN_BRIGHTNESS_CHANGED = 1<<11; 1605 public static final int ROTATION_ANIMATION_CHANGED = 1<<12; 1606 /** {@hide} */ 1607 public static final int BUTTON_BRIGHTNESS_CHANGED = 1<<13; 1608 /** {@hide} */ 1609 public static final int SYSTEM_UI_VISIBILITY_CHANGED = 1<<14; 1610 /** {@hide} */ 1611 public static final int SYSTEM_UI_LISTENER_CHANGED = 1<<15; 1612 /** {@hide} */ 1613 public static final int INPUT_FEATURES_CHANGED = 1<<16; 1614 /** {@hide} */ 1615 public static final int PRIVATE_FLAGS_CHANGED = 1<<17; 1616 /** {@hide} */ 1617 public static final int USER_ACTIVITY_TIMEOUT_CHANGED = 1<<18; 1618 /** {@hide} */ 1619 public static final int TRANSLUCENT_FLAGS_CHANGED = 1<<19; 1620 /** {@hide} */ 1621 public static final int EVERYTHING_CHANGED = 0xffffffff; 1622 1623 // internal buffer to backup/restore parameters under compatibility mode. 1624 private int[] mCompatibilityParamsBackup = null; 1625 copyFrom(LayoutParams o)1626 public final int copyFrom(LayoutParams o) { 1627 int changes = 0; 1628 1629 if (width != o.width) { 1630 width = o.width; 1631 changes |= LAYOUT_CHANGED; 1632 } 1633 if (height != o.height) { 1634 height = o.height; 1635 changes |= LAYOUT_CHANGED; 1636 } 1637 if (x != o.x) { 1638 x = o.x; 1639 changes |= LAYOUT_CHANGED; 1640 } 1641 if (y != o.y) { 1642 y = o.y; 1643 changes |= LAYOUT_CHANGED; 1644 } 1645 if (horizontalWeight != o.horizontalWeight) { 1646 horizontalWeight = o.horizontalWeight; 1647 changes |= LAYOUT_CHANGED; 1648 } 1649 if (verticalWeight != o.verticalWeight) { 1650 verticalWeight = o.verticalWeight; 1651 changes |= LAYOUT_CHANGED; 1652 } 1653 if (horizontalMargin != o.horizontalMargin) { 1654 horizontalMargin = o.horizontalMargin; 1655 changes |= LAYOUT_CHANGED; 1656 } 1657 if (verticalMargin != o.verticalMargin) { 1658 verticalMargin = o.verticalMargin; 1659 changes |= LAYOUT_CHANGED; 1660 } 1661 if (type != o.type) { 1662 type = o.type; 1663 changes |= TYPE_CHANGED; 1664 } 1665 if (flags != o.flags) { 1666 final int diff = flags ^ o.flags; 1667 if ((diff & (FLAG_TRANSLUCENT_STATUS | FLAG_TRANSLUCENT_NAVIGATION)) != 0) { 1668 changes |= TRANSLUCENT_FLAGS_CHANGED; 1669 } 1670 flags = o.flags; 1671 changes |= FLAGS_CHANGED; 1672 } 1673 if (privateFlags != o.privateFlags) { 1674 privateFlags = o.privateFlags; 1675 changes |= PRIVATE_FLAGS_CHANGED; 1676 } 1677 if (softInputMode != o.softInputMode) { 1678 softInputMode = o.softInputMode; 1679 changes |= SOFT_INPUT_MODE_CHANGED; 1680 } 1681 if (gravity != o.gravity) { 1682 gravity = o.gravity; 1683 changes |= LAYOUT_CHANGED; 1684 } 1685 if (format != o.format) { 1686 format = o.format; 1687 changes |= FORMAT_CHANGED; 1688 } 1689 if (windowAnimations != o.windowAnimations) { 1690 windowAnimations = o.windowAnimations; 1691 changes |= ANIMATION_CHANGED; 1692 } 1693 if (token == null) { 1694 // NOTE: token only copied if the recipient doesn't 1695 // already have one. 1696 token = o.token; 1697 } 1698 if (packageName == null) { 1699 // NOTE: packageName only copied if the recipient doesn't 1700 // already have one. 1701 packageName = o.packageName; 1702 } 1703 if (!mTitle.equals(o.mTitle)) { 1704 mTitle = o.mTitle; 1705 changes |= TITLE_CHANGED; 1706 } 1707 if (alpha != o.alpha) { 1708 alpha = o.alpha; 1709 changes |= ALPHA_CHANGED; 1710 } 1711 if (dimAmount != o.dimAmount) { 1712 dimAmount = o.dimAmount; 1713 changes |= DIM_AMOUNT_CHANGED; 1714 } 1715 if (screenBrightness != o.screenBrightness) { 1716 screenBrightness = o.screenBrightness; 1717 changes |= SCREEN_BRIGHTNESS_CHANGED; 1718 } 1719 if (buttonBrightness != o.buttonBrightness) { 1720 buttonBrightness = o.buttonBrightness; 1721 changes |= BUTTON_BRIGHTNESS_CHANGED; 1722 } 1723 if (rotationAnimation != o.rotationAnimation) { 1724 rotationAnimation = o.rotationAnimation; 1725 changes |= ROTATION_ANIMATION_CHANGED; 1726 } 1727 1728 if (screenOrientation != o.screenOrientation) { 1729 screenOrientation = o.screenOrientation; 1730 changes |= SCREEN_ORIENTATION_CHANGED; 1731 } 1732 1733 if (systemUiVisibility != o.systemUiVisibility 1734 || subtreeSystemUiVisibility != o.subtreeSystemUiVisibility) { 1735 systemUiVisibility = o.systemUiVisibility; 1736 subtreeSystemUiVisibility = o.subtreeSystemUiVisibility; 1737 changes |= SYSTEM_UI_VISIBILITY_CHANGED; 1738 } 1739 1740 if (hasSystemUiListeners != o.hasSystemUiListeners) { 1741 hasSystemUiListeners = o.hasSystemUiListeners; 1742 changes |= SYSTEM_UI_LISTENER_CHANGED; 1743 } 1744 1745 if (inputFeatures != o.inputFeatures) { 1746 inputFeatures = o.inputFeatures; 1747 changes |= INPUT_FEATURES_CHANGED; 1748 } 1749 1750 if (userActivityTimeout != o.userActivityTimeout) { 1751 userActivityTimeout = o.userActivityTimeout; 1752 changes |= USER_ACTIVITY_TIMEOUT_CHANGED; 1753 } 1754 1755 return changes; 1756 } 1757 1758 @Override debug(String output)1759 public String debug(String output) { 1760 output += "Contents of " + this + ":"; 1761 Log.d("Debug", output); 1762 output = super.debug(""); 1763 Log.d("Debug", output); 1764 Log.d("Debug", ""); 1765 Log.d("Debug", "WindowManager.LayoutParams={title=" + mTitle + "}"); 1766 return ""; 1767 } 1768 1769 @Override toString()1770 public String toString() { 1771 StringBuilder sb = new StringBuilder(256); 1772 sb.append("WM.LayoutParams{"); 1773 sb.append("("); 1774 sb.append(x); 1775 sb.append(','); 1776 sb.append(y); 1777 sb.append(")("); 1778 sb.append((width== MATCH_PARENT ?"fill":(width==WRAP_CONTENT?"wrap":width))); 1779 sb.append('x'); 1780 sb.append((height== MATCH_PARENT ?"fill":(height==WRAP_CONTENT?"wrap":height))); 1781 sb.append(")"); 1782 if (horizontalMargin != 0) { 1783 sb.append(" hm="); 1784 sb.append(horizontalMargin); 1785 } 1786 if (verticalMargin != 0) { 1787 sb.append(" vm="); 1788 sb.append(verticalMargin); 1789 } 1790 if (gravity != 0) { 1791 sb.append(" gr=#"); 1792 sb.append(Integer.toHexString(gravity)); 1793 } 1794 if (softInputMode != 0) { 1795 sb.append(" sim=#"); 1796 sb.append(Integer.toHexString(softInputMode)); 1797 } 1798 sb.append(" ty="); 1799 sb.append(type); 1800 sb.append(" fl=#"); 1801 sb.append(Integer.toHexString(flags)); 1802 if (privateFlags != 0) { 1803 if ((privateFlags & PRIVATE_FLAG_COMPATIBLE_WINDOW) != 0) { 1804 sb.append(" compatible=true"); 1805 } 1806 sb.append(" pfl=0x").append(Integer.toHexString(privateFlags)); 1807 } 1808 if (format != PixelFormat.OPAQUE) { 1809 sb.append(" fmt="); 1810 sb.append(format); 1811 } 1812 if (windowAnimations != 0) { 1813 sb.append(" wanim=0x"); 1814 sb.append(Integer.toHexString(windowAnimations)); 1815 } 1816 if (screenOrientation != ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED) { 1817 sb.append(" or="); 1818 sb.append(screenOrientation); 1819 } 1820 if (alpha != 1.0f) { 1821 sb.append(" alpha="); 1822 sb.append(alpha); 1823 } 1824 if (screenBrightness != BRIGHTNESS_OVERRIDE_NONE) { 1825 sb.append(" sbrt="); 1826 sb.append(screenBrightness); 1827 } 1828 if (buttonBrightness != BRIGHTNESS_OVERRIDE_NONE) { 1829 sb.append(" bbrt="); 1830 sb.append(buttonBrightness); 1831 } 1832 if (rotationAnimation != ROTATION_ANIMATION_ROTATE) { 1833 sb.append(" rotAnim="); 1834 sb.append(rotationAnimation); 1835 } 1836 if (systemUiVisibility != 0) { 1837 sb.append(" sysui=0x"); 1838 sb.append(Integer.toHexString(systemUiVisibility)); 1839 } 1840 if (subtreeSystemUiVisibility != 0) { 1841 sb.append(" vsysui=0x"); 1842 sb.append(Integer.toHexString(subtreeSystemUiVisibility)); 1843 } 1844 if (hasSystemUiListeners) { 1845 sb.append(" sysuil="); 1846 sb.append(hasSystemUiListeners); 1847 } 1848 if (inputFeatures != 0) { 1849 sb.append(" if=0x").append(Integer.toHexString(inputFeatures)); 1850 } 1851 if (userActivityTimeout >= 0) { 1852 sb.append(" userActivityTimeout=").append(userActivityTimeout); 1853 } 1854 sb.append('}'); 1855 return sb.toString(); 1856 } 1857 1858 /** 1859 * Scale the layout params' coordinates and size. 1860 * @hide 1861 */ scale(float scale)1862 public void scale(float scale) { 1863 x = (int) (x * scale + 0.5f); 1864 y = (int) (y * scale + 0.5f); 1865 if (width > 0) { 1866 width = (int) (width * scale + 0.5f); 1867 } 1868 if (height > 0) { 1869 height = (int) (height * scale + 0.5f); 1870 } 1871 } 1872 1873 /** 1874 * Backup the layout parameters used in compatibility mode. 1875 * @see LayoutParams#restore() 1876 */ backup()1877 void backup() { 1878 int[] backup = mCompatibilityParamsBackup; 1879 if (backup == null) { 1880 // we backup 4 elements, x, y, width, height 1881 backup = mCompatibilityParamsBackup = new int[4]; 1882 } 1883 backup[0] = x; 1884 backup[1] = y; 1885 backup[2] = width; 1886 backup[3] = height; 1887 } 1888 1889 /** 1890 * Restore the layout params' coordinates, size and gravity 1891 * @see LayoutParams#backup() 1892 */ restore()1893 void restore() { 1894 int[] backup = mCompatibilityParamsBackup; 1895 if (backup != null) { 1896 x = backup[0]; 1897 y = backup[1]; 1898 width = backup[2]; 1899 height = backup[3]; 1900 } 1901 } 1902 1903 private CharSequence mTitle = ""; 1904 } 1905 } 1906