• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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     /**
69      * Return true if this window manager is configured to request hardware
70      * accelerated windows.  This does <em>not</em> guarantee that they will
71      * actually be accelerated, since that depends on the device supporting them.
72      * @hide
73      */
isHardwareAccelerated()74     public boolean isHardwareAccelerated();
75 
76     public static class LayoutParams extends ViewGroup.LayoutParams
77             implements Parcelable {
78         /**
79          * X position for this window.  With the default gravity it is ignored.
80          * When using {@link Gravity#LEFT} or {@link Gravity#START} or {@link Gravity#RIGHT} or
81          * {@link Gravity#END} it provides an offset from the given edge.
82          */
83         @ViewDebug.ExportedProperty
84         public int x;
85 
86         /**
87          * Y position for this window.  With the default gravity it is ignored.
88          * When using {@link Gravity#TOP} or {@link Gravity#BOTTOM} it provides
89          * an offset from the given edge.
90          */
91         @ViewDebug.ExportedProperty
92         public int y;
93 
94         /**
95          * Indicates how much of the extra space will be allocated horizontally
96          * to the view associated with these LayoutParams. Specify 0 if the view
97          * should not be stretched. Otherwise the extra pixels will be pro-rated
98          * among all views whose weight is greater than 0.
99          */
100         @ViewDebug.ExportedProperty
101         public float horizontalWeight;
102 
103         /**
104          * Indicates how much of the extra space will be allocated vertically
105          * to the view associated with these LayoutParams. Specify 0 if the view
106          * should not be stretched. Otherwise the extra pixels will be pro-rated
107          * among all views whose weight is greater than 0.
108          */
109         @ViewDebug.ExportedProperty
110         public float verticalWeight;
111 
112         /**
113          * The general type of window.  There are three main classes of
114          * window types:
115          * <ul>
116          * <li> <strong>Application windows</strong> (ranging from
117          * {@link #FIRST_APPLICATION_WINDOW} to
118          * {@link #LAST_APPLICATION_WINDOW}) are normal top-level application
119          * windows.  For these types of windows, the {@link #token} must be
120          * set to the token of the activity they are a part of (this will
121          * normally be done for you if {@link #token} is null).
122          * <li> <strong>Sub-windows</strong> (ranging from
123          * {@link #FIRST_SUB_WINDOW} to
124          * {@link #LAST_SUB_WINDOW}) are associated with another top-level
125          * window.  For these types of windows, the {@link #token} must be
126          * the token of the window it is attached to.
127          * <li> <strong>System windows</strong> (ranging from
128          * {@link #FIRST_SYSTEM_WINDOW} to
129          * {@link #LAST_SYSTEM_WINDOW}) are special types of windows for
130          * use by the system for specific purposes.  They should not normally
131          * be used by applications, and a special permission is required
132          * to use them.
133          * </ul>
134          *
135          * @see #TYPE_BASE_APPLICATION
136          * @see #TYPE_APPLICATION
137          * @see #TYPE_APPLICATION_STARTING
138          * @see #TYPE_APPLICATION_PANEL
139          * @see #TYPE_APPLICATION_MEDIA
140          * @see #TYPE_APPLICATION_SUB_PANEL
141          * @see #TYPE_APPLICATION_ATTACHED_DIALOG
142          * @see #TYPE_STATUS_BAR
143          * @see #TYPE_SEARCH_BAR
144          * @see #TYPE_PHONE
145          * @see #TYPE_SYSTEM_ALERT
146          * @see #TYPE_KEYGUARD
147          * @see #TYPE_TOAST
148          * @see #TYPE_SYSTEM_OVERLAY
149          * @see #TYPE_PRIORITY_PHONE
150          * @see #TYPE_STATUS_BAR_PANEL
151          * @see #TYPE_SYSTEM_DIALOG
152          * @see #TYPE_KEYGUARD_DIALOG
153          * @see #TYPE_SYSTEM_ERROR
154          * @see #TYPE_INPUT_METHOD
155          * @see #TYPE_INPUT_METHOD_DIALOG
156          */
157         @ViewDebug.ExportedProperty(mapping = {
158             @ViewDebug.IntToString(from = TYPE_BASE_APPLICATION, to = "TYPE_BASE_APPLICATION"),
159             @ViewDebug.IntToString(from = TYPE_APPLICATION, to = "TYPE_APPLICATION"),
160             @ViewDebug.IntToString(from = TYPE_APPLICATION_STARTING, to = "TYPE_APPLICATION_STARTING"),
161             @ViewDebug.IntToString(from = TYPE_APPLICATION_PANEL, to = "TYPE_APPLICATION_PANEL"),
162             @ViewDebug.IntToString(from = TYPE_APPLICATION_MEDIA, to = "TYPE_APPLICATION_MEDIA"),
163             @ViewDebug.IntToString(from = TYPE_APPLICATION_SUB_PANEL, to = "TYPE_APPLICATION_SUB_PANEL"),
164             @ViewDebug.IntToString(from = TYPE_APPLICATION_ATTACHED_DIALOG, to = "TYPE_APPLICATION_ATTACHED_DIALOG"),
165             @ViewDebug.IntToString(from = TYPE_STATUS_BAR, to = "TYPE_STATUS_BAR"),
166             @ViewDebug.IntToString(from = TYPE_SEARCH_BAR, to = "TYPE_SEARCH_BAR"),
167             @ViewDebug.IntToString(from = TYPE_PHONE, to = "TYPE_PHONE"),
168             @ViewDebug.IntToString(from = TYPE_SYSTEM_ALERT, to = "TYPE_SYSTEM_ALERT"),
169             @ViewDebug.IntToString(from = TYPE_KEYGUARD, to = "TYPE_KEYGUARD"),
170             @ViewDebug.IntToString(from = TYPE_TOAST, to = "TYPE_TOAST"),
171             @ViewDebug.IntToString(from = TYPE_SYSTEM_OVERLAY, to = "TYPE_SYSTEM_OVERLAY"),
172             @ViewDebug.IntToString(from = TYPE_PRIORITY_PHONE, to = "TYPE_PRIORITY_PHONE"),
173             @ViewDebug.IntToString(from = TYPE_STATUS_BAR_PANEL, to = "TYPE_STATUS_BAR_PANEL"),
174             @ViewDebug.IntToString(from = TYPE_STATUS_BAR_SUB_PANEL, to = "TYPE_STATUS_BAR_SUB_PANEL"),
175             @ViewDebug.IntToString(from = TYPE_SYSTEM_DIALOG, to = "TYPE_SYSTEM_DIALOG"),
176             @ViewDebug.IntToString(from = TYPE_KEYGUARD_DIALOG, to = "TYPE_KEYGUARD_DIALOG"),
177             @ViewDebug.IntToString(from = TYPE_SYSTEM_ERROR, to = "TYPE_SYSTEM_ERROR"),
178             @ViewDebug.IntToString(from = TYPE_INPUT_METHOD, to = "TYPE_INPUT_METHOD"),
179             @ViewDebug.IntToString(from = TYPE_INPUT_METHOD_DIALOG, to = "TYPE_INPUT_METHOD_DIALOG"),
180             @ViewDebug.IntToString(from = TYPE_WALLPAPER, to = "TYPE_WALLPAPER"),
181             @ViewDebug.IntToString(from = TYPE_STATUS_BAR_PANEL, to = "TYPE_STATUS_BAR_PANEL"),
182             @ViewDebug.IntToString(from = TYPE_SECURE_SYSTEM_OVERLAY, to = "TYPE_SECURE_SYSTEM_OVERLAY"),
183             @ViewDebug.IntToString(from = TYPE_DRAG, to = "TYPE_DRAG"),
184             @ViewDebug.IntToString(from = TYPE_STATUS_BAR_SUB_PANEL, to = "TYPE_STATUS_BAR_SUB_PANEL"),
185             @ViewDebug.IntToString(from = TYPE_POINTER, to = "TYPE_POINTER"),
186             @ViewDebug.IntToString(from = TYPE_NAVIGATION_BAR, to = "TYPE_NAVIGATION_BAR"),
187             @ViewDebug.IntToString(from = TYPE_VOLUME_OVERLAY, to = "TYPE_VOLUME_OVERLAY"),
188             @ViewDebug.IntToString(from = TYPE_BOOT_PROGRESS, to = "TYPE_BOOT_PROGRESS")
189         })
190         public int type;
191 
192         /**
193          * Start of window types that represent normal application windows.
194          */
195         public static final int FIRST_APPLICATION_WINDOW = 1;
196 
197         /**
198          * Window type: an application window that serves as the "base" window
199          * of the overall application; all other application windows will
200          * appear on top of it.
201          */
202         public static final int TYPE_BASE_APPLICATION   = 1;
203 
204         /**
205          * Window type: a normal application window.  The {@link #token} must be
206          * an Activity token identifying who the window belongs to.
207          */
208         public static final int TYPE_APPLICATION        = 2;
209 
210         /**
211          * Window type: special application window that is displayed while the
212          * application is starting.  Not for use by applications themselves;
213          * this is used by the system to display something until the
214          * application can show its own windows.
215          */
216         public static final int TYPE_APPLICATION_STARTING = 3;
217 
218         /**
219          * End of types of application windows.
220          */
221         public static final int LAST_APPLICATION_WINDOW = 99;
222 
223         /**
224          * Start of types of sub-windows.  The {@link #token} of these windows
225          * must be set to the window they are attached to.  These types of
226          * windows are kept next to their attached window in Z-order, and their
227          * coordinate space is relative to their attached window.
228          */
229         public static final int FIRST_SUB_WINDOW        = 1000;
230 
231         /**
232          * Window type: a panel on top of an application window.  These windows
233          * appear on top of their attached window.
234          */
235         public static final int TYPE_APPLICATION_PANEL  = FIRST_SUB_WINDOW;
236 
237         /**
238          * Window type: window for showing media (e.g. video).  These windows
239          * are displayed behind their attached window.
240          */
241         public static final int TYPE_APPLICATION_MEDIA  = FIRST_SUB_WINDOW+1;
242 
243         /**
244          * Window type: a sub-panel on top of an application window.  These
245          * windows are displayed on top their attached window and any
246          * {@link #TYPE_APPLICATION_PANEL} panels.
247          */
248         public static final int TYPE_APPLICATION_SUB_PANEL = FIRST_SUB_WINDOW+2;
249 
250         /** Window type: like {@link #TYPE_APPLICATION_PANEL}, but layout
251          * of the window happens as that of a top-level window, <em>not</em>
252          * as a child of its container.
253          */
254         public static final int TYPE_APPLICATION_ATTACHED_DIALOG = FIRST_SUB_WINDOW+3;
255 
256         /**
257          * Window type: window for showing overlays on top of media windows.
258          * These windows are displayed between TYPE_APPLICATION_MEDIA and the
259          * application window.  They should be translucent to be useful.  This
260          * is a big ugly hack so:
261          * @hide
262          */
263         public static final int TYPE_APPLICATION_MEDIA_OVERLAY  = FIRST_SUB_WINDOW+4;
264 
265         /**
266          * End of types of sub-windows.
267          */
268         public static final int LAST_SUB_WINDOW         = 1999;
269 
270         /**
271          * Start of system-specific window types.  These are not normally
272          * created by applications.
273          */
274         public static final int FIRST_SYSTEM_WINDOW     = 2000;
275 
276         /**
277          * Window type: the status bar.  There can be only one status bar
278          * window; it is placed at the top of the screen, and all other
279          * windows are shifted down so they are below it.
280          */
281         public static final int TYPE_STATUS_BAR         = FIRST_SYSTEM_WINDOW;
282 
283         /**
284          * Window type: the search bar.  There can be only one search bar
285          * window; it is placed at the top of the screen.
286          */
287         public static final int TYPE_SEARCH_BAR         = FIRST_SYSTEM_WINDOW+1;
288 
289         /**
290          * Window type: phone.  These are non-application windows providing
291          * user interaction with the phone (in particular incoming calls).
292          * These windows are normally placed above all applications, but behind
293          * the status bar.
294          */
295         public static final int TYPE_PHONE              = FIRST_SYSTEM_WINDOW+2;
296 
297         /**
298          * Window type: system window, such as low power alert. These windows
299          * are always on top of application windows.
300          */
301         public static final int TYPE_SYSTEM_ALERT       = FIRST_SYSTEM_WINDOW+3;
302 
303         /**
304          * Window type: keyguard window.
305          */
306         public static final int TYPE_KEYGUARD           = FIRST_SYSTEM_WINDOW+4;
307 
308         /**
309          * Window type: transient notifications.
310          */
311         public static final int TYPE_TOAST              = FIRST_SYSTEM_WINDOW+5;
312 
313         /**
314          * Window type: system overlay windows, which need to be displayed
315          * on top of everything else.  These windows must not take input
316          * focus, or they will interfere with the keyguard.
317          */
318         public static final int TYPE_SYSTEM_OVERLAY     = FIRST_SYSTEM_WINDOW+6;
319 
320         /**
321          * Window type: priority phone UI, which needs to be displayed even if
322          * the keyguard is active.  These windows must not take input
323          * focus, or they will interfere with the keyguard.
324          */
325         public static final int TYPE_PRIORITY_PHONE     = FIRST_SYSTEM_WINDOW+7;
326 
327         /**
328          * Window type: panel that slides out from the status bar
329          */
330         public static final int TYPE_SYSTEM_DIALOG      = FIRST_SYSTEM_WINDOW+8;
331 
332         /**
333          * Window type: dialogs that the keyguard shows
334          */
335         public static final int TYPE_KEYGUARD_DIALOG    = FIRST_SYSTEM_WINDOW+9;
336 
337         /**
338          * Window type: internal system error windows, appear on top of
339          * everything they can.
340          */
341         public static final int TYPE_SYSTEM_ERROR       = FIRST_SYSTEM_WINDOW+10;
342 
343         /**
344          * Window type: internal input methods windows, which appear above
345          * the normal UI.  Application windows may be resized or panned to keep
346          * the input focus visible while this window is displayed.
347          */
348         public static final int TYPE_INPUT_METHOD       = FIRST_SYSTEM_WINDOW+11;
349 
350         /**
351          * Window type: internal input methods dialog windows, which appear above
352          * the current input method window.
353          */
354         public static final int TYPE_INPUT_METHOD_DIALOG= FIRST_SYSTEM_WINDOW+12;
355 
356         /**
357          * Window type: wallpaper window, placed behind any window that wants
358          * to sit on top of the wallpaper.
359          */
360         public static final int TYPE_WALLPAPER          = FIRST_SYSTEM_WINDOW+13;
361 
362         /**
363          * Window type: panel that slides out from over the status bar
364          */
365         public static final int TYPE_STATUS_BAR_PANEL   = FIRST_SYSTEM_WINDOW+14;
366 
367         /**
368          * Window type: secure system overlay windows, which need to be displayed
369          * on top of everything else.  These windows must not take input
370          * focus, or they will interfere with the keyguard.
371          *
372          * This is exactly like {@link #TYPE_SYSTEM_OVERLAY} except that only the
373          * system itself is allowed to create these overlays.  Applications cannot
374          * obtain permission to create secure system overlays.
375          * @hide
376          */
377         public static final int TYPE_SECURE_SYSTEM_OVERLAY = FIRST_SYSTEM_WINDOW+15;
378 
379         /**
380          * Window type: the drag-and-drop pseudowindow.  There is only one
381          * drag layer (at most), and it is placed on top of all other windows.
382          * @hide
383          */
384         public static final int TYPE_DRAG               = FIRST_SYSTEM_WINDOW+16;
385 
386         /**
387          * Window type: panel that slides out from under the status bar
388          * @hide
389          */
390         public static final int TYPE_STATUS_BAR_SUB_PANEL = FIRST_SYSTEM_WINDOW+17;
391 
392         /**
393          * Window type: (mouse) pointer
394          * @hide
395          */
396         public static final int TYPE_POINTER = FIRST_SYSTEM_WINDOW+18;
397 
398         /**
399          * Window type: Navigation bar (when distinct from status bar)
400          * @hide
401          */
402         public static final int TYPE_NAVIGATION_BAR = FIRST_SYSTEM_WINDOW+19;
403 
404         /**
405          * Window type: The volume level overlay/dialog shown when the user
406          * changes the system volume.
407          * @hide
408          */
409         public static final int TYPE_VOLUME_OVERLAY = FIRST_SYSTEM_WINDOW+20;
410 
411         /**
412          * Window type: The boot progress dialog, goes on top of everything
413          * in the world.
414          * @hide
415          */
416         public static final int TYPE_BOOT_PROGRESS = FIRST_SYSTEM_WINDOW+21;
417 
418         /**
419          * Window type: Fake window to consume touch events when the navigation
420          * bar is hidden.
421          * @hide
422          */
423         public static final int TYPE_HIDDEN_NAV_CONSUMER = FIRST_SYSTEM_WINDOW+22;
424 
425         /**
426          * End of types of system windows.
427          */
428         public static final int LAST_SYSTEM_WINDOW      = 2999;
429 
430         /** @deprecated this is ignored, this value is set automatically when needed. */
431         @Deprecated
432         public static final int MEMORY_TYPE_NORMAL = 0;
433         /** @deprecated this is ignored, this value is set automatically when needed. */
434         @Deprecated
435         public static final int MEMORY_TYPE_HARDWARE = 1;
436         /** @deprecated this is ignored, this value is set automatically when needed. */
437         @Deprecated
438         public static final int MEMORY_TYPE_GPU = 2;
439         /** @deprecated this is ignored, this value is set automatically when needed. */
440         @Deprecated
441         public static final int MEMORY_TYPE_PUSH_BUFFERS = 3;
442 
443         /**
444          * @deprecated this is ignored
445          */
446         @Deprecated
447         public int memoryType;
448 
449         /** Window flag: as long as this window is visible to the user, allow
450          *  the lock screen to activate while the screen is on.
451          *  This can be used independently, or in combination with
452          *  {@link #FLAG_KEEP_SCREEN_ON} and/or {@link #FLAG_SHOW_WHEN_LOCKED} */
453         public static final int FLAG_ALLOW_LOCK_WHILE_SCREEN_ON     = 0x00000001;
454 
455         /** Window flag: everything behind this window will be dimmed.
456          *  Use {@link #dimAmount} to control the amount of dim. */
457         public static final int FLAG_DIM_BEHIND        = 0x00000002;
458 
459         /** Window flag: blur everything behind this window.
460          * @deprecated Blurring is no longer supported. */
461         @Deprecated
462         public static final int FLAG_BLUR_BEHIND        = 0x00000004;
463 
464         /** Window flag: this window won't ever get key input focus, so the
465          * user can not send key or other button events to it.  Those will
466          * instead go to whatever focusable window is behind it.  This flag
467          * will also enable {@link #FLAG_NOT_TOUCH_MODAL} whether or not that
468          * is explicitly set.
469          *
470          * <p>Setting this flag also implies that the window will not need to
471          * interact with
472          * a soft input method, so it will be Z-ordered and positioned
473          * independently of any active input method (typically this means it
474          * gets Z-ordered on top of the input method, so it can use the full
475          * screen for its content and cover the input method if needed.  You
476          * can use {@link #FLAG_ALT_FOCUSABLE_IM} to modify this behavior. */
477         public static final int FLAG_NOT_FOCUSABLE      = 0x00000008;
478 
479         /** Window flag: this window can never receive touch events. */
480         public static final int FLAG_NOT_TOUCHABLE      = 0x00000010;
481 
482         /** Window flag: Even when this window is focusable (its
483          * {@link #FLAG_NOT_FOCUSABLE is not set), allow any pointer events
484          * outside of the window to be sent to the windows behind it.  Otherwise
485          * it will consume all pointer events itself, regardless of whether they
486          * are inside of the window. */
487         public static final int FLAG_NOT_TOUCH_MODAL    = 0x00000020;
488 
489         /** Window flag: When set, if the device is asleep when the touch
490          * screen is pressed, you will receive this first touch event.  Usually
491          * the first touch event is consumed by the system since the user can
492          * not see what they are pressing on.
493          */
494         public static final int FLAG_TOUCHABLE_WHEN_WAKING = 0x00000040;
495 
496         /** Window flag: as long as this window is visible to the user, keep
497          *  the device's screen turned on and bright. */
498         public static final int FLAG_KEEP_SCREEN_ON     = 0x00000080;
499 
500         /** Window flag: place the window within the entire screen, ignoring
501          *  decorations around the border (a.k.a. the status bar).  The
502          *  window must correctly position its contents to take the screen
503          *  decoration into account.  This flag is normally set for you
504          *  by Window as described in {@link Window#setFlags}. */
505         public static final int FLAG_LAYOUT_IN_SCREEN   = 0x00000100;
506 
507         /** Window flag: allow window to extend outside of the screen. */
508         public static final int FLAG_LAYOUT_NO_LIMITS   = 0x00000200;
509 
510         /** Window flag: Hide all screen decorations (e.g. status bar) while
511          * this window is displayed.  This allows the window to use the entire
512          * display space for itself -- the status bar will be hidden when
513          * an app window with this flag set is on the top layer. */
514         public static final int FLAG_FULLSCREEN      = 0x00000400;
515 
516         /** Window flag: Override {@link #FLAG_FULLSCREEN and force the
517          *  screen decorations (such as status bar) to be shown. */
518         public static final int FLAG_FORCE_NOT_FULLSCREEN   = 0x00000800;
519 
520         /** Window flag: turn on dithering when compositing this window to
521          *  the screen. */
522         public static final int FLAG_DITHER             = 0x00001000;
523 
524         /** Window flag: don't allow screen shots while this window is
525          * displayed. Maps to Surface.SECURE. */
526         public static final int FLAG_SECURE             = 0x00002000;
527 
528         /** Window flag: a special mode where the layout parameters are used
529          * to perform scaling of the surface when it is composited to the
530          * screen. */
531         public static final int FLAG_SCALED             = 0x00004000;
532 
533         /** Window flag: intended for windows that will often be used when the user is
534          * holding the screen against their face, it will aggressively filter the event
535          * stream to prevent unintended presses in this situation that may not be
536          * desired for a particular window, when such an event stream is detected, the
537          * application will receive a CANCEL motion event to indicate this so applications
538          * can handle this accordingly by taking no action on the event
539          * until the finger is released. */
540         public static final int FLAG_IGNORE_CHEEK_PRESSES    = 0x00008000;
541 
542         /** Window flag: a special option only for use in combination with
543          * {@link #FLAG_LAYOUT_IN_SCREEN}.  When requesting layout in the
544          * screen your window may appear on top of or behind screen decorations
545          * such as the status bar.  By also including this flag, the window
546          * manager will report the inset rectangle needed to ensure your
547          * content is not covered by screen decorations.  This flag is normally
548          * set for you by Window as described in {@link Window#setFlags}.*/
549         public static final int FLAG_LAYOUT_INSET_DECOR = 0x00010000;
550 
551         /** Window flag: invert the state of {@link #FLAG_NOT_FOCUSABLE} with
552          * respect to how this window interacts with the current method.  That
553          * is, if FLAG_NOT_FOCUSABLE is set and this flag is set, then the
554          * window will behave as if it needs to interact with the input method
555          * and thus be placed behind/away from it; if FLAG_NOT_FOCUSABLE is
556          * not set and this flag is set, then the window will behave as if it
557          * doesn't need to interact with the input method and can be placed
558          * to use more space and cover the input method.
559          */
560         public static final int FLAG_ALT_FOCUSABLE_IM = 0x00020000;
561 
562         /** Window flag: if you have set {@link #FLAG_NOT_TOUCH_MODAL}, you
563          * can set this flag to receive a single special MotionEvent with
564          * the action
565          * {@link MotionEvent#ACTION_OUTSIDE MotionEvent.ACTION_OUTSIDE} for
566          * touches that occur outside of your window.  Note that you will not
567          * receive the full down/move/up gesture, only the location of the
568          * first down as an ACTION_OUTSIDE.
569          */
570         public static final int FLAG_WATCH_OUTSIDE_TOUCH = 0x00040000;
571 
572         /** Window flag: special flag to let windows be shown when the screen
573          * is locked. This will let application windows take precedence over
574          * key guard or any other lock screens. Can be used with
575          * {@link #FLAG_KEEP_SCREEN_ON} to turn screen on and display windows
576          * directly before showing the key guard window.  Can be used with
577          * {@link #FLAG_DISMISS_KEYGUARD} to automatically fully dismisss
578          * non-secure keyguards.  This flag only applies to the top-most
579          * full-screen window.
580          */
581         public static final int FLAG_SHOW_WHEN_LOCKED = 0x00080000;
582 
583         /** Window flag: ask that the system wallpaper be shown behind
584          * your window.  The window surface must be translucent to be able
585          * to actually see the wallpaper behind it; this flag just ensures
586          * that the wallpaper surface will be there if this window actually
587          * has translucent regions.
588          */
589         public static final int FLAG_SHOW_WALLPAPER = 0x00100000;
590 
591         /** Window flag: when set as a window is being added or made
592          * visible, once the window has been shown then the system will
593          * poke the power manager's user activity (as if the user had woken
594          * up the device) to turn the screen on. */
595         public static final int FLAG_TURN_SCREEN_ON = 0x00200000;
596 
597         /** Window flag: when set the window will cause the keyguard to
598          * be dismissed, only if it is not a secure lock keyguard.  Because such
599          * a keyguard is not needed for security, it will never re-appear if
600          * the user navigates to another window (in contrast to
601          * {@link #FLAG_SHOW_WHEN_LOCKED}, which will only temporarily
602          * hide both secure and non-secure keyguards but ensure they reappear
603          * when the user moves to another UI that doesn't hide them).
604          * If the keyguard is currently active and is secure (requires an
605          * unlock pattern) than the user will still need to confirm it before
606          * seeing this window, unless {@link #FLAG_SHOW_WHEN_LOCKED} has
607          * also been set.
608          */
609         public static final int FLAG_DISMISS_KEYGUARD = 0x00400000;
610 
611         /** Window flag: when set the window will accept for touch events
612          * outside of its bounds to be sent to other windows that also
613          * support split touch.  When this flag is not set, the first pointer
614          * that goes down determines the window to which all subsequent touches
615          * go until all pointers go up.  When this flag is set, each pointer
616          * (not necessarily the first) that goes down determines the window
617          * to which all subsequent touches of that pointer will go until that
618          * pointer goes up thereby enabling touches with multiple pointers
619          * to be split across multiple windows.
620          */
621         public static final int FLAG_SPLIT_TOUCH = 0x00800000;
622 
623         /**
624          * <p>Indicates whether this window should be hardware accelerated.
625          * Requesting hardware acceleration does not guarantee it will happen.</p>
626          *
627          * <p>This flag can be controlled programmatically <em>only</em> to enable
628          * hardware acceleration. To enable hardware acceleration for a given
629          * window programmatically, do the following:</p>
630          *
631          * <pre>
632          * Window w = activity.getWindow(); // in Activity's onCreate() for instance
633          * w.setFlags(WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED,
634          *         WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED);
635          * </pre>
636          *
637          * <p>It is important to remember that this flag <strong>must</strong>
638          * be set before setting the content view of your activity or dialog.</p>
639          *
640          * <p>This flag cannot be used to disable hardware acceleration after it
641          * was enabled in your manifest using
642          * {@link android.R.attr#hardwareAccelerated}. If you need to selectively
643          * and programmatically disable hardware acceleration (for automated testing
644          * for instance), make sure it is turned off in your manifest and enable it
645          * on your activity or dialog when you need it instead, using the method
646          * described above.</p>
647          *
648          * <p>This flag is automatically set by the system if the
649          * {@link android.R.attr#hardwareAccelerated android:hardwareAccelerated}
650          * XML attribute is set to true on an activity or on the application.</p>
651          */
652         public static final int FLAG_HARDWARE_ACCELERATED = 0x01000000;
653 
654         // ----- HIDDEN FLAGS.
655         // These start at the high bit and go down.
656 
657         /** Window flag: Enable touches to slide out of a window into neighboring
658          * windows in mid-gesture instead of being captured for the duration of
659          * the gesture.
660          *
661          * This flag changes the behavior of touch focus for this window only.
662          * Touches can slide out of the window but they cannot necessarily slide
663          * back in (unless the other window with touch focus permits it).
664          *
665          * {@hide}
666          */
667         public static final int FLAG_SLIPPERY = 0x04000000;
668 
669         /**
670          * Flag for a window belonging to an activity that responds to {@link KeyEvent#KEYCODE_MENU}
671          * and therefore needs a Menu key. For devices where Menu is a physical button this flag is
672          * ignored, but on devices where the Menu key is drawn in software it may be hidden unless
673          * this flag is set.
674          *
675          * (Note that Action Bars, when available, are the preferred way to offer additional
676          * functions otherwise accessed via an options menu.)
677          *
678          * {@hide}
679          */
680         public static final int FLAG_NEEDS_MENU_KEY = 0x08000000;
681 
682         /** Window flag: *sigh* The lock screen wants to continue running its
683          * animation while it is fading.  A kind-of hack to allow this.  Maybe
684          * in the future we just make this the default behavior.
685          *
686          * {@hide} */
687         public static final int FLAG_KEEP_SURFACE_WHILE_ANIMATING = 0x10000000;
688 
689         /** Window flag: special flag to limit the size of the window to be
690          * original size ([320x480] x density). Used to create window for applications
691          * running under compatibility mode.
692          *
693          * {@hide} */
694         public static final int FLAG_COMPATIBLE_WINDOW = 0x20000000;
695 
696         /** Window flag: a special option intended for system dialogs.  When
697          * this flag is set, the window will demand focus unconditionally when
698          * it is created.
699          * {@hide} */
700         public static final int FLAG_SYSTEM_ERROR = 0x40000000;
701 
702         /**
703          * Various behavioral options/flags.  Default is none.
704          *
705          * @see #FLAG_ALLOW_LOCK_WHILE_SCREEN_ON
706          * @see #FLAG_DIM_BEHIND
707          * @see #FLAG_NOT_FOCUSABLE
708          * @see #FLAG_NOT_TOUCHABLE
709          * @see #FLAG_NOT_TOUCH_MODAL
710          * @see #FLAG_TOUCHABLE_WHEN_WAKING
711          * @see #FLAG_KEEP_SCREEN_ON
712          * @see #FLAG_LAYOUT_IN_SCREEN
713          * @see #FLAG_LAYOUT_NO_LIMITS
714          * @see #FLAG_FULLSCREEN
715          * @see #FLAG_FORCE_NOT_FULLSCREEN
716          * @see #FLAG_DITHER
717          * @see #FLAG_SECURE
718          * @see #FLAG_SCALED
719          * @see #FLAG_IGNORE_CHEEK_PRESSES
720          * @see #FLAG_LAYOUT_INSET_DECOR
721          * @see #FLAG_ALT_FOCUSABLE_IM
722          * @see #FLAG_WATCH_OUTSIDE_TOUCH
723          * @see #FLAG_SHOW_WHEN_LOCKED
724          * @see #FLAG_SHOW_WALLPAPER
725          * @see #FLAG_TURN_SCREEN_ON
726          * @see #FLAG_DISMISS_KEYGUARD
727          * @see #FLAG_SPLIT_TOUCH
728          * @see #FLAG_HARDWARE_ACCELERATED
729          */
730         @ViewDebug.ExportedProperty(flagMapping = {
731             @ViewDebug.FlagToString(mask = FLAG_ALLOW_LOCK_WHILE_SCREEN_ON, equals = FLAG_ALLOW_LOCK_WHILE_SCREEN_ON,
732                     name = "FLAG_ALLOW_LOCK_WHILE_SCREEN_ON"),
733             @ViewDebug.FlagToString(mask = FLAG_DIM_BEHIND, equals = FLAG_DIM_BEHIND,
734                     name = "FLAG_DIM_BEHIND"),
735             @ViewDebug.FlagToString(mask = FLAG_BLUR_BEHIND, equals = FLAG_BLUR_BEHIND,
736                     name = "FLAG_BLUR_BEHIND"),
737             @ViewDebug.FlagToString(mask = FLAG_NOT_FOCUSABLE, equals = FLAG_NOT_FOCUSABLE,
738                     name = "FLAG_NOT_FOCUSABLE"),
739             @ViewDebug.FlagToString(mask = FLAG_NOT_TOUCHABLE, equals = FLAG_NOT_TOUCHABLE,
740                     name = "FLAG_NOT_TOUCHABLE"),
741             @ViewDebug.FlagToString(mask = FLAG_NOT_TOUCH_MODAL, equals = FLAG_NOT_TOUCH_MODAL,
742                     name = "FLAG_NOT_TOUCH_MODAL"),
743             @ViewDebug.FlagToString(mask = FLAG_TOUCHABLE_WHEN_WAKING, equals = FLAG_TOUCHABLE_WHEN_WAKING,
744                     name = "FLAG_TOUCHABLE_WHEN_WAKING"),
745             @ViewDebug.FlagToString(mask = FLAG_KEEP_SCREEN_ON, equals = FLAG_KEEP_SCREEN_ON,
746                     name = "FLAG_KEEP_SCREEN_ON"),
747             @ViewDebug.FlagToString(mask = FLAG_LAYOUT_IN_SCREEN, equals = FLAG_LAYOUT_IN_SCREEN,
748                     name = "FLAG_LAYOUT_IN_SCREEN"),
749             @ViewDebug.FlagToString(mask = FLAG_LAYOUT_NO_LIMITS, equals = FLAG_LAYOUT_NO_LIMITS,
750                     name = "FLAG_LAYOUT_NO_LIMITS"),
751             @ViewDebug.FlagToString(mask = FLAG_FULLSCREEN, equals = FLAG_FULLSCREEN,
752                     name = "FLAG_FULLSCREEN"),
753             @ViewDebug.FlagToString(mask = FLAG_FORCE_NOT_FULLSCREEN, equals = FLAG_FORCE_NOT_FULLSCREEN,
754                     name = "FLAG_FORCE_NOT_FULLSCREEN"),
755             @ViewDebug.FlagToString(mask = FLAG_DITHER, equals = FLAG_DITHER,
756                     name = "FLAG_DITHER"),
757             @ViewDebug.FlagToString(mask = FLAG_SECURE, equals = FLAG_SECURE,
758                     name = "FLAG_SECURE"),
759             @ViewDebug.FlagToString(mask = FLAG_SCALED, equals = FLAG_SCALED,
760                     name = "FLAG_SCALED"),
761             @ViewDebug.FlagToString(mask = FLAG_IGNORE_CHEEK_PRESSES, equals = FLAG_IGNORE_CHEEK_PRESSES,
762                     name = "FLAG_IGNORE_CHEEK_PRESSES"),
763             @ViewDebug.FlagToString(mask = FLAG_LAYOUT_INSET_DECOR, equals = FLAG_LAYOUT_INSET_DECOR,
764                     name = "FLAG_LAYOUT_INSET_DECOR"),
765             @ViewDebug.FlagToString(mask = FLAG_ALT_FOCUSABLE_IM, equals = FLAG_ALT_FOCUSABLE_IM,
766                     name = "FLAG_ALT_FOCUSABLE_IM"),
767             @ViewDebug.FlagToString(mask = FLAG_WATCH_OUTSIDE_TOUCH, equals = FLAG_WATCH_OUTSIDE_TOUCH,
768                     name = "FLAG_WATCH_OUTSIDE_TOUCH"),
769             @ViewDebug.FlagToString(mask = FLAG_SHOW_WHEN_LOCKED, equals = FLAG_SHOW_WHEN_LOCKED,
770                     name = "FLAG_SHOW_WHEN_LOCKED"),
771             @ViewDebug.FlagToString(mask = FLAG_SHOW_WALLPAPER, equals = FLAG_SHOW_WALLPAPER,
772                     name = "FLAG_SHOW_WALLPAPER"),
773             @ViewDebug.FlagToString(mask = FLAG_TURN_SCREEN_ON, equals = FLAG_TURN_SCREEN_ON,
774                     name = "FLAG_TURN_SCREEN_ON"),
775             @ViewDebug.FlagToString(mask = FLAG_DISMISS_KEYGUARD, equals = FLAG_DISMISS_KEYGUARD,
776                     name = "FLAG_DISMISS_KEYGUARD"),
777             @ViewDebug.FlagToString(mask = FLAG_SPLIT_TOUCH, equals = FLAG_SPLIT_TOUCH,
778                     name = "FLAG_SPLIT_TOUCH"),
779             @ViewDebug.FlagToString(mask = FLAG_HARDWARE_ACCELERATED, equals = FLAG_HARDWARE_ACCELERATED,
780                     name = "FLAG_HARDWARE_ACCELERATED")
781         })
782         public int flags;
783 
784         /**
785          * If the window has requested hardware acceleration, but this is not
786          * allowed in the process it is in, then still render it as if it is
787          * hardware accelerated.  This is used for the starting preview windows
788          * in the system process, which don't need to have the overhead of
789          * hardware acceleration (they are just a static rendering), but should
790          * be rendered as much to match the actual window of the app even if it
791          * is hardware accelerated.
792          * Even if the window isn't hardware accelerated, still do its rendering
793          * as if it is.
794          * Like {@link #FLAG_HARDWARE_ACCELERATED} except for trusted system windows
795          * that need hardware acceleration (e.g. LockScreen), where hardware acceleration
796          * is generally disabled. This flag must be specified in addition to
797          * {@link #FLAG_HARDWARE_ACCELERATED} to enable hardware acceleration for system
798          * windows.
799          *
800          * @hide
801          */
802         public static final int PRIVATE_FLAG_FAKE_HARDWARE_ACCELERATED = 0x00000001;
803 
804         /**
805          * In the system process, we globally do not use hardware acceleration
806          * because there are many threads doing UI there and they an conflict.
807          * If certain parts of the UI that really do want to use hardware
808          * acceleration, this flag can be set to force it.  This is basically
809          * for the lock screen.  Anyone else using it, you are probably wrong.
810          *
811          * @hide
812          */
813         public static final int PRIVATE_FLAG_FORCE_HARDWARE_ACCELERATED = 0x00000002;
814 
815         /**
816          * Control flags that are private to the platform.
817          * @hide
818          */
819         public int privateFlags;
820 
821         /**
822          * Given a particular set of window manager flags, determine whether
823          * such a window may be a target for an input method when it has
824          * focus.  In particular, this checks the
825          * {@link #FLAG_NOT_FOCUSABLE} and {@link #FLAG_ALT_FOCUSABLE_IM}
826          * flags and returns true if the combination of the two corresponds
827          * to a window that needs to be behind the input method so that the
828          * user can type into it.
829          *
830          * @param flags The current window manager flags.
831          *
832          * @return Returns true if such a window should be behind/interact
833          * with an input method, false if not.
834          */
mayUseInputMethod(int flags)835         public static boolean mayUseInputMethod(int flags) {
836             switch (flags&(FLAG_NOT_FOCUSABLE|FLAG_ALT_FOCUSABLE_IM)) {
837                 case 0:
838                 case FLAG_NOT_FOCUSABLE|FLAG_ALT_FOCUSABLE_IM:
839                     return true;
840             }
841             return false;
842         }
843 
844         /**
845          * Mask for {@link #softInputMode} of the bits that determine the
846          * desired visibility state of the soft input area for this window.
847          */
848         public static final int SOFT_INPUT_MASK_STATE = 0x0f;
849 
850         /**
851          * Visibility state for {@link #softInputMode}: no state has been specified.
852          */
853         public static final int SOFT_INPUT_STATE_UNSPECIFIED = 0;
854 
855         /**
856          * Visibility state for {@link #softInputMode}: please don't change the state of
857          * the soft input area.
858          */
859         public static final int SOFT_INPUT_STATE_UNCHANGED = 1;
860 
861         /**
862          * Visibility state for {@link #softInputMode}: please hide any soft input
863          * area when normally appropriate (when the user is navigating
864          * forward to your window).
865          */
866         public static final int SOFT_INPUT_STATE_HIDDEN = 2;
867 
868         /**
869          * Visibility state for {@link #softInputMode}: please always hide any
870          * soft input area when this window receives focus.
871          */
872         public static final int SOFT_INPUT_STATE_ALWAYS_HIDDEN = 3;
873 
874         /**
875          * Visibility state for {@link #softInputMode}: please show the soft
876          * input area when normally appropriate (when the user is navigating
877          * forward to your window).
878          */
879         public static final int SOFT_INPUT_STATE_VISIBLE = 4;
880 
881         /**
882          * Visibility state for {@link #softInputMode}: please always make the
883          * soft input area visible when this window receives input focus.
884          */
885         public static final int SOFT_INPUT_STATE_ALWAYS_VISIBLE = 5;
886 
887         /**
888          * Mask for {@link #softInputMode} of the bits that determine the
889          * way that the window should be adjusted to accommodate the soft
890          * input window.
891          */
892         public static final int SOFT_INPUT_MASK_ADJUST = 0xf0;
893 
894         /** Adjustment option for {@link #softInputMode}: nothing specified.
895          * The system will try to pick one or
896          * the other depending on the contents of the window.
897          */
898         public static final int SOFT_INPUT_ADJUST_UNSPECIFIED = 0x00;
899 
900         /** Adjustment option for {@link #softInputMode}: set to allow the
901          * window to be resized when an input
902          * method is shown, so that its contents are not covered by the input
903          * method.  This can <em>not</em> be combined with
904          * {@link #SOFT_INPUT_ADJUST_PAN}; if
905          * neither of these are set, then the system will try to pick one or
906          * the other depending on the contents of the window.
907          */
908         public static final int SOFT_INPUT_ADJUST_RESIZE = 0x10;
909 
910         /** Adjustment option for {@link #softInputMode}: set to have a window
911          * pan when an input method is
912          * shown, so it doesn't need to deal with resizing but just panned
913          * by the framework to ensure the current input focus is visible.  This
914          * can <em>not</em> be combined with {@link #SOFT_INPUT_ADJUST_RESIZE}; if
915          * neither of these are set, then the system will try to pick one or
916          * the other depending on the contents of the window.
917          */
918         public static final int SOFT_INPUT_ADJUST_PAN = 0x20;
919 
920         /** Adjustment option for {@link #softInputMode}: set to have a window
921          * not adjust for a shown input method.  The window will not be resized,
922          * and it will not be panned to make its focus visible.
923          */
924         public static final int SOFT_INPUT_ADJUST_NOTHING = 0x30;
925 
926         /**
927          * Bit for {@link #softInputMode}: set when the user has navigated
928          * forward to the window.  This is normally set automatically for
929          * you by the system, though you may want to set it in certain cases
930          * when you are displaying a window yourself.  This flag will always
931          * be cleared automatically after the window is displayed.
932          */
933         public static final int SOFT_INPUT_IS_FORWARD_NAVIGATION = 0x100;
934 
935         /**
936          * Desired operating mode for any soft input area.  May be any combination
937          * of:
938          *
939          * <ul>
940          * <li> One of the visibility states
941          * {@link #SOFT_INPUT_STATE_UNSPECIFIED}, {@link #SOFT_INPUT_STATE_UNCHANGED},
942          * {@link #SOFT_INPUT_STATE_HIDDEN}, {@link #SOFT_INPUT_STATE_ALWAYS_VISIBLE}, or
943          * {@link #SOFT_INPUT_STATE_VISIBLE}.
944          * <li> One of the adjustment options
945          * {@link #SOFT_INPUT_ADJUST_UNSPECIFIED},
946          * {@link #SOFT_INPUT_ADJUST_RESIZE}, or
947          * {@link #SOFT_INPUT_ADJUST_PAN}.
948          */
949         public int softInputMode;
950 
951         /**
952          * Placement of window within the screen as per {@link Gravity}.  Both
953          * {@link Gravity#apply(int, int, int, android.graphics.Rect, int, int,
954          * android.graphics.Rect) Gravity.apply} and
955          * {@link Gravity#applyDisplay(int, android.graphics.Rect, android.graphics.Rect)
956          * Gravity.applyDisplay} are used during window layout, with this value
957          * given as the desired gravity.  For example you can specify
958          * {@link Gravity#DISPLAY_CLIP_HORIZONTAL Gravity.DISPLAY_CLIP_HORIZONTAL} and
959          * {@link Gravity#DISPLAY_CLIP_VERTICAL Gravity.DISPLAY_CLIP_VERTICAL} here
960          * to control the behavior of
961          * {@link Gravity#applyDisplay(int, android.graphics.Rect, android.graphics.Rect)
962          * Gravity.applyDisplay}.
963          *
964          * @see Gravity
965          */
966         public int gravity;
967 
968         /**
969          * The horizontal margin, as a percentage of the container's width,
970          * between the container and the widget.  See
971          * {@link Gravity#apply(int, int, int, android.graphics.Rect, int, int,
972          * android.graphics.Rect) Gravity.apply} for how this is used.  This
973          * field is added with {@link #x} to supply the <var>xAdj</var> parameter.
974          */
975         public float horizontalMargin;
976 
977         /**
978          * The vertical margin, as a percentage of the container's height,
979          * between the container and the widget.  See
980          * {@link Gravity#apply(int, int, int, android.graphics.Rect, int, int,
981          * android.graphics.Rect) Gravity.apply} for how this is used.  This
982          * field is added with {@link #y} to supply the <var>yAdj</var> parameter.
983          */
984         public float verticalMargin;
985 
986         /**
987          * The desired bitmap format.  May be one of the constants in
988          * {@link android.graphics.PixelFormat}.  Default is OPAQUE.
989          */
990         public int format;
991 
992         /**
993          * A style resource defining the animations to use for this window.
994          * This must be a system resource; it can not be an application resource
995          * because the window manager does not have access to applications.
996          */
997         public int windowAnimations;
998 
999         /**
1000          * An alpha value to apply to this entire window.
1001          * An alpha of 1.0 means fully opaque and 0.0 means fully transparent
1002          */
1003         public float alpha = 1.0f;
1004 
1005         /**
1006          * When {@link #FLAG_DIM_BEHIND} is set, this is the amount of dimming
1007          * to apply.  Range is from 1.0 for completely opaque to 0.0 for no
1008          * dim.
1009          */
1010         public float dimAmount = 1.0f;
1011 
1012         /**
1013          * Default value for {@link #screenBrightness} and {@link #buttonBrightness}
1014          * indicating that the brightness value is not overridden for this window
1015          * and normal brightness policy should be used.
1016          */
1017         public static final float BRIGHTNESS_OVERRIDE_NONE = -1.0f;
1018 
1019         /**
1020          * Value for {@link #screenBrightness} and {@link #buttonBrightness}
1021          * indicating that the screen or button backlight brightness should be set
1022          * to the lowest value when this window is in front.
1023          */
1024         public static final float BRIGHTNESS_OVERRIDE_OFF = 0.0f;
1025 
1026         /**
1027          * Value for {@link #screenBrightness} and {@link #buttonBrightness}
1028          * indicating that the screen or button backlight brightness should be set
1029          * to the hightest value when this window is in front.
1030          */
1031         public static final float BRIGHTNESS_OVERRIDE_FULL = 1.0f;
1032 
1033         /**
1034          * This can be used to override the user's preferred brightness of
1035          * the screen.  A value of less than 0, the default, means to use the
1036          * preferred screen brightness.  0 to 1 adjusts the brightness from
1037          * dark to full bright.
1038          */
1039         public float screenBrightness = BRIGHTNESS_OVERRIDE_NONE;
1040 
1041         /**
1042          * This can be used to override the standard behavior of the button and
1043          * keyboard backlights.  A value of less than 0, the default, means to
1044          * use the standard backlight behavior.  0 to 1 adjusts the brightness
1045          * from dark to full bright.
1046          */
1047         public float buttonBrightness = BRIGHTNESS_OVERRIDE_NONE;
1048 
1049         /**
1050          * Identifier for this window.  This will usually be filled in for
1051          * you.
1052          */
1053         public IBinder token = null;
1054 
1055         /**
1056          * Name of the package owning this window.
1057          */
1058         public String packageName = null;
1059 
1060         /**
1061          * Specific orientation value for a window.
1062          * May be any of the same values allowed
1063          * for {@link android.content.pm.ActivityInfo#screenOrientation}.
1064          * If not set, a default value of
1065          * {@link android.content.pm.ActivityInfo#SCREEN_ORIENTATION_UNSPECIFIED}
1066          * will be used.
1067          */
1068         public int screenOrientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;
1069 
1070         /**
1071          * Control the visibility of the status bar.
1072          *
1073          * @see View#STATUS_BAR_VISIBLE
1074          * @see View#STATUS_BAR_HIDDEN
1075          */
1076         public int systemUiVisibility;
1077 
1078         /**
1079          * @hide
1080          * The ui visibility as requested by the views in this hierarchy.
1081          * the combined value should be systemUiVisibility | subtreeSystemUiVisibility.
1082          */
1083         public int subtreeSystemUiVisibility;
1084 
1085         /**
1086          * Get callbacks about the system ui visibility changing.
1087          *
1088          * TODO: Maybe there should be a bitfield of optional callbacks that we need.
1089          *
1090          * @hide
1091          */
1092         public boolean hasSystemUiListeners;
1093 
1094         /**
1095          * When this window has focus, disable touch pad pointer gesture processing.
1096          * The window will receive raw position updates from the touch pad instead
1097          * of pointer movements and synthetic touch events.
1098          *
1099          * @hide
1100          */
1101         public static final int INPUT_FEATURE_DISABLE_POINTER_GESTURES = 0x00000001;
1102 
1103         /**
1104          * Does not construct an input channel for this window.  The channel will therefore
1105          * be incapable of receiving input.
1106          *
1107          * @hide
1108          */
1109         public static final int INPUT_FEATURE_NO_INPUT_CHANNEL = 0x00000002;
1110 
1111         /**
1112          * Control special features of the input subsystem.
1113          *
1114          * @see #INPUT_FEATURE_DISABLE_TOUCH_PAD_GESTURES
1115          * @see #INPUT_FEATURE_NO_INPUT_CHANNEL
1116          * @hide
1117          */
1118         public int inputFeatures;
1119 
LayoutParams()1120         public LayoutParams() {
1121             super(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
1122             type = TYPE_APPLICATION;
1123             format = PixelFormat.OPAQUE;
1124         }
1125 
LayoutParams(int _type)1126         public LayoutParams(int _type) {
1127             super(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
1128             type = _type;
1129             format = PixelFormat.OPAQUE;
1130         }
1131 
LayoutParams(int _type, int _flags)1132         public LayoutParams(int _type, int _flags) {
1133             super(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
1134             type = _type;
1135             flags = _flags;
1136             format = PixelFormat.OPAQUE;
1137         }
1138 
LayoutParams(int _type, int _flags, int _format)1139         public LayoutParams(int _type, int _flags, int _format) {
1140             super(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
1141             type = _type;
1142             flags = _flags;
1143             format = _format;
1144         }
1145 
LayoutParams(int w, int h, int _type, int _flags, int _format)1146         public LayoutParams(int w, int h, int _type, int _flags, int _format) {
1147             super(w, h);
1148             type = _type;
1149             flags = _flags;
1150             format = _format;
1151         }
1152 
LayoutParams(int w, int h, int xpos, int ypos, int _type, int _flags, int _format)1153         public LayoutParams(int w, int h, int xpos, int ypos, int _type,
1154                 int _flags, int _format) {
1155             super(w, h);
1156             x = xpos;
1157             y = ypos;
1158             type = _type;
1159             flags = _flags;
1160             format = _format;
1161         }
1162 
setTitle(CharSequence title)1163         public final void setTitle(CharSequence title) {
1164             if (null == title)
1165                 title = "";
1166 
1167             mTitle = TextUtils.stringOrSpannedString(title);
1168         }
1169 
getTitle()1170         public final CharSequence getTitle() {
1171             return mTitle;
1172         }
1173 
describeContents()1174         public int describeContents() {
1175             return 0;
1176         }
1177 
writeToParcel(Parcel out, int parcelableFlags)1178         public void writeToParcel(Parcel out, int parcelableFlags) {
1179             out.writeInt(width);
1180             out.writeInt(height);
1181             out.writeInt(x);
1182             out.writeInt(y);
1183             out.writeInt(type);
1184             out.writeInt(flags);
1185             out.writeInt(privateFlags);
1186             out.writeInt(softInputMode);
1187             out.writeInt(gravity);
1188             out.writeFloat(horizontalMargin);
1189             out.writeFloat(verticalMargin);
1190             out.writeInt(format);
1191             out.writeInt(windowAnimations);
1192             out.writeFloat(alpha);
1193             out.writeFloat(dimAmount);
1194             out.writeFloat(screenBrightness);
1195             out.writeFloat(buttonBrightness);
1196             out.writeStrongBinder(token);
1197             out.writeString(packageName);
1198             TextUtils.writeToParcel(mTitle, out, parcelableFlags);
1199             out.writeInt(screenOrientation);
1200             out.writeInt(systemUiVisibility);
1201             out.writeInt(subtreeSystemUiVisibility);
1202             out.writeInt(hasSystemUiListeners ? 1 : 0);
1203             out.writeInt(inputFeatures);
1204         }
1205 
1206         public static final Parcelable.Creator<LayoutParams> CREATOR
1207                     = new Parcelable.Creator<LayoutParams>() {
1208             public LayoutParams createFromParcel(Parcel in) {
1209                 return new LayoutParams(in);
1210             }
1211 
1212             public LayoutParams[] newArray(int size) {
1213                 return new LayoutParams[size];
1214             }
1215         };
1216 
1217 
LayoutParams(Parcel in)1218         public LayoutParams(Parcel in) {
1219             width = in.readInt();
1220             height = in.readInt();
1221             x = in.readInt();
1222             y = in.readInt();
1223             type = in.readInt();
1224             flags = in.readInt();
1225             privateFlags = in.readInt();
1226             softInputMode = in.readInt();
1227             gravity = in.readInt();
1228             horizontalMargin = in.readFloat();
1229             verticalMargin = in.readFloat();
1230             format = in.readInt();
1231             windowAnimations = in.readInt();
1232             alpha = in.readFloat();
1233             dimAmount = in.readFloat();
1234             screenBrightness = in.readFloat();
1235             buttonBrightness = in.readFloat();
1236             token = in.readStrongBinder();
1237             packageName = in.readString();
1238             mTitle = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(in);
1239             screenOrientation = in.readInt();
1240             systemUiVisibility = in.readInt();
1241             subtreeSystemUiVisibility = in.readInt();
1242             hasSystemUiListeners = in.readInt() != 0;
1243             inputFeatures = in.readInt();
1244         }
1245 
1246         @SuppressWarnings({"PointlessBitwiseExpression"})
1247         public static final int LAYOUT_CHANGED = 1<<0;
1248         public static final int TYPE_CHANGED = 1<<1;
1249         public static final int FLAGS_CHANGED = 1<<2;
1250         public static final int FORMAT_CHANGED = 1<<3;
1251         public static final int ANIMATION_CHANGED = 1<<4;
1252         public static final int DIM_AMOUNT_CHANGED = 1<<5;
1253         public static final int TITLE_CHANGED = 1<<6;
1254         public static final int ALPHA_CHANGED = 1<<7;
1255         public static final int MEMORY_TYPE_CHANGED = 1<<8;
1256         public static final int SOFT_INPUT_MODE_CHANGED = 1<<9;
1257         public static final int SCREEN_ORIENTATION_CHANGED = 1<<10;
1258         public static final int SCREEN_BRIGHTNESS_CHANGED = 1<<11;
1259         /** {@hide} */
1260         public static final int BUTTON_BRIGHTNESS_CHANGED = 1<<12;
1261         /** {@hide} */
1262         public static final int SYSTEM_UI_VISIBILITY_CHANGED = 1<<13;
1263         /** {@hide} */
1264         public static final int SYSTEM_UI_LISTENER_CHANGED = 1<<14;
1265         /** {@hide} */
1266         public static final int INPUT_FEATURES_CHANGED = 1<<15;
1267         /** {@hide} */
1268         public static final int PRIVATE_FLAGS_CHANGED = 1<<16;
1269         /** {@hide} */
1270         public static final int EVERYTHING_CHANGED = 0xffffffff;
1271 
1272         // internal buffer to backup/restore parameters under compatibility mode.
1273         private int[] mCompatibilityParamsBackup = null;
1274 
copyFrom(LayoutParams o)1275         public final int copyFrom(LayoutParams o) {
1276             int changes = 0;
1277 
1278             if (width != o.width) {
1279                 width = o.width;
1280                 changes |= LAYOUT_CHANGED;
1281             }
1282             if (height != o.height) {
1283                 height = o.height;
1284                 changes |= LAYOUT_CHANGED;
1285             }
1286             if (x != o.x) {
1287                 x = o.x;
1288                 changes |= LAYOUT_CHANGED;
1289             }
1290             if (y != o.y) {
1291                 y = o.y;
1292                 changes |= LAYOUT_CHANGED;
1293             }
1294             if (horizontalWeight != o.horizontalWeight) {
1295                 horizontalWeight = o.horizontalWeight;
1296                 changes |= LAYOUT_CHANGED;
1297             }
1298             if (verticalWeight != o.verticalWeight) {
1299                 verticalWeight = o.verticalWeight;
1300                 changes |= LAYOUT_CHANGED;
1301             }
1302             if (horizontalMargin != o.horizontalMargin) {
1303                 horizontalMargin = o.horizontalMargin;
1304                 changes |= LAYOUT_CHANGED;
1305             }
1306             if (verticalMargin != o.verticalMargin) {
1307                 verticalMargin = o.verticalMargin;
1308                 changes |= LAYOUT_CHANGED;
1309             }
1310             if (type != o.type) {
1311                 type = o.type;
1312                 changes |= TYPE_CHANGED;
1313             }
1314             if (flags != o.flags) {
1315                 flags = o.flags;
1316                 changes |= FLAGS_CHANGED;
1317             }
1318             if (privateFlags != o.privateFlags) {
1319                 privateFlags = o.privateFlags;
1320                 changes |= PRIVATE_FLAGS_CHANGED;
1321             }
1322             if (softInputMode != o.softInputMode) {
1323                 softInputMode = o.softInputMode;
1324                 changes |= SOFT_INPUT_MODE_CHANGED;
1325             }
1326             if (gravity != o.gravity) {
1327                 gravity = o.gravity;
1328                 changes |= LAYOUT_CHANGED;
1329             }
1330             if (format != o.format) {
1331                 format = o.format;
1332                 changes |= FORMAT_CHANGED;
1333             }
1334             if (windowAnimations != o.windowAnimations) {
1335                 windowAnimations = o.windowAnimations;
1336                 changes |= ANIMATION_CHANGED;
1337             }
1338             if (token == null) {
1339                 // NOTE: token only copied if the recipient doesn't
1340                 // already have one.
1341                 token = o.token;
1342             }
1343             if (packageName == null) {
1344                 // NOTE: packageName only copied if the recipient doesn't
1345                 // already have one.
1346                 packageName = o.packageName;
1347             }
1348             if (!mTitle.equals(o.mTitle)) {
1349                 mTitle = o.mTitle;
1350                 changes |= TITLE_CHANGED;
1351             }
1352             if (alpha != o.alpha) {
1353                 alpha = o.alpha;
1354                 changes |= ALPHA_CHANGED;
1355             }
1356             if (dimAmount != o.dimAmount) {
1357                 dimAmount = o.dimAmount;
1358                 changes |= DIM_AMOUNT_CHANGED;
1359             }
1360             if (screenBrightness != o.screenBrightness) {
1361                 screenBrightness = o.screenBrightness;
1362                 changes |= SCREEN_BRIGHTNESS_CHANGED;
1363             }
1364             if (buttonBrightness != o.buttonBrightness) {
1365                 buttonBrightness = o.buttonBrightness;
1366                 changes |= BUTTON_BRIGHTNESS_CHANGED;
1367             }
1368 
1369             if (screenOrientation != o.screenOrientation) {
1370                 screenOrientation = o.screenOrientation;
1371                 changes |= SCREEN_ORIENTATION_CHANGED;
1372             }
1373 
1374             if (systemUiVisibility != o.systemUiVisibility
1375                     || subtreeSystemUiVisibility != o.subtreeSystemUiVisibility) {
1376                 systemUiVisibility = o.systemUiVisibility;
1377                 subtreeSystemUiVisibility = o.subtreeSystemUiVisibility;
1378                 changes |= SYSTEM_UI_VISIBILITY_CHANGED;
1379             }
1380 
1381             if (hasSystemUiListeners != o.hasSystemUiListeners) {
1382                 hasSystemUiListeners = o.hasSystemUiListeners;
1383                 changes |= SYSTEM_UI_LISTENER_CHANGED;
1384             }
1385 
1386             if (inputFeatures != o.inputFeatures) {
1387                 inputFeatures = o.inputFeatures;
1388                 changes |= INPUT_FEATURES_CHANGED;
1389             }
1390 
1391             return changes;
1392         }
1393 
1394         @Override
debug(String output)1395         public String debug(String output) {
1396             output += "Contents of " + this + ":";
1397             Log.d("Debug", output);
1398             output = super.debug("");
1399             Log.d("Debug", output);
1400             Log.d("Debug", "");
1401             Log.d("Debug", "WindowManager.LayoutParams={title=" + mTitle + "}");
1402             return "";
1403         }
1404 
1405         @Override
toString()1406         public String toString() {
1407             StringBuilder sb = new StringBuilder(256);
1408             sb.append("WM.LayoutParams{");
1409             sb.append("(");
1410             sb.append(x);
1411             sb.append(',');
1412             sb.append(y);
1413             sb.append(")(");
1414             sb.append((width== MATCH_PARENT ?"fill":(width==WRAP_CONTENT?"wrap":width)));
1415             sb.append('x');
1416             sb.append((height== MATCH_PARENT ?"fill":(height==WRAP_CONTENT?"wrap":height)));
1417             sb.append(")");
1418             if (horizontalMargin != 0) {
1419                 sb.append(" hm=");
1420                 sb.append(horizontalMargin);
1421             }
1422             if (verticalMargin != 0) {
1423                 sb.append(" vm=");
1424                 sb.append(verticalMargin);
1425             }
1426             if (gravity != 0) {
1427                 sb.append(" gr=#");
1428                 sb.append(Integer.toHexString(gravity));
1429             }
1430             if (softInputMode != 0) {
1431                 sb.append(" sim=#");
1432                 sb.append(Integer.toHexString(softInputMode));
1433             }
1434             sb.append(" ty=");
1435             sb.append(type);
1436             sb.append(" fl=#");
1437             sb.append(Integer.toHexString(flags));
1438             if (privateFlags != 0) {
1439                 sb.append(" pfl=0x").append(Integer.toHexString(privateFlags));
1440             }
1441             if (format != PixelFormat.OPAQUE) {
1442                 sb.append(" fmt=");
1443                 sb.append(format);
1444             }
1445             if (windowAnimations != 0) {
1446                 sb.append(" wanim=0x");
1447                 sb.append(Integer.toHexString(windowAnimations));
1448             }
1449             if (screenOrientation != ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED) {
1450                 sb.append(" or=");
1451                 sb.append(screenOrientation);
1452             }
1453             if (alpha != 1.0f) {
1454                 sb.append(" alpha=");
1455                 sb.append(alpha);
1456             }
1457             if (screenBrightness != BRIGHTNESS_OVERRIDE_NONE) {
1458                 sb.append(" sbrt=");
1459                 sb.append(screenBrightness);
1460             }
1461             if (buttonBrightness != BRIGHTNESS_OVERRIDE_NONE) {
1462                 sb.append(" bbrt=");
1463                 sb.append(buttonBrightness);
1464             }
1465             if ((flags & FLAG_COMPATIBLE_WINDOW) != 0) {
1466                 sb.append(" compatible=true");
1467             }
1468             if (systemUiVisibility != 0) {
1469                 sb.append(" sysui=0x");
1470                 sb.append(Integer.toHexString(systemUiVisibility));
1471             }
1472             if (subtreeSystemUiVisibility != 0) {
1473                 sb.append(" vsysui=0x");
1474                 sb.append(Integer.toHexString(subtreeSystemUiVisibility));
1475             }
1476             if (hasSystemUiListeners) {
1477                 sb.append(" sysuil=");
1478                 sb.append(hasSystemUiListeners);
1479             }
1480             if (inputFeatures != 0) {
1481                 sb.append(" if=0x").append(Integer.toHexString(inputFeatures));
1482             }
1483             sb.append('}');
1484             return sb.toString();
1485         }
1486 
1487         /**
1488          * Scale the layout params' coordinates and size.
1489          * @hide
1490          */
scale(float scale)1491         public void scale(float scale) {
1492             x = (int) (x * scale + 0.5f);
1493             y = (int) (y * scale + 0.5f);
1494             if (width > 0) {
1495                 width = (int) (width * scale + 0.5f);
1496             }
1497             if (height > 0) {
1498                 height = (int) (height * scale + 0.5f);
1499             }
1500         }
1501 
1502         /**
1503          * Backup the layout parameters used in compatibility mode.
1504          * @see LayoutParams#restore()
1505          */
backup()1506         void backup() {
1507             int[] backup = mCompatibilityParamsBackup;
1508             if (backup == null) {
1509                 // we backup 4 elements, x, y, width, height
1510                 backup = mCompatibilityParamsBackup = new int[4];
1511             }
1512             backup[0] = x;
1513             backup[1] = y;
1514             backup[2] = width;
1515             backup[3] = height;
1516         }
1517 
1518         /**
1519          * Restore the layout params' coordinates, size and gravity
1520          * @see LayoutParams#backup()
1521          */
restore()1522         void restore() {
1523             int[] backup = mCompatibilityParamsBackup;
1524             if (backup != null) {
1525                 x = backup[0];
1526                 y = backup[1];
1527                 width = backup[2];
1528                 height = backup[3];
1529             }
1530         }
1531 
1532         private CharSequence mTitle = "";
1533     }
1534 }
1535