LayoutParams
open class LayoutParams : ViewGroup.LayoutParams, Parcelable
kotlin.Any | ||
↳ | android.view.ViewGroup.LayoutParams | |
↳ | android.view.WindowManager.LayoutParams |
Summary
Inherited XML attributes | |
---|---|
Constants | |
---|---|
static Int | |
static Int | |
static Float |
Value for |
static Float |
Default value for |
static Float |
Value for |
static Int | |
static Int |
Indicates whether this window wants the HDR conversion is disabled. |
static Int |
Start of window types that represent normal application windows. |
static Int |
Start of types of sub-windows. |
static Int |
Start of system-specific window types. |
static Int | |
static Int |
Window flag: as long as this window is visible to the user, allow the lock screen to activate while the screen is on. |
static Int |
Window flag: when set, inverts the input method focusability of the window. |
static Int |
Window flag: enable blur behind for this window. |
static Int |
Window flag: everything behind this window will be dimmed. |
static Int |
Window flag: when set the window will cause the keyguard to be dismissed, only if it is not a secure lock keyguard. |
static Int |
Window flag: turn on dithering when compositing this window to the screen. |
static Int |
Flag indicating that this Window is responsible for drawing the background for the system bars. |
static Int |
Window flag: override |
static Int |
Window flag: hide all screen decorations (such as the status bar) while this window is displayed. |
static Int |
Indicates whether this window should be hardware accelerated. |
static Int |
Window flag: intended for windows that will often be used when the user is holding the screen against their face, it will aggressively filter the event stream to prevent unintended presses in this situation that may not be desired for a particular window, when such an event stream is detected, the application will receive a CANCEL motion event to indicate this so applications can handle this accordingly by taking no action on the event until the finger is released. |
static Int |
Window flag: as long as this window is visible to the user, keep the device's screen turned on and bright. |
static Int |
Window flag: When requesting layout with an attached window, the attached window may overlap with the screen decorations of the parent window such as the navigation bar. |
static Int |
Window flag: a special option only for use in combination with |
static Int |
Window flag: allow window contents to extend in to the screen's overscan area, if there is one. |
static Int |
Window flag for attached windows: Place the window within the entire screen, ignoring any constraints from the parent window. |
static Int |
Window flag: allow window to extend outside of the screen. |
static Int |
Flag for a window in local focus mode. |
static Int |
Window flag: this window won't ever get key input focus, so the user can not send key or other button events to it. |
static Int |
Window flag: this window can never receive touch events. |
static Int |
Window flag: even when this window is focusable (its |
static Int |
Window flag: a special mode where the layout parameters are used to perform scaling of the surface when it is composited to the screen. |
static Int |
Window flag: treat the content of the window as secure, preventing it from appearing in screenshots or from being viewed on non-secure displays. |
static Int |
Window flag: ask that the system wallpaper be shown behind your window. |
static Int |
Window flag: special flag to let windows be shown when the screen is locked. |
static Int |
Window flag: when set the window will accept for touch events outside of its bounds to be sent to other windows that also support split touch. |
static Int |
Window flag: when set, if the device is asleep when the touch screen is pressed, you will receive this first touch event. |
static Int |
Window flag: request a translucent navigation bar with minimal system-provided background protection. |
static Int |
Window flag: request a translucent status bar with minimal system-provided background protection. |
static Int |
Window flag: when set as a window is being added or made visible, once the window has been shown then the system will poke the power manager's user activity (as if the user had woken up the device) to turn the screen on. |
static Int |
Window flag: if you have set |
static Int | |
static Int |
End of types of application windows. |
static Int |
End of types of sub-windows. |
static Int |
End of types of system windows. |
static Int | |
static Int |
The window is always allowed to extend into the |
static Int |
The window is allowed to extend into the |
static Int |
The window is never allowed to overlap with the DisplayCutout area. |
static Int |
The window is always allowed to extend into the |
static Int | |
static Int | |
static Int | |
static Int | |
static Int | |
static Int | |
static Int |
Value for |
static Int |
Value for |
static Int |
Value for |
static Int |
Value for |
static Int | |
static Int | |
static Int |
Adjustment option for |
static Int |
Adjustment option for |
static Int |
Adjustment option for |
static Int |
Adjustment option for |
static Int |
Bit for |
static Int |
Mask for |
static Int |
Mask for |
static Int | |
static Int |
Visibility state for |
static Int |
Visibility state for |
static Int |
Visibility state for |
static Int |
Visibility state for |
static Int |
Visibility state for |
static Int |
Visibility state for |
static Int | |
static Int |
Window type: Windows that are overlaid only by a connected for interception of user interactions without changing the windows an accessibility service can introspect. |
static Int |
Window type: a normal application window. |
static Int |
Window type: like |
static Int |
Window type: window for showing media (such as video). |
static Int |
Window type: Application overlay windows are displayed above all activity windows (types between |
static Int |
Window type: a panel on top of an application window. |
static Int |
Window type: special application window that is displayed while the application is starting. |
static Int |
Window type: a sub-panel on top of an application window. |
static Int |
Window type: an application window that serves as the "base" window of the overall application; all other application windows will appear on top of it. |
static Int | |
static Int |
Window type: a variation on TYPE_APPLICATION that ensures the window manager will wait for this window to be drawn before the app is shown. |
static Int |
Window type: internal input methods windows, which appear above the normal UI. |
static Int |
Window type: internal input methods dialog windows, which appear above the current input method window. |
static Int |
Window type: dialogs that the keyguard shows In multiuser systems shows on all users' windows. |
static Int |
Window type: phone. |
static Int |
Window type: priority phone UI, which needs to be displayed even if the keyguard is active. |
static Int |
Window type: Window for Presentation on top of private virtual display. |
static Int |
Window type: the search bar. |
static Int |
Window type: the status bar. |
static Int |
Window type: system window, such as low power alert. |
static Int |
Window type: panel that slides out from the status bar In multiuser systems shows on all users' windows. |
static Int |
Window type: internal system error windows, appear on top of everything they can. |
static Int |
Window type: system overlay windows, which need to be displayed on top of everything else. |
static Int |
Window type: transient notifications. |
static Int |
Window type: wallpaper window, placed behind any window that wants to sit on top of the wallpaper. |
Inherited constants | |
---|---|
Public constructors | |
---|---|
LayoutParams(_type: Int) |
|
LayoutParams(_type: Int, _flags: Int) |
|
LayoutParams(_type: Int, _flags: Int, _format: Int) |
|
LayoutParams(in: Parcel!) |
Public methods | |
---|---|
open Boolean |
Returns whether sending touch events to the system wallpaper (which can be provided by a third-party application) is enabled for windows that show wallpaper in background. |
open Boolean | |
Int | |
open String! | |
open Int | |
open Int |
Returns the blur behind radius of the window. |
open Int |
Returns the color mode of the window, one of |
open Float |
Get the desired amount of HDR headroom as set by |
open Int | |
open Int | |
open Boolean |
Get the value whether we should enable touch boost as set by |
CharSequence! |
getTitle() |
open Boolean | |
open Boolean |
Get the value whether frameratepowersavingsbalance is enabled for this Window. |
open Boolean |
Returns whether the HDR conversion is enabled for the window |
open static Boolean |
mayUseInputMethod(flags: Int) Given a particular set of window manager flags, determine whether such a window may be a target for an input method when it has focus. |
open Unit |
setBlurBehindRadius(blurBehindRadius: Int) Blurs the screen behind the window. |
open Unit |
setCanPlayMoveAnimation(enable: Boolean) Set whether animations can be played for position changes on this window. |
open Unit |
setColorMode(colorMode: Int) Set the color mode of the window. |
open Unit |
setDesiredHdrHeadroom(desiredHeadroom: Float) Sets the desired about of HDR headroom to be used when rendering as a ratio of targetHdrPeakBrightnessInNits / targetSdrWhitePointInNits. |
open Unit |
setFitInsetsIgnoringVisibility(ignore: Boolean) Specifies if this window should fit the window insets no matter they are visible or not. |
open Unit |
setFitInsetsSides(sides: Int) Specifies sides of insets that this window should avoid overlapping during layout. |
open Unit |
setFitInsetsTypes(types: Int) Specifies types of insets that this window should avoid overlapping during layout. |
open Unit |
setFrameRateBoostOnTouchEnabled(enabled: Boolean) Set the value whether we should enable Touch Boost |
open Unit |
setFrameRatePowerSavingsBalanced(enabled: Boolean) Set the value whether frameratepowersavingsbalance is enabled for this Window. |
open Unit |
setHdrConversionEnabled(enabled: Boolean) Enables/disables the HDR conversion for the window. |
Unit |
setTitle(title: CharSequence!) |
open Unit |
setWallpaperTouchEventsEnabled(enable: Boolean) Set whether sending touch events to the system wallpaper (which can be provided by a third-party application) should be enabled for windows that show wallpaper in background. |
open String |
toString() |
open Unit |
writeToParcel(out: Parcel, parcelableFlags: Int) |
Inherited functions | |
---|---|
Properties | |
---|---|
static Parcelable.Creator<WindowManager.LayoutParams!> | |
Float |
An alpha value to apply to this entire window. |
Float |
This can be used to override the standard behavior of the button and keyboard backlights. |
Float |
When |
Int |
Various behavioral options/flags. |
Int |
The desired bitmap format. |
Int |
Placement of window within the screen as per |
Float |
The horizontal margin, as a percentage of the container's width, between the container and the widget. |
Float |
Indicates how much of the extra space will be allocated horizontally to the view associated with these LayoutParams. |
Int |
Controls how the window is laid out if there is a |
Int | |
String! |
Name of the package owning this window. |
Boolean |
Indicates whether this window wants the connected display to do minimal post processing on the produced image or video frames. |
Int |
Id of the preferred display mode for the window. |
Float |
The preferred refresh rate for the window. |
Int |
Define the exit and entry animations used on this window when the device is rotated. |
Float |
This can be used to override the user's preferred brightness of the screen. |
Int |
Specific orientation value for a window. |
Int |
Desired operating mode for any soft input area. |
Int |
Control the visibility of the status bar. |
IBinder! |
Identifier for this window. |
Int |
The general type of window. |
Float |
The vertical margin, as a percentage of the container's height, between the container and the widget. |
Float |
Indicates how much of the extra space will be allocated vertically to the view associated with these LayoutParams. |
Int |
A style resource defining the animations to use for this window. |
Int |
X position for this window. |
Int |
Y position for this window. |
Inherited properties | |
---|---|
Constants
BRIGHTNESS_OVERRIDE_FULL
static val BRIGHTNESS_OVERRIDE_FULL: Float
Value for screenBrightness
and buttonBrightness
indicating that the screen or button backlight brightness should be set to the hightest value when this window is in front.
Value: 1.0f
BRIGHTNESS_OVERRIDE_NONE
static val BRIGHTNESS_OVERRIDE_NONE: Float
Default value for screenBrightness
and buttonBrightness
indicating that the brightness value is not overridden for this window and normal brightness policy should be used.
Value: -1.0f
BRIGHTNESS_OVERRIDE_OFF
static val BRIGHTNESS_OVERRIDE_OFF: Float
Value for screenBrightness
and buttonBrightness
indicating that the screen or button backlight brightness should be set to the lowest value when this window is in front.
Value: 0.0f
DISPLAY_FLAG_DISABLE_HDR_CONVERSION
static val DISPLAY_FLAG_DISABLE_HDR_CONVERSION: Int
Indicates whether this window wants the HDR conversion is disabled.
Value: 1
FIRST_APPLICATION_WINDOW
static val FIRST_APPLICATION_WINDOW: Int
Start of window types that represent normal application windows.
Value: 1
FIRST_SUB_WINDOW
static val FIRST_SUB_WINDOW: Int
Start of types of sub-windows. The token
of these windows must be set to the window they are attached to. These types of windows are kept next to their attached window in Z-order, and their coordinate space is relative to their attached window.
Value: 1000
FIRST_SYSTEM_WINDOW
static val FIRST_SYSTEM_WINDOW: Int
Start of system-specific window types. These are not normally created by applications.
Value: 2000
FLAG_ALLOW_LOCK_WHILE_SCREEN_ON
static val FLAG_ALLOW_LOCK_WHILE_SCREEN_ON: Int
Window flag: as long as this window is visible to the user, allow the lock screen to activate while the screen is on. This can be used independently, or in combination with FLAG_KEEP_SCREEN_ON
and/or FLAG_SHOW_WHEN_LOCKED
Value: 1
FLAG_ALT_FOCUSABLE_IM
static val FLAG_ALT_FOCUSABLE_IM: Int
Window flag: when set, inverts the input method focusability of the window. The effect of setting this flag depends on whether FLAG_NOT_FOCUSABLE
is set:
If FLAG_NOT_FOCUSABLE
is not set, i.e. when the window is focusable, setting this flag prevents this window from becoming the target of the input method. Consequently, it will not be able to interact with the input method, and will be layered above the input method (unless there is another input method target above it).
If FLAG_NOT_FOCUSABLE
is set, setting this flag requests for the window to be the input method target even though the window is not focusable. Consequently, it will be layered below the input method. Note: Windows that set FLAG_NOT_FOCUSABLE
cannot interact with the input method, regardless of this flag.
Value: 131072
FLAG_BLUR_BEHIND
static val FLAG_BLUR_BEHIND: Int
Window flag: enable blur behind for this window.
Value: 4
FLAG_DIM_BEHIND
static val FLAG_DIM_BEHIND: Int
Window flag: everything behind this window will be dimmed. Use dimAmount
to control the amount of dim.
Value: 2
FLAG_DISMISS_KEYGUARD
static valFLAG_DISMISS_KEYGUARD: Int
Deprecated: Use FLAG_SHOW_WHEN_LOCKED
or KeyguardManager#requestDismissKeyguard
instead. Since keyguard was dismissed all the time as long as an activity with this flag on its window was focused, keyguard couldn't guard against unintentional touches on the screen, which isn't desired.
Window flag: when set the window will cause the keyguard to be dismissed, only if it is not a secure lock keyguard. Because such a keyguard is not needed for security, it will never re-appear if the user navigates to another window (in contrast to FLAG_SHOW_WHEN_LOCKED
, which will only temporarily hide both secure and non-secure keyguards but ensure they reappear when the user moves to another UI that doesn't hide them). If the keyguard is currently active and is secure (requires an unlock credential) than the user will still need to confirm it before seeing this window, unless FLAG_SHOW_WHEN_LOCKED
has also been set.
Value: 4194304
FLAG_DITHER
static valFLAG_DITHER: Int
Deprecated: This flag is no longer used.
Window flag: turn on dithering when compositing this window to the screen.
Value: 4096
FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS
static val FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS: Int
Flag indicating that this Window is responsible for drawing the background for the system bars. If set, the system bars are drawn with a transparent background and the corresponding areas in this window are filled with the colors specified in Window#getStatusBarColor()
and Window#getNavigationBarColor()
.
Value: -2147483648
FLAG_FORCE_NOT_FULLSCREEN
static valFLAG_FORCE_NOT_FULLSCREEN: Int
Deprecated: This value became API "by accident", and shouldn't be used by 3rd party applications.
Window flag: override FLAG_FULLSCREEN
and force the screen decorations (such as the status bar) to be shown.
Value: 2048
FLAG_FULLSCREEN
static valFLAG_FULLSCREEN: Int
Deprecated: Use WindowInsetsController#hide(int)
with Type#statusBars()
instead.
Window flag: hide all screen decorations (such as the status bar) while this window is displayed. This allows the window to use the entire display space for itself -- the status bar will be hidden when an app window with this flag set is on the top layer. A fullscreen window will ignore a value of SOFT_INPUT_ADJUST_RESIZE
for the window's softInputMode
field; the window will stay fullscreen and will not resize.
This flag can be controlled in your theme through the android.R.attr#windowFullscreen
attribute; this attribute is automatically set for you in the standard fullscreen themes such as android.R.style#Theme_NoTitleBar_Fullscreen
, android.R.style#Theme_Black_NoTitleBar_Fullscreen
, android.R.style#Theme_Light_NoTitleBar_Fullscreen
, android.R.style#Theme_Holo_NoActionBar_Fullscreen
, android.R.style#Theme_Holo_Light_NoActionBar_Fullscreen
, android.R.style#Theme_DeviceDefault_NoActionBar_Fullscreen
, and android.R.style#Theme_DeviceDefault_Light_NoActionBar_Fullscreen
.
Value: 1024
FLAG_HARDWARE_ACCELERATED
static val FLAG_HARDWARE_ACCELERATED: Int
Indicates whether this window should be hardware accelerated. Requesting hardware acceleration does not guarantee it will happen.
This flag can be controlled programmatically only to enable hardware acceleration. To enable hardware acceleration for a given window programmatically, do the following:
Window w = activity.getWindow(); // in Activity's onCreate() for instance w.setFlags(WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED, WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED);
It is important to remember that this flag must be set before setting the content view of your activity or dialog.
This flag cannot be used to disable hardware acceleration after it was enabled in your manifest using android.R.attr#hardwareAccelerated
. If you need to selectively and programmatically disable hardware acceleration (for automated testing for instance), make sure it is turned off in your manifest and enable it on your activity or dialog when you need it instead, using the method described above.
This flag is automatically set by the system if the android:hardwareAccelerated
XML attribute is set to true on an activity or on the application.
Value: 16777216
FLAG_IGNORE_CHEEK_PRESSES
static val FLAG_IGNORE_CHEEK_PRESSES: Int
Window flag: intended for windows that will often be used when the user is holding the screen against their face, it will aggressively filter the event stream to prevent unintended presses in this situation that may not be desired for a particular window, when such an event stream is detected, the application will receive a CANCEL motion event to indicate this so applications can handle this accordingly by taking no action on the event until the finger is released.
Value: 32768
FLAG_KEEP_SCREEN_ON
static val FLAG_KEEP_SCREEN_ON: Int
Window flag: as long as this window is visible to the user, keep the device's screen turned on and bright.
Value: 128
FLAG_LAYOUT_ATTACHED_IN_DECOR
static valFLAG_LAYOUT_ATTACHED_IN_DECOR: Int
Deprecated: Use setFitInsetsTypes(int)
to determine whether the attached window will overlap with system bars.
Window flag: When requesting layout with an attached window, the attached window may overlap with the screen decorations of the parent window such as the navigation bar. By including this flag, the window manager will layout the attached window within the decor frame of the parent window such that it doesn't overlap with screen decorations.
Value: 1073741824
FLAG_LAYOUT_INSET_DECOR
static valFLAG_LAYOUT_INSET_DECOR: Int
Deprecated: Insets will always be delivered to your application.
Window flag: a special option only for use in combination with FLAG_LAYOUT_IN_SCREEN
. When requesting layout in the screen your window may appear on top of or behind screen decorations such as the status bar. By also including this flag, the window manager will report the inset rectangle needed to ensure your content is not covered by screen decorations. This flag is normally set for you by Window as described in Window#setFlags
Value: 65536
FLAG_LAYOUT_IN_OVERSCAN
static valFLAG_LAYOUT_IN_OVERSCAN: Int
Deprecated: Overscan areas aren't set by any Android product anymore as of Android 11.
Window flag: allow window contents to extend in to the screen's overscan area, if there is one. The window should still correctly position its contents to take the overscan area into account.
This flag can be controlled in your theme through the android.R.attr#windowOverscan
attribute; this attribute is automatically set for you in the standard overscan themes such as android.R.style#Theme_Holo_NoActionBar_Overscan
, android.R.style#Theme_Holo_Light_NoActionBar_Overscan
, android.R.style#Theme_DeviceDefault_NoActionBar_Overscan
, and android.R.style#Theme_DeviceDefault_Light_NoActionBar_Overscan
.
When this flag is enabled for a window, its normal content may be obscured to some degree by the overscan region of the display. To ensure key parts of that content are visible to the user, you can use View.setFitsSystemWindows(boolean)
to set the point in the view hierarchy where the appropriate offsets should be applied. (This can be done either by directly calling this function, using the android.R.attr#fitsSystemWindows
attribute in your view hierarchy, or implementing you own View.fitSystemWindows(Rect)
method).
This mechanism for positioning content elements is identical to its equivalent use with layout and View.setSystemUiVisibility(int)
; here is an example layout that will correctly position its UI elements with this overscan flag is set:
Value: 33554432
FLAG_LAYOUT_IN_SCREEN
static val FLAG_LAYOUT_IN_SCREEN: Int
Window flag for attached windows: Place the window within the entire screen, ignoring any constraints from the parent window.
Note: on displays that have a DisplayCutout
, the window may be placed such that it avoids the DisplayCutout
area if necessary according to the layoutInDisplayCutoutMode
.
Value: 256
FLAG_LAYOUT_NO_LIMITS
static val FLAG_LAYOUT_NO_LIMITS: Int
Window flag: allow window to extend outside of the screen.
Value: 512
FLAG_LOCAL_FOCUS_MODE
static val FLAG_LOCAL_FOCUS_MODE: Int
Flag for a window in local focus mode. Window in local focus mode can control focus independent of window manager using Window#setLocalFocus(boolean, boolean)
. Usually window in this mode will not get touch/key events from window manager, but will get events only via local injection using Window#injectInputEvent(InputEvent)
.
Value: 268435456
FLAG_NOT_FOCUSABLE
static val FLAG_NOT_FOCUSABLE: Int
Window flag: this window won't ever get key input focus, so the user can not send key or other button events to it. Those will instead go to whatever focusable window is behind it. This flag will also enable FLAG_NOT_TOUCH_MODAL
whether or not that is explicitly set.
Setting this flag also implies that the window will not need to interact with a soft input method, so it will be Z-ordered and positioned independently of any active input method (typically this means it gets Z-ordered on top of the input method, so it can use the full screen for its content and cover the input method if needed. You can use FLAG_ALT_FOCUSABLE_IM
to modify this behavior.
Value: 8
FLAG_NOT_TOUCHABLE
static val FLAG_NOT_TOUCHABLE: Int
Window flag: this window can never receive touch events.
The intention of this flag is to leave the touch to be handled by some window below this window (in Z order).
Starting from Android Build.VERSION_CODES#S
, for security reasons, touch events that pass through windows containing this flag (ie. are within the bounds of the window) will only be delivered to the touch-consuming window if one (or more) of the items below are true:
- Same UID: This window belongs to the same UID that owns the touch-consuming window.
- Trusted windows: This window is trusted. Trusted windows include (but are not limited to) accessibility windows (
TYPE_ACCESSIBILITY_OVERLAY
), the IME (TYPE_INPUT_METHOD
) and assistant windows (TYPE_VOICE_INTERACTION). Windows of typeTYPE_APPLICATION_OVERLAY
are not trusted, see below. - Invisible windows: This window is
View#GONE
orView#INVISIBLE
. - Fully transparent windows: This window has
LayoutParams#alpha
equal to 0. - One SAW window with enough transparency: This window is of type
TYPE_APPLICATION_OVERLAY
, hasLayoutParams#alpha
below or equal to the maximum obscuring opacity (see below) and it's the only window of typeTYPE_APPLICATION_OVERLAY
from this UID in the touch path. - Multiple SAW windows with enough transparency: The multiple overlapping
TYPE_APPLICATION_OVERLAY
windows in the touch path from this UID have a combined obscuring opacity below or equal to the maximum obscuring opacity. See section Combined obscuring opacity below on how to compute this value.
If none of these cases hold, the touch will not be delivered and a message will be logged to logcat.
Maximum obscuring opacity
This value is 0.8. Apps that want to gather this value from the system rather than hard-coding it might want to use android.hardware.input.InputManager#getMaximumObscuringOpacityForTouch()
.
Combined obscuring opacity
The combined obscuring opacity of a set of windows is obtained by combining the opacity values of all windows in the set using the associative and commutative operation defined as:
opacity({A,B}) = 1 - (1 - opacity(A))*(1 - opacity(B))
where opacity(X)
is the LayoutParams#alpha
of window X. So, for a set of windows {W1, .., Wn}
, the combined obscuring opacity will be:
opacity({W1, .., Wn}) = 1 - (1 - opacity(W1)) * ... * (1 - opacity(Wn))
Value: 16
FLAG_NOT_TOUCH_MODAL
static val FLAG_NOT_TOUCH_MODAL: Int
Window flag: even when this window is focusable (its FLAG_NOT_FOCUSABLE
is not set), allow any pointer events outside of the window to be sent to the windows behind it. Otherwise it will consume all pointer events itself, regardless of whether they are inside of the window.
Value: 32
FLAG_SCALED
static val FLAG_SCALED: Int
Window flag: a special mode where the layout parameters are used to perform scaling of the surface when it is composited to the screen.
Value: 16384
FLAG_SECURE
static val FLAG_SECURE: Int
Window flag: treat the content of the window as secure, preventing it from appearing in screenshots or from being viewed on non-secure displays.
See android.view.View#setContentSensitivity(int)
, a window hosting a sensitive view will be marked as secure during media projection, preventing it from being viewed on non-secure displays and during screen share.
See android.view.Display#FLAG_SECURE
for more details about secure surfaces and secure displays.
Value: 8192
FLAG_SHOW_WALLPAPER
static val FLAG_SHOW_WALLPAPER: Int
Window flag: ask that the system wallpaper be shown behind your window. The window surface must be translucent to be able to actually see the wallpaper behind it; this flag just ensures that the wallpaper surface will be there if this window actually has translucent regions.
This flag can be controlled in your theme through the android.R.attr#windowShowWallpaper
attribute; this attribute is automatically set for you in the standard wallpaper themes such as android.R.style#Theme_Wallpaper
, android.R.style#Theme_Wallpaper_NoTitleBar
, android.R.style#Theme_Wallpaper_NoTitleBar_Fullscreen
, android.R.style#Theme_Holo_Wallpaper
, android.R.style#Theme_Holo_Wallpaper_NoTitleBar
, android.R.style#Theme_DeviceDefault_Wallpaper
, and android.R.style#Theme_DeviceDefault_Wallpaper_NoTitleBar
.
When this flag is set, all touch events sent to this window is also sent to the wallpaper, which is used to interact with live wallpapers. Check LayoutParams#areWallpaperTouchEventsEnabled()
, which is set to true
by default. When showing sensitive information on the window, if you want to disable sending the touch events to the wallpaper, use LayoutParams#setWallpaperTouchEventsEnabled(boolean)
.
Value: 1048576
FLAG_SHOW_WHEN_LOCKED
static valFLAG_SHOW_WHEN_LOCKED: Int
Deprecated: Use android.R.attr#showWhenLocked
or android.app.Activity#setShowWhenLocked(boolean)
instead to prevent an unintentional double life-cycle event.
Window flag: special flag to let windows be shown when the screen is locked. This will let application windows take precedence over key guard or any other lock screens. Can be used with FLAG_KEEP_SCREEN_ON
to turn screen on and display windows directly before showing the key guard window. Can be used with FLAG_DISMISS_KEYGUARD
to automatically fully dismisss non-secure keyguards. This flag only applies to the top-most full-screen window.
Value: 524288
FLAG_SPLIT_TOUCH
static val FLAG_SPLIT_TOUCH: Int
Window flag: when set the window will accept for touch events outside of its bounds to be sent to other windows that also support split touch. When this flag is not set, the first pointer that goes down determines the window to which all subsequent touches go until all pointers go up. When this flag is set, each pointer (not necessarily the first) that goes down determines the window to which all subsequent touches of that pointer will go until that pointer goes up thereby enabling touches with multiple pointers to be split across multiple windows.
Value: 8388608
FLAG_TOUCHABLE_WHEN_WAKING
static valFLAG_TOUCHABLE_WHEN_WAKING: Int
Deprecated: This flag has no effect.
Window flag: when set, if the device is asleep when the touch screen is pressed, you will receive this first touch event. Usually the first touch event is consumed by the system since the user can not see what they are pressing on.
Value: 64
FLAG_TRANSLUCENT_NAVIGATION
static valFLAG_TRANSLUCENT_NAVIGATION: Int
Deprecated: Use Window#setNavigationBarColor(int)
with a half-translucent color instead.
Window flag: request a translucent navigation bar with minimal system-provided background protection.
This flag can be controlled in your theme through the android.R.attr#windowTranslucentNavigation
attribute; this attribute is automatically set for you in the standard translucent decor themes such as android.R.style#Theme_Holo_NoActionBar_TranslucentDecor
, android.R.style#Theme_Holo_Light_NoActionBar_TranslucentDecor
, android.R.style#Theme_DeviceDefault_NoActionBar_TranslucentDecor
, and android.R.style#Theme_DeviceDefault_Light_NoActionBar_TranslucentDecor
.
When this flag is enabled for a window, it automatically sets the system UI visibility flags View#SYSTEM_UI_FLAG_LAYOUT_STABLE
and View#SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
.
Note: For devices that support android.content.pm.PackageManager#FEATURE_AUTOMOTIVE
this flag can be disabled by the car manufacturers.
Value: 134217728
FLAG_TRANSLUCENT_STATUS
static valFLAG_TRANSLUCENT_STATUS: Int
Deprecated: Use Window#setStatusBarColor(int)
with a half-translucent color instead.
Window flag: request a translucent status bar with minimal system-provided background protection.
This flag can be controlled in your theme through the android.R.attr#windowTranslucentStatus
attribute; this attribute is automatically set for you in the standard translucent decor themes such as android.R.style#Theme_Holo_NoActionBar_TranslucentDecor
, android.R.style#Theme_Holo_Light_NoActionBar_TranslucentDecor
, android.R.style#Theme_DeviceDefault_NoActionBar_TranslucentDecor
, and android.R.style#Theme_DeviceDefault_Light_NoActionBar_TranslucentDecor
.
When this flag is enabled for a window, it automatically sets the system UI visibility flags View#SYSTEM_UI_FLAG_LAYOUT_STABLE
and View#SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
.
Note: For devices that support android.content.pm.PackageManager#FEATURE_AUTOMOTIVE
this flag may be ignored.
Value: 67108864
FLAG_TURN_SCREEN_ON
static valFLAG_TURN_SCREEN_ON: Int
Deprecated: Use android.R.attr#turnScreenOn
or android.app.Activity#setTurnScreenOn(boolean)
instead to prevent an unintentional double life-cycle event.
Window flag: when set as a window is being added or made visible, once the window has been shown then the system will poke the power manager's user activity (as if the user had woken up the device) to turn the screen on.
Value: 2097152
FLAG_WATCH_OUTSIDE_TOUCH
static val FLAG_WATCH_OUTSIDE_TOUCH: Int
Window flag: if you have set FLAG_NOT_TOUCH_MODAL
, you can set this flag to receive a single special MotionEvent with the action MotionEvent.ACTION_OUTSIDE
for touches that occur outside of your window. Note that you will not receive the full down/move/up gesture, only the location of the first down as an ACTION_OUTSIDE.
Value: 262144
LAST_APPLICATION_WINDOW
static val LAST_APPLICATION_WINDOW: Int
End of types of application windows.
Value: 99
LAST_SUB_WINDOW
static val LAST_SUB_WINDOW: Int
End of types of sub-windows.
Value: 1999
LAST_SYSTEM_WINDOW
static val LAST_SYSTEM_WINDOW: Int
End of types of system windows.
Value: 2999
LAYOUT_IN_DISPLAY_CUTOUT_MODE_ALWAYS
static val LAYOUT_IN_DISPLAY_CUTOUT_MODE_ALWAYS: Int
The window is always allowed to extend into the DisplayCutout
areas on the all edges of the screen.
The window must make sure that no important content overlaps with the DisplayCutout
.
In this mode, the window extends under cutouts on the all edges of the display in both portrait and landscape, regardless of whether the window is hiding the system bars.
Note: Android might not allow the content view to overlap the system bars in view level. To override this behavior and allow content to be able to extend into the cutout area, call Window#setDecorFitsSystemWindows(boolean)
with false
.
Value: 3
LAYOUT_IN_DISPLAY_CUTOUT_MODE_DEFAULT
static val LAYOUT_IN_DISPLAY_CUTOUT_MODE_DEFAULT: Int
The window is allowed to extend into the DisplayCutout
area, only if the DisplayCutout
is fully contained within a system bar or the DisplayCutout
is not deeper than 16 dp, but this depends on the OEM choice. Otherwise, the window is laid out such that it does not overlap with the DisplayCutout
area.
In practice, this means that if the window did not set FLAG_FULLSCREEN
or View#SYSTEM_UI_FLAG_FULLSCREEN
, it can extend into the cutout area in portrait if the cutout is at the top edge. Similarly for View#SYSTEM_UI_FLAG_HIDE_NAVIGATION
and a cutout at the bottom of the screen. Otherwise (i.e. fullscreen or landscape) it is laid out such that it does not overlap the cutout area.
The usual precautions for not overlapping with the status and navigation bar are sufficient for ensuring that no important content overlaps with the DisplayCutout.
Note: OEMs can have an option to allow the window to always extend into the DisplayCutout
area, no matter the cutout flag set, when the DisplayCutout
is on the different side from system bars, only if the DisplayCutout
overlaps at most 16dp with the windows. In such case, OEMs must provide an opt-in/out affordance for users.
Value: 0
LAYOUT_IN_DISPLAY_CUTOUT_MODE_NEVER
static val LAYOUT_IN_DISPLAY_CUTOUT_MODE_NEVER: Int
The window is never allowed to overlap with the DisplayCutout area.
This should be used with windows that transiently set View#SYSTEM_UI_FLAG_FULLSCREEN
or View#SYSTEM_UI_FLAG_HIDE_NAVIGATION
to avoid a relayout of the window when the respective flag is set or cleared.
Value: 2
LAYOUT_IN_DISPLAY_CUTOUT_MODE_SHORT_EDGES
static val LAYOUT_IN_DISPLAY_CUTOUT_MODE_SHORT_EDGES: Int
The window is always allowed to extend into the DisplayCutout
areas on the short edges of the screen.
The window will never extend into a DisplayCutout
area on the long edges of the screen, unless the DisplayCutout
is not deeper than 16 dp, but this depends on the OEM choice.
Note: OEMs can have an option to allow the window to extend into the DisplayCutout
area on the long edge side, only if the cutout overlaps at most 16dp with the windows. In such case, OEMs must provide an opt-in/out affordance for users.
The window must make sure that no important content overlaps with the DisplayCutout
.
In this mode, the window extends under cutouts on the short edge of the display in both portrait and landscape, regardless of whether the window is hiding the system bars:
A cutout in the corner can be considered to be on different edge in different device rotations. This behavior may vary from device to device. Use this flag is possible to letterbox your app if the display cutout is at corner.
On the other hand, should the cutout be on the long edge of the display, a letterbox will be applied such that the window does not extend into the cutout on either long edge:
Note: Android might not allow the content view to overlap the system bars in view level. To override this behavior and allow content to be able to extend into the cutout area, call Window#setDecorFitsSystemWindows(boolean)
with false
.
Value: 1
MEMORY_TYPE_GPU
static valMEMORY_TYPE_GPU: Int
Deprecated: this is ignored, this value is set automatically when needed.
Value: 2
MEMORY_TYPE_HARDWARE
static valMEMORY_TYPE_HARDWARE: Int
Deprecated: this is ignored, this value is set automatically when needed.
Value: 1
MEMORY_TYPE_NORMAL
static valMEMORY_TYPE_NORMAL: Int
Deprecated: this is ignored, this value is set automatically when needed.
Value: 0
MEMORY_TYPE_PUSH_BUFFERS
static valMEMORY_TYPE_PUSH_BUFFERS: Int
Deprecated: this is ignored, this value is set automatically when needed.
Value: 3
ROTATION_ANIMATION_CHANGED
static val ROTATION_ANIMATION_CHANGED: Int
Value: 4096
ROTATION_ANIMATION_CROSSFADE
static val ROTATION_ANIMATION_CROSSFADE: Int
Value for rotationAnimation
which specifies that this window will fade in or out following a rotation.
Value: 1
ROTATION_ANIMATION_JUMPCUT
static val ROTATION_ANIMATION_JUMPCUT: Int
Value for rotationAnimation
which specifies that this window will immediately disappear or appear following a rotation.
Value: 2
ROTATION_ANIMATION_ROTATE
static val ROTATION_ANIMATION_ROTATE: Int
Value for rotationAnimation
which specifies that this window will visually rotate in or out following a rotation.
Value: 0
ROTATION_ANIMATION_SEAMLESS
static val ROTATION_ANIMATION_SEAMLESS: Int
Value for rotationAnimation
to specify seamless rotation mode. This works like JUMPCUT but will fall back to CROSSFADE if rotation can't be applied without pausing the screen. For example, this is ideal for Camera apps which don't want the viewfinder contents to ever rotate or fade (and rather to be seamless) but also don't want ROTATION_ANIMATION_JUMPCUT during app transition scenarios where seamless rotation can't be applied.
Value: 3
SCREEN_BRIGHTNESS_CHANGED
static val SCREEN_BRIGHTNESS_CHANGED: Int
Value: 2048
SCREEN_ORIENTATION_CHANGED
static val SCREEN_ORIENTATION_CHANGED: Int
Value: 1024
SOFT_INPUT_ADJUST_NOTHING
static val SOFT_INPUT_ADJUST_NOTHING: Int
Adjustment option for softInputMode
: set to have a window not adjust for a shown input method. The window will not be resized, and it will not be panned to make its focus visible.
Value: 48
SOFT_INPUT_ADJUST_PAN
static val SOFT_INPUT_ADJUST_PAN: Int
Adjustment option for softInputMode
: set to have a window pan when an input method is shown, so it doesn't need to deal with resizing but just panned by the framework to ensure the current input focus is visible. This can not be combined with SOFT_INPUT_ADJUST_RESIZE
; if neither of these are set, then the system will try to pick one or the other depending on the contents of the window.
Value: 32
SOFT_INPUT_ADJUST_RESIZE
static valSOFT_INPUT_ADJUST_RESIZE: Int
Deprecated: Call Window#setDecorFitsSystemWindows(boolean)
with false
and install an OnApplyWindowInsetsListener
on your root content view that fits insets of type Type#ime()
.
Adjustment option for softInputMode
: set to allow the window to be resized when an input method is shown, so that its contents are not covered by the input method. This can not be combined with SOFT_INPUT_ADJUST_PAN
; if neither of these are set, then the system will try to pick one or the other depending on the contents of the window. If the window's layout parameter flags include FLAG_FULLSCREEN
, this value for softInputMode
will be ignored; the window will not resize, but will stay fullscreen.
Value: 16
SOFT_INPUT_ADJUST_UNSPECIFIED
static val SOFT_INPUT_ADJUST_UNSPECIFIED: Int
Adjustment option for softInputMode
: nothing specified. The system will try to pick one or the other depending on the contents of the window.
Value: 0
SOFT_INPUT_IS_FORWARD_NAVIGATION
static val SOFT_INPUT_IS_FORWARD_NAVIGATION: Int
Bit for softInputMode
: set when the user has navigated forward to the window. This is normally set automatically for you by the system, though you may want to set it in certain cases when you are displaying a window yourself. This flag will always be cleared automatically after the window is displayed.
Value: 256
SOFT_INPUT_MASK_ADJUST
static val SOFT_INPUT_MASK_ADJUST: Int
Mask for softInputMode
of the bits that determine the way that the window should be adjusted to accommodate the soft input window.
Value: 240
SOFT_INPUT_MASK_STATE
static val SOFT_INPUT_MASK_STATE: Int
Mask for softInputMode
of the bits that determine the desired visibility state of the soft input area for this window.
Value: 15
SOFT_INPUT_STATE_ALWAYS_HIDDEN
static val SOFT_INPUT_STATE_ALWAYS_HIDDEN: Int
Visibility state for softInputMode
: please always hide any soft input area when this window receives focus.
Value: 3
SOFT_INPUT_STATE_ALWAYS_VISIBLE
static val SOFT_INPUT_STATE_ALWAYS_VISIBLE: Int
Visibility state for softInputMode
: please always make the soft input area visible when this window receives input focus.
Applications that target android.os.Build.VERSION_CODES#P
and later, this flag is ignored unless there is a focused view that returns true
from View#onCheckIsTextEditor()
when the window is focused.
Value: 5
SOFT_INPUT_STATE_HIDDEN
static val SOFT_INPUT_STATE_HIDDEN: Int
Visibility state for softInputMode
: please hide any soft input area when normally appropriate (when the user is navigating forward to your window).
Value: 2
SOFT_INPUT_STATE_UNCHANGED
static val SOFT_INPUT_STATE_UNCHANGED: Int
Visibility state for softInputMode
: please don't change the state of the soft input area.
Value: 1
SOFT_INPUT_STATE_UNSPECIFIED
static val SOFT_INPUT_STATE_UNSPECIFIED: Int
Visibility state for softInputMode
: no state has been specified. The system may show or hide the software keyboard for better user experience when the window gains focus.
Value: 0
SOFT_INPUT_STATE_VISIBLE
static val SOFT_INPUT_STATE_VISIBLE: Int
Visibility state for softInputMode
: please show the soft input area when normally appropriate (when the user is navigating forward to your window).
Applications that target android.os.Build.VERSION_CODES#P
and later, this flag is ignored unless there is a focused view that returns true
from View#onCheckIsTextEditor()
when the window is focused.
Value: 4
TYPE_ACCESSIBILITY_OVERLAY
static val TYPE_ACCESSIBILITY_OVERLAY: Int
Window type: Windows that are overlaid only by a connected for interception of user interactions without changing the windows an accessibility service can introspect. In particular, an accessibility service can introspect only windows that a sighted user can interact with which is they can touch these windows or can type into these windows. For example, if there is a full screen accessibility overlay that is touchable, the windows below it will be introspectable by an accessibility service even though they are covered by a touchable window.
Value: 2032
TYPE_APPLICATION
static val TYPE_APPLICATION: Int
Window type: a normal application window. The token
must be an Activity token identifying who the window belongs to. In multiuser systems shows only on the owning user's window.
Value: 2
TYPE_APPLICATION_ATTACHED_DIALOG
static val TYPE_APPLICATION_ATTACHED_DIALOG: Int
Window type: like TYPE_APPLICATION_PANEL
, but layout of the window happens as that of a top-level window, not as a child of its container.
Value: 1003
TYPE_APPLICATION_MEDIA
static val TYPE_APPLICATION_MEDIA: Int
Window type: window for showing media (such as video). These windows are displayed behind their attached window.
Value: 1001
TYPE_APPLICATION_OVERLAY
static val TYPE_APPLICATION_OVERLAY: Int
Window type: Application overlay windows are displayed above all activity windows (types between FIRST_APPLICATION_WINDOW
and LAST_APPLICATION_WINDOW
) but below critical system windows like the status bar or IME.
The system may change the position, size, or visibility of these windows at anytime to reduce visual clutter to the user and also manage resources.
Requires android.Manifest.permission#SYSTEM_ALERT_WINDOW
permission.
The system will adjust the importance of processes with this window type to reduce the chance of the low-memory-killer killing them.
In multi-user systems shows only on the owning user's screen.
Value: 2038
TYPE_APPLICATION_PANEL
static val TYPE_APPLICATION_PANEL: Int
Window type: a panel on top of an application window. These windows appear on top of their attached window.
Value: 1000
TYPE_APPLICATION_STARTING
static val TYPE_APPLICATION_STARTING: Int
Window type: special application window that is displayed while the application is starting. Not for use by applications themselves; this is used by the system to display something until the application can show its own windows. In multiuser systems shows on all users' windows.
Value: 3
TYPE_APPLICATION_SUB_PANEL
static val TYPE_APPLICATION_SUB_PANEL: Int
Window type: a sub-panel on top of an application window. These windows are displayed on top their attached window and any TYPE_APPLICATION_PANEL
panels.
Value: 1002
TYPE_BASE_APPLICATION
static val TYPE_BASE_APPLICATION: Int
Window type: an application window that serves as the "base" window of the overall application; all other application windows will appear on top of it. In multiuser systems shows only on the owning user's window.
Value: 1
TYPE_DRAWN_APPLICATION
static val TYPE_DRAWN_APPLICATION: Int
Window type: a variation on TYPE_APPLICATION that ensures the window manager will wait for this window to be drawn before the app is shown. In multiuser systems shows only on the owning user's window.
Value: 4
TYPE_INPUT_METHOD
static val TYPE_INPUT_METHOD: Int
Window type: internal input methods windows, which appear above the normal UI. Application windows may be resized or panned to keep the input focus visible while this window is displayed. In multiuser systems shows only on the owning user's window.
Value: 2011
TYPE_INPUT_METHOD_DIALOG
static val TYPE_INPUT_METHOD_DIALOG: Int
Window type: internal input methods dialog windows, which appear above the current input method window. In multiuser systems shows only on the owning user's window.
Value: 2012
TYPE_KEYGUARD_DIALOG
static val TYPE_KEYGUARD_DIALOG: Int
Window type: dialogs that the keyguard shows In multiuser systems shows on all users' windows.
Value: 2009
TYPE_PHONE
static valTYPE_PHONE: Int
Deprecated: for non-system apps. Use TYPE_APPLICATION_OVERLAY
instead.
Window type: phone. These are non-application windows providing user interaction with the phone (in particular incoming calls). These windows are normally placed above all applications, but behind the status bar. In multiuser systems shows on all users' windows.
Value: 2002
TYPE_PRIORITY_PHONE
static valTYPE_PRIORITY_PHONE: Int
Deprecated: for non-system apps. Use TYPE_APPLICATION_OVERLAY
instead.
Window type: priority phone UI, which needs to be displayed even if the keyguard is active. These windows must not take input focus, or they will interfere with the keyguard. In multiuser systems shows on all users' windows.
Value: 2007
TYPE_PRIVATE_PRESENTATION
static val TYPE_PRIVATE_PRESENTATION: Int
Window type: Window for Presentation on top of private virtual display.
Value: 2030
TYPE_SEARCH_BAR
static val TYPE_SEARCH_BAR: Int
Window type: the search bar. There can be only one search bar window; it is placed at the top of the screen. In multiuser systems shows on all users' windows.
Value: 2001
TYPE_STATUS_BAR
static val TYPE_STATUS_BAR: Int
Window type: the status bar. There can be only one status bar window; it is placed at the top of the screen, and all other windows are shifted down so they are below it. In multiuser systems shows on all users' windows.
Value: 2000
TYPE_SYSTEM_ALERT
static valTYPE_SYSTEM_ALERT: Int
Deprecated: for non-system apps. Use TYPE_APPLICATION_OVERLAY
instead.
Window type: system window, such as low power alert. These windows are always on top of application windows. In multiuser systems shows only on the owning user's window.
Value: 2003
TYPE_SYSTEM_DIALOG
static val TYPE_SYSTEM_DIALOG: Int
Window type: panel that slides out from the status bar In multiuser systems shows on all users' windows.
Value: 2008
TYPE_SYSTEM_ERROR
static valTYPE_SYSTEM_ERROR: Int
Deprecated: for non-system apps. Use TYPE_APPLICATION_OVERLAY
instead.
Window type: internal system error windows, appear on top of everything they can. In multiuser systems shows only on the owning user's window.
Value: 2010
TYPE_SYSTEM_OVERLAY
static valTYPE_SYSTEM_OVERLAY: Int
Deprecated: for non-system apps. Use TYPE_APPLICATION_OVERLAY
instead.
Window type: system overlay windows, which need to be displayed on top of everything else. These windows must not take input focus, or they will interfere with the keyguard. In multiuser systems shows only on the owning user's window.
Value: 2006
TYPE_TOAST
static valTYPE_TOAST: Int
Deprecated: for non-system apps. Use TYPE_APPLICATION_OVERLAY
instead.
Window type: transient notifications. In multiuser systems shows only on the owning user's window.
Value: 2005
TYPE_WALLPAPER
static val TYPE_WALLPAPER: Int
Window type: wallpaper window, placed behind any window that wants to sit on top of the wallpaper. In multiuser systems shows only on the owning user's window.
Value: 2013
Public constructors
LayoutParams
LayoutParams(
w: Int,
h: Int,
_type: Int,
_flags: Int,
_format: Int)
LayoutParams
LayoutParams(
w: Int,
h: Int,
xpos: Int,
ypos: Int,
_type: Int,
_flags: Int,
_format: Int)
Public methods
areWallpaperTouchEventsEnabled
open fun areWallpaperTouchEventsEnabled(): Boolean
Returns whether sending touch events to the system wallpaper (which can be provided by a third-party application) is enabled for windows that show wallpaper in background. Check android.view.WindowManager.LayoutParams#FLAG_SHOW_WALLPAPER
for more information on showing system wallpaper behind the window.
Return | |
---|---|
Boolean |
whether sending touch events to the system wallpaper is enabled. |
canPlayMoveAnimation
open fun canPlayMoveAnimation(): Boolean
Return | |
---|---|
Boolean |
whether playing an animation during a position change is allowed on this window. This does not guarantee that an animation will be played in all such situations. For example, drag-resizing may move the window but not play an animation. |
describeContents
open fun describeContents(): Int
Return | |
---|---|
Int |
a bitmask indicating the set of special object types marshaled by this Parcelable object instance. Value is either 0 or android.os.Parcelable#CONTENTS_FILE_DESCRIPTOR |
getBlurBehindRadius
open fun getBlurBehindRadius(): Int
Returns the blur behind radius of the window.
See Also
getColorMode
open fun getColorMode(): Int
Returns the color mode of the window, one of ActivityInfo#COLOR_MODE_DEFAULT
, ActivityInfo#COLOR_MODE_WIDE_COLOR_GAMUT
or ActivityInfo#COLOR_MODE_HDR
.
Return | |
---|---|
Int |
Value is android.content.pm.ActivityInfo#COLOR_MODE_DEFAULT , android.content.pm.ActivityInfo#COLOR_MODE_WIDE_COLOR_GAMUT , android.content.pm.ActivityInfo#COLOR_MODE_HDR , or android.content.pm.ActivityInfo.COLOR_MODE_A8 |
See Also
getDesiredHdrHeadroom
open fun getDesiredHdrHeadroom(): Float
Get the desired amount of HDR headroom as set by setDesiredHdrHeadroom(float)
Return | |
---|---|
Float |
The amount of HDR headroom set, or 0 for automatic/default behavior. |
getFitInsetsSides
open fun getFitInsetsSides(): Int
Return | |
---|---|
Int |
the sides that this window is avoiding overlapping. Value is either 0 or a combination of android.view.WindowInsets.Side#LEFT , android.view.WindowInsets.Side#TOP , android.view.WindowInsets.Side#RIGHT , and android.view.WindowInsets.Side#BOTTOM |
getFitInsetsTypes
open fun getFitInsetsTypes(): Int
Return | |
---|---|
Int |
the WindowInsets.Type s that this window is avoiding overlapping. Value is either 0 or a combination of android.view.WindowInsets.Type.STATUS_BARS, android.view.WindowInsets.Type.NAVIGATION_BARS, android.view.WindowInsets.Type.CAPTION_BAR, android.view.WindowInsets.Type.IME, android.view.WindowInsets.Type.WINDOW_DECOR, android.view.WindowInsets.Type.SYSTEM_GESTURES, android.view.WindowInsets.Type.MANDATORY_SYSTEM_GESTURES, android.view.WindowInsets.Type.TAPPABLE_ELEMENT, android.view.WindowInsets.Type.DISPLAY_CUTOUT, and android.view.WindowInsets.Type.SYSTEM_OVERLAYS |
getFrameRateBoostOnTouchEnabled
open fun getFrameRateBoostOnTouchEnabled(): Boolean
Get the value whether we should enable touch boost as set by setFrameRateBoostOnTouchEnabled(boolean)
Return | |
---|---|
Boolean |
A boolean value to indicate whether we should enable touch boost |
isFitInsetsIgnoringVisibility
open fun isFitInsetsIgnoringVisibility(): Boolean
Return | |
---|---|
Boolean |
true if this window fits the window insets no matter they are visible or not. |
isFrameRatePowerSavingsBalanced
open fun isFrameRatePowerSavingsBalanced(): Boolean
Get the value whether frameratepowersavingsbalance is enabled for this Window. This allows device to adjust refresh rate as needed and can be useful for power saving. by setFrameRatePowerSavingsBalanced(boolean)
Return | |
---|---|
Boolean |
Whether we should enable frameratepowersavingsbalance. |
isHdrConversionEnabled
open fun isHdrConversionEnabled(): Boolean
Returns whether the HDR conversion is enabled for the window
mayUseInputMethod
open static fun mayUseInputMethod(flags: Int): Boolean
Given a particular set of window manager flags, determine whether such a window may be a target for an input method when it has focus. In particular, this checks the FLAG_NOT_FOCUSABLE
and FLAG_ALT_FOCUSABLE_IM
flags and returns true if the combination of the two corresponds to a window that can use the input method.
Parameters | |
---|---|
flags |
Int: The current window manager flags. |
Return | |
---|---|
Boolean |
Returns true if a window with the given flags would be able to use the input method, false if not. |
setBlurBehindRadius
open fun setBlurBehindRadius(blurBehindRadius: Int): Unit
Blurs the screen behind the window. The effect is similar to that of dimAmount
, but instead of dimmed, the content behind the window will be blurred (or combined with the dim amount, if such is specified).
The density of the blur is set by the blur radius. The radius defines the size of the neighbouring area, from which pixels will be averaged to form the final color for each pixel. The operation approximates a Gaussian blur. A radius of 0 means no blur. The higher the radius, the denser the blur.
Note the difference with android.view.Window#setBackgroundBlurRadius
, which blurs only within the bounds of the window. Blur behind blurs the whole screen behind the window.
Requires FLAG_BLUR_BEHIND
to be set.
Cross-window blur might not be supported by some devices due to GPU limitations. It can also be disabled at runtime, e.g. during battery saving mode, when multimedia tunneling is used or when minimal post processing is requested. In such situations, no blur will be computed or drawn, resulting in there being no depth separation between the window and the content behind it. To avoid this, the app might want to use more dimAmount
on its window. To listen for cross-window blur enabled/disabled events, use #addCrossWindowBlurEnabledListener.
Parameters | |
---|---|
blurBehindRadius |
Int: The blur radius to use for blur behind in pixels Value is 0 or greater |
setCanPlayMoveAnimation
open fun setCanPlayMoveAnimation(enable: Boolean): Unit
Set whether animations can be played for position changes on this window. If disabled, the window will move to its new position instantly without animating.
setColorMode
open fun setColorMode(colorMode: Int): Unit
Set the color mode of the window. Setting the color mode might override the window's pixel format
.
The color mode must be one of ActivityInfo#COLOR_MODE_DEFAULT
, ActivityInfo#COLOR_MODE_WIDE_COLOR_GAMUT
or ActivityInfo#COLOR_MODE_HDR
.
Parameters | |
---|---|
colorMode |
Int: Value is android.content.pm.ActivityInfo#COLOR_MODE_DEFAULT , android.content.pm.ActivityInfo#COLOR_MODE_WIDE_COLOR_GAMUT , android.content.pm.ActivityInfo#COLOR_MODE_HDR , or android.content.pm.ActivityInfo.COLOR_MODE_A8 |
See Also
setDesiredHdrHeadroom
open fun setDesiredHdrHeadroom(desiredHeadroom: Float): Unit
Sets the desired about of HDR headroom to be used when rendering as a ratio of targetHdrPeakBrightnessInNits / targetSdrWhitePointInNits. Only applies when setColorMode(int)
is ActivityInfo#COLOR_MODE_HDR
Parameters | |
---|---|
desiredHeadroom |
Float: Desired amount of HDR headroom. Must be in the range of 1.0 (SDR) to 10,000.0, or 0.0 to reset to default. Value is between 0.0f and 10000.0f inclusive |
setFitInsetsIgnoringVisibility
open fun setFitInsetsIgnoringVisibility(ignore: Boolean): Unit
Specifies if this window should fit the window insets no matter they are visible or not.
Parameters | |
---|---|
ignore |
Boolean: if true, this window will fit the given types even if they are not visible. |
setFitInsetsSides
open fun setFitInsetsSides(sides: Int): Unit
Specifies sides of insets that this window should avoid overlapping during layout.
Parameters | |
---|---|
sides |
Int: which sides that this window should avoid overlapping with the types specified. The initial value of this object includes all sides. Value is either 0 or a combination of android.view.WindowInsets.Side#LEFT , android.view.WindowInsets.Side#TOP , android.view.WindowInsets.Side#RIGHT , and android.view.WindowInsets.Side#BOTTOM |
setFitInsetsTypes
open fun setFitInsetsTypes(types: Int): Unit
Specifies types of insets that this window should avoid overlapping during layout.
Parameters | |
---|---|
types |
Int: which WindowInsets.Type s of insets that this window should avoid. The initial value of this object includes all system bars. Value is either 0 or a combination of android.view.WindowInsets.Type.STATUS_BARS, android.view.WindowInsets.Type.NAVIGATION_BARS, android.view.WindowInsets.Type.CAPTION_BAR, android.view.WindowInsets.Type.IME, android.view.WindowInsets.Type.WINDOW_DECOR, android.view.WindowInsets.Type.SYSTEM_GESTURES, android.view.WindowInsets.Type.MANDATORY_SYSTEM_GESTURES, android.view.WindowInsets.Type.TAPPABLE_ELEMENT, android.view.WindowInsets.Type.DISPLAY_CUTOUT, and android.view.WindowInsets.Type.SYSTEM_OVERLAYS |
setFrameRateBoostOnTouchEnabled
open fun setFrameRateBoostOnTouchEnabled(enabled: Boolean): Unit
Set the value whether we should enable Touch Boost
Parameters | |
---|---|
enabled |
Boolean: Whether we should enable Touch Boost |
setFrameRatePowerSavingsBalanced
open fun setFrameRatePowerSavingsBalanced(enabled: Boolean): Unit
Set the value whether frameratepowersavingsbalance is enabled for this Window. This allows device to adjust refresh rate as needed and can be useful for power saving.
Parameters | |
---|---|
enabled |
Boolean: Whether we should enable frameratepowersavingsbalance. |
setHdrConversionEnabled
open fun setHdrConversionEnabled(enabled: Boolean): Unit
Enables/disables the HDR conversion for the window. By default, the HDR conversion is enabled for the window.
setWallpaperTouchEventsEnabled
open fun setWallpaperTouchEventsEnabled(enable: Boolean): Unit
Set whether sending touch events to the system wallpaper (which can be provided by a third-party application) should be enabled for windows that show wallpaper in background. By default, this is set to true
. Check android.view.WindowManager.LayoutParams#FLAG_SHOW_WALLPAPER
for more information on showing system wallpaper behind the window.
Parameters | |
---|---|
enable |
Boolean: whether to enable sending touch events to the system wallpaper. |
toString
open fun toString(): String
Return | |
---|---|
String |
a string representation of the object. |
writeToParcel
open fun writeToParcel(
out: Parcel,
parcelableFlags: Int
): Unit
Parameters | |
---|---|
dest |
The Parcel in which the object should be written. This value cannot be null . |
flags |
Additional flags about how the object should be written. May be 0 or PARCELABLE_WRITE_RETURN_VALUE . Value is either 0 or a combination of android.os.Parcelable#PARCELABLE_WRITE_RETURN_VALUE , and android.os.Parcelable.PARCELABLE_ELIDE_DUPLICATES |
Properties
alpha
var alpha: Float
An alpha value to apply to this entire window. An alpha of 1.0 means fully opaque and 0.0 means fully transparent
buttonBrightness
var buttonBrightness: Float
This can be used to override the standard behavior of the button and keyboard backlights. A value of less than 0, the default, means to use the standard backlight behavior. 0 to 1 adjusts the brightness from dark to full bright.
dimAmount
var dimAmount: Float
When FLAG_DIM_BEHIND
is set, this is the amount of dimming to apply. Range is from 1.0 for completely opaque to 0.0 for no dim.
flags
var flags: Int
Various behavioral options/flags. Default is none.
Value is either 0
or a combination of android.view.WindowManager.LayoutParams#FLAG_ALLOW_LOCK_WHILE_SCREEN_ON
, android.view.WindowManager.LayoutParams#FLAG_DIM_BEHIND
, android.view.WindowManager.LayoutParams#FLAG_BLUR_BEHIND
, android.view.WindowManager.LayoutParams#FLAG_NOT_FOCUSABLE
, android.view.WindowManager.LayoutParams#FLAG_NOT_TOUCHABLE
, android.view.WindowManager.LayoutParams#FLAG_NOT_TOUCH_MODAL
, android.view.WindowManager.LayoutParams#FLAG_TOUCHABLE_WHEN_WAKING
, android.view.WindowManager.LayoutParams#FLAG_KEEP_SCREEN_ON
, android.view.WindowManager.LayoutParams#FLAG_LAYOUT_IN_SCREEN
, android.view.WindowManager.LayoutParams#FLAG_LAYOUT_NO_LIMITS
, android.view.WindowManager.LayoutParams#FLAG_FULLSCREEN
, android.view.WindowManager.LayoutParams#FLAG_FORCE_NOT_FULLSCREEN
, android.view.WindowManager.LayoutParams#FLAG_DITHER
, android.view.WindowManager.LayoutParams#FLAG_SECURE
, android.view.WindowManager.LayoutParams#FLAG_SCALED
, android.view.WindowManager.LayoutParams#FLAG_IGNORE_CHEEK_PRESSES
, android.view.WindowManager.LayoutParams#FLAG_LAYOUT_INSET_DECOR
, android.view.WindowManager.LayoutParams#FLAG_ALT_FOCUSABLE_IM
, android.view.WindowManager.LayoutParams#FLAG_WATCH_OUTSIDE_TOUCH
, android.view.WindowManager.LayoutParams#FLAG_SHOW_WHEN_LOCKED
, android.view.WindowManager.LayoutParams#FLAG_SHOW_WALLPAPER
, android.view.WindowManager.LayoutParams#FLAG_TURN_SCREEN_ON
, android.view.WindowManager.LayoutParams#FLAG_DISMISS_KEYGUARD
, android.view.WindowManager.LayoutParams#FLAG_SPLIT_TOUCH
, android.view.WindowManager.LayoutParams#FLAG_HARDWARE_ACCELERATED
, android.view.WindowManager.LayoutParams#FLAG_LAYOUT_IN_OVERSCAN
, android.view.WindowManager.LayoutParams#FLAG_TRANSLUCENT_STATUS
, android.view.WindowManager.LayoutParams#FLAG_TRANSLUCENT_NAVIGATION
, android.view.WindowManager.LayoutParams#FLAG_LOCAL_FOCUS_MODE
, android.view.WindowManager.LayoutParams.FLAG_SLIPPERY, android.view.WindowManager.LayoutParams#FLAG_LAYOUT_ATTACHED_IN_DECOR
, and android.view.WindowManager.LayoutParams#FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS
See Also
#FLAG_ALLOW_LOCK_WHILE_SCREEN_ON
#FLAG_DIM_BEHIND
#FLAG_NOT_FOCUSABLE
#FLAG_NOT_TOUCHABLE
#FLAG_NOT_TOUCH_MODAL
#FLAG_TOUCHABLE_WHEN_WAKING
#FLAG_KEEP_SCREEN_ON
#FLAG_LAYOUT_IN_SCREEN
#FLAG_LAYOUT_NO_LIMITS
#FLAG_FULLSCREEN
#FLAG_FORCE_NOT_FULLSCREEN
#FLAG_SECURE
#FLAG_SCALED
#FLAG_IGNORE_CHEEK_PRESSES
#FLAG_LAYOUT_INSET_DECOR
#FLAG_ALT_FOCUSABLE_IM
#FLAG_WATCH_OUTSIDE_TOUCH
#FLAG_SHOW_WHEN_LOCKED
#FLAG_SHOW_WALLPAPER
#FLAG_TURN_SCREEN_ON
#FLAG_DISMISS_KEYGUARD
#FLAG_SPLIT_TOUCH
#FLAG_HARDWARE_ACCELERATED
#FLAG_LOCAL_FOCUS_MODE
#FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS
format
var format: Int
The desired bitmap format. May be one of the constants in android.graphics.PixelFormat
. The choice of format might be overridden by setColorMode(int)
. Default is OPAQUE.
gravity
var gravity: Int
Placement of window within the screen as per Gravity
. Both Gravity.apply
and Gravity.applyDisplay
are used during window layout, with this value given as the desired gravity. For example you can specify Gravity.DISPLAY_CLIP_HORIZONTAL
and Gravity.DISPLAY_CLIP_VERTICAL
here to control the behavior of Gravity.applyDisplay
.
Value is either 0
or a combination of android.view.Gravity#FILL
, android.view.Gravity#FILL_HORIZONTAL
, android.view.Gravity#FILL_VERTICAL
, android.view.Gravity#START
, android.view.Gravity#END
, android.view.Gravity#LEFT
, android.view.Gravity#RIGHT
, android.view.Gravity#TOP
, android.view.Gravity#BOTTOM
, android.view.Gravity#CENTER
, android.view.Gravity#CENTER_HORIZONTAL
, android.view.Gravity#CENTER_VERTICAL
, android.view.Gravity#DISPLAY_CLIP_HORIZONTAL
, android.view.Gravity#DISPLAY_CLIP_VERTICAL
, android.view.Gravity#CLIP_HORIZONTAL
, android.view.Gravity#CLIP_VERTICAL
, and android.view.Gravity#NO_GRAVITY
See Also
horizontalMargin
var horizontalMargin: Float
The horizontal margin, as a percentage of the container's width, between the container and the widget. See Gravity.apply
for how this is used. This field is added with x
to supply the xAdj parameter.
horizontalWeight
var horizontalWeight: Float
Indicates how much of the extra space will be allocated horizontally to the view associated with these LayoutParams. Specify 0 if the view should not be stretched. Otherwise the extra pixels will be pro-rated among all views whose weight is greater than 0.
layoutInDisplayCutoutMode
var layoutInDisplayCutoutMode: Int
Controls how the window is laid out if there is a DisplayCutout
.
Defaults to LAYOUT_IN_DISPLAY_CUTOUT_MODE_DEFAULT
.
Value is android.view.WindowManager.LayoutParams#LAYOUT_IN_DISPLAY_CUTOUT_MODE_DEFAULT
, android.view.WindowManager.LayoutParams#LAYOUT_IN_DISPLAY_CUTOUT_MODE_SHORT_EDGES
, android.view.WindowManager.LayoutParams#LAYOUT_IN_DISPLAY_CUTOUT_MODE_NEVER
, or android.view.WindowManager.LayoutParams#LAYOUT_IN_DISPLAY_CUTOUT_MODE_ALWAYS
preferMinimalPostProcessing
var preferMinimalPostProcessing: Boolean
Indicates whether this window wants the connected display to do minimal post processing on the produced image or video frames. This will only be requested if the window is visible on the screen.
This setting should be used when low latency has a higher priority than image enhancement processing (e.g. for games or video conferencing).
If the Display sink is connected via HDMI, the device will begin to send infoframes with Auto Low Latency Mode enabled and Game Content Type. This will switch the connected display to a minimal image processing mode (if available), which reduces latency, improving the user experience for gaming or video conferencing applications. For more information, see HDMI 2.1 specification.
If the Display sink has an internal connection or uses some other protocol than HDMI, effects may be similar but implementation-defined.
The ability to switch to a mode with minimal post proessing may be disabled by a user setting in the system settings menu. In that case, this field is ignored and the display will remain in its current mode.
preferredDisplayModeId
var preferredDisplayModeId: Int
Id of the preferred display mode for the window.
This must be one of the supported modes obtained for the display(s) the window is on. A value of 0
means no preference.
preferredRefreshRate
var preferredRefreshRate: Float
The preferred refresh rate for the window.
Before API 34, this must be one of the supported refresh rates obtained for the display(s) the window is on. The selected refresh rate will be applied to the display's default mode.
Starting API 34, this value is not limited to the supported refresh rates obtained from the display(s) for the window: it can be any refresh rate the window intends to run at. Any refresh rate can be provided as the preferred window refresh rate. The OS will select the refresh rate that best matches the preferredRefreshRate
.
Setting this value is the equivalent of calling android.view.Surface#setFrameRate with ( preferred_frame_rate, Surface#FRAME_RATE_COMPATIBILITY_DEFAULT
, Surface#CHANGE_FRAME_RATE_ONLY_IF_SEAMLESS
). This should be used in favor of LayoutParams#preferredDisplayModeId
for applications that want to specify the refresh rate, but do not want to specify a preference for any other displayMode properties (e.g., resolution).
This value is ignored if preferredDisplayModeId
is set.
rotationAnimation
var rotationAnimation: Int
Define the exit and entry animations used on this window when the device is rotated. This only has an affect if the incoming and outgoing topmost opaque windows have the #FLAG_FULLSCREEN bit set and are not covered by other windows. All other situations default to the ROTATION_ANIMATION_ROTATE
behavior.
screenBrightness
var screenBrightness: Float
This can be used to override the user's preferred brightness of the screen. A value of less than 0, the default, means to use the preferred screen brightness. 0 to 1 adjusts the brightness from dark to full bright.
screenOrientation
var screenOrientation: Int
Specific orientation value for a window. May be any of the same values allowed for android.content.pm.ActivityInfo#screenOrientation
. If not set, a default value of android.content.pm.ActivityInfo#SCREEN_ORIENTATION_UNSPECIFIED
will be used.
Value is android.content.pm.ActivityInfo.SCREEN_ORIENTATION_UNSET, android.content.pm.ActivityInfo#SCREEN_ORIENTATION_UNSPECIFIED
, android.content.pm.ActivityInfo#SCREEN_ORIENTATION_LANDSCAPE
, android.content.pm.ActivityInfo#SCREEN_ORIENTATION_PORTRAIT
, android.content.pm.ActivityInfo#SCREEN_ORIENTATION_USER
, android.content.pm.ActivityInfo#SCREEN_ORIENTATION_BEHIND
, android.content.pm.ActivityInfo#SCREEN_ORIENTATION_SENSOR
, android.content.pm.ActivityInfo#SCREEN_ORIENTATION_NOSENSOR
, android.content.pm.ActivityInfo#SCREEN_ORIENTATION_SENSOR_LANDSCAPE
, android.content.pm.ActivityInfo#SCREEN_ORIENTATION_SENSOR_PORTRAIT
, android.content.pm.ActivityInfo#SCREEN_ORIENTATION_REVERSE_LANDSCAPE
, android.content.pm.ActivityInfo#SCREEN_ORIENTATION_REVERSE_PORTRAIT
, android.content.pm.ActivityInfo#SCREEN_ORIENTATION_FULL_SENSOR
, android.content.pm.ActivityInfo#SCREEN_ORIENTATION_USER_LANDSCAPE
, android.content.pm.ActivityInfo#SCREEN_ORIENTATION_USER_PORTRAIT
, android.content.pm.ActivityInfo#SCREEN_ORIENTATION_FULL_USER
, or android.content.pm.ActivityInfo#SCREEN_ORIENTATION_LOCKED
softInputMode
var softInputMode: Int
Desired operating mode for any soft input area. May be any combination of:
- One of the visibility states
SOFT_INPUT_STATE_UNSPECIFIED
,SOFT_INPUT_STATE_UNCHANGED
,SOFT_INPUT_STATE_HIDDEN
,SOFT_INPUT_STATE_ALWAYS_HIDDEN
,SOFT_INPUT_STATE_VISIBLE
, orSOFT_INPUT_STATE_ALWAYS_VISIBLE
. - One of the adjustment options
SOFT_INPUT_ADJUST_UNSPECIFIED
,SOFT_INPUT_ADJUST_RESIZE
,SOFT_INPUT_ADJUST_PAN
, orSOFT_INPUT_ADJUST_NOTHING
.
This flag can be controlled in your theme through the android.R.attr#windowSoftInputMode
attribute.
Value is either
0
or a combination of android.view.WindowManager.LayoutParams#SOFT_INPUT_STATE_UNSPECIFIED
, android.view.WindowManager.LayoutParams#SOFT_INPUT_STATE_UNCHANGED
, android.view.WindowManager.LayoutParams#SOFT_INPUT_STATE_HIDDEN
, android.view.WindowManager.LayoutParams#SOFT_INPUT_STATE_ALWAYS_HIDDEN
, android.view.WindowManager.LayoutParams#SOFT_INPUT_STATE_VISIBLE
, android.view.WindowManager.LayoutParams#SOFT_INPUT_STATE_ALWAYS_VISIBLE
, android.view.WindowManager.LayoutParams#SOFT_INPUT_ADJUST_UNSPECIFIED
, android.view.WindowManager.LayoutParams#SOFT_INPUT_ADJUST_RESIZE
, android.view.WindowManager.LayoutParams#SOFT_INPUT_ADJUST_PAN
, android.view.WindowManager.LayoutParams#SOFT_INPUT_ADJUST_NOTHING
, and android.view.WindowManager.LayoutParams#SOFT_INPUT_IS_FORWARD_NAVIGATION
systemUiVisibility
varsystemUiVisibility: Int
Deprecated: SystemUiVisibility flags are deprecated. Use WindowInsetsController
instead.
Control the visibility of the status bar.
Value is either 0
or a combination of android.view.View#SYSTEM_UI_FLAG_VISIBLE
, android.view.View#SYSTEM_UI_FLAG_LOW_PROFILE
, android.view.View#SYSTEM_UI_FLAG_HIDE_NAVIGATION
, android.view.View#SYSTEM_UI_FLAG_FULLSCREEN
, android.view.View#SYSTEM_UI_FLAG_LIGHT_NAVIGATION_BAR
, android.view.View#SYSTEM_UI_FLAG_LAYOUT_STABLE
, android.view.View#SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
, android.view.View#SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
, android.view.View#SYSTEM_UI_FLAG_IMMERSIVE
, android.view.View#SYSTEM_UI_FLAG_IMMERSIVE_STICKY
, android.view.View#SYSTEM_UI_FLAG_LIGHT_STATUS_BAR
, android.view.View.STATUS_BAR_DISABLE_EXPAND, android.view.View.STATUS_BAR_DISABLE_NOTIFICATION_ICONS, android.view.View.STATUS_BAR_DISABLE_NOTIFICATION_ALERTS, android.view.View.STATUS_BAR_DISABLE_NOTIFICATION_TICKER, android.view.View.STATUS_BAR_DISABLE_SYSTEM_INFO, android.view.View.STATUS_BAR_DISABLE_HOME, android.view.View.STATUS_BAR_DISABLE_BACK, android.view.View.STATUS_BAR_DISABLE_CLOCK, android.view.View.STATUS_BAR_DISABLE_RECENT, and android.view.View.STATUS_BAR_DISABLE_SEARCH
token
var token: IBinder!
Identifier for this window. This will usually be filled in for you.
type
var type: Int
The general type of window. There are three main classes of window types:
- Application windows (ranging from
FIRST_APPLICATION_WINDOW
toLAST_APPLICATION_WINDOW
) are normal top-level application windows. For these types of windows, thetoken
must be set to the token of the activity they are a part of (this will normally be done for you iftoken
is null). - Sub-windows (ranging from
FIRST_SUB_WINDOW
toLAST_SUB_WINDOW
) are associated with another top-level window. For these types of windows, thetoken
must be the token of the window it is attached to. - System windows (ranging from
FIRST_SYSTEM_WINDOW
toLAST_SYSTEM_WINDOW
) are special types of windows for use by the system for specific purposes. They should not normally be used by applications, and a special permission is required to use them.
Value is
android.view.WindowManager.LayoutParams#TYPE_BASE_APPLICATION
, android.view.WindowManager.LayoutParams#TYPE_APPLICATION
, android.view.WindowManager.LayoutParams#TYPE_APPLICATION_STARTING
, android.view.WindowManager.LayoutParams#TYPE_DRAWN_APPLICATION
, android.view.WindowManager.LayoutParams#TYPE_APPLICATION_PANEL
, android.view.WindowManager.LayoutParams#TYPE_APPLICATION_MEDIA
, android.view.WindowManager.LayoutParams#TYPE_APPLICATION_SUB_PANEL
, android.view.WindowManager.LayoutParams#TYPE_APPLICATION_ATTACHED_DIALOG
, android.view.WindowManager.LayoutParams.TYPE_APPLICATION_MEDIA_OVERLAY, android.view.WindowManager.LayoutParams.TYPE_APPLICATION_ABOVE_SUB_PANEL, android.view.WindowManager.LayoutParams#TYPE_STATUS_BAR
, android.view.WindowManager.LayoutParams#TYPE_SEARCH_BAR
, android.view.WindowManager.LayoutParams#TYPE_PHONE
, android.view.WindowManager.LayoutParams#TYPE_SYSTEM_ALERT
, android.view.WindowManager.LayoutParams.TYPE_KEYGUARD, android.view.WindowManager.LayoutParams#TYPE_TOAST
, android.view.WindowManager.LayoutParams#TYPE_SYSTEM_OVERLAY
, android.view.WindowManager.LayoutParams#TYPE_PRIORITY_PHONE
, android.view.WindowManager.LayoutParams#TYPE_SYSTEM_DIALOG
, android.view.WindowManager.LayoutParams#TYPE_KEYGUARD_DIALOG
, android.view.WindowManager.LayoutParams#TYPE_SYSTEM_ERROR
, android.view.WindowManager.LayoutParams#TYPE_INPUT_METHOD
, android.view.WindowManager.LayoutParams#TYPE_INPUT_METHOD_DIALOG
, android.view.WindowManager.LayoutParams#TYPE_WALLPAPER
, android.view.WindowManager.LayoutParams.TYPE_STATUS_BAR_PANEL, android.view.WindowManager.LayoutParams.TYPE_SECURE_SYSTEM_OVERLAY, android.view.WindowManager.LayoutParams.TYPE_DRAG, android.view.WindowManager.LayoutParams.TYPE_STATUS_BAR_SUB_PANEL, android.view.WindowManager.LayoutParams.TYPE_POINTER, android.view.WindowManager.LayoutParams.TYPE_NAVIGATION_BAR, android.view.WindowManager.LayoutParams.TYPE_VOLUME_OVERLAY, android.view.WindowManager.LayoutParams.TYPE_BOOT_PROGRESS, android.view.WindowManager.LayoutParams.TYPE_INPUT_CONSUMER, android.view.WindowManager.LayoutParams.TYPE_NAVIGATION_BAR_PANEL, android.view.WindowManager.LayoutParams.TYPE_DISPLAY_OVERLAY, android.view.WindowManager.LayoutParams.TYPE_MAGNIFICATION_OVERLAY, android.view.WindowManager.LayoutParams#TYPE_PRIVATE_PRESENTATION
, android.view.WindowManager.LayoutParams.TYPE_VOICE_INTERACTION, android.view.WindowManager.LayoutParams#TYPE_ACCESSIBILITY_OVERLAY
, android.view.WindowManager.LayoutParams.TYPE_VOICE_INTERACTION_STARTING, android.view.WindowManager.LayoutParams.TYPE_DOCK_DIVIDER, android.view.WindowManager.LayoutParams.TYPE_QS_DIALOG, android.view.WindowManager.LayoutParams.TYPE_SCREENSHOT, android.view.WindowManager.LayoutParams.TYPE_PRESENTATION, android.view.WindowManager.LayoutParams#TYPE_APPLICATION_OVERLAY
, android.view.WindowManager.LayoutParams.TYPE_ACCESSIBILITY_MAGNIFICATION_OVERLAY, android.view.WindowManager.LayoutParams.TYPE_NOTIFICATION_SHADE, or android.view.WindowManager.LayoutParams.TYPE_STATUS_BAR_ADDITIONAL
See Also
#TYPE_BASE_APPLICATION
#TYPE_APPLICATION
#TYPE_APPLICATION_STARTING
#TYPE_DRAWN_APPLICATION
#TYPE_APPLICATION_PANEL
#TYPE_APPLICATION_MEDIA
#TYPE_APPLICATION_SUB_PANEL
#TYPE_APPLICATION_ATTACHED_DIALOG
#TYPE_STATUS_BAR
#TYPE_SEARCH_BAR
#TYPE_PHONE
#TYPE_SYSTEM_ALERT
#TYPE_TOAST
#TYPE_SYSTEM_OVERLAY
#TYPE_PRIORITY_PHONE
#TYPE_SYSTEM_DIALOG
#TYPE_KEYGUARD_DIALOG
#TYPE_SYSTEM_ERROR
#TYPE_INPUT_METHOD
#TYPE_INPUT_METHOD_DIALOG
verticalMargin
var verticalMargin: Float
The vertical margin, as a percentage of the container's height, between the container and the widget. See Gravity.apply
for how this is used. This field is added with y
to supply the yAdj parameter.
verticalWeight
var verticalWeight: Float
Indicates how much of the extra space will be allocated vertically to the view associated with these LayoutParams. Specify 0 if the view should not be stretched. Otherwise the extra pixels will be pro-rated among all views whose weight is greater than 0.
windowAnimations
var windowAnimations: Int
A style resource defining the animations to use for this window. This must be a system resource; it can not be an application resource because the window manager does not have access to applications.
x
var x: Int
X position for this window. With the default gravity it is ignored. When using Gravity#LEFT
or Gravity#START
or Gravity#RIGHT
or Gravity#END
it provides an offset from the given edge.
y
var y: Int
Y position for this window. With the default gravity it is ignored. When using Gravity#TOP
or Gravity#BOTTOM
it provides an offset from the given edge.