/**@class android.view.Window
@extends java.lang.Object
Abstract base class for a top-level window look and behavior policy. An
instance of this class should be used as the top-level view added to the
window manager. It provides standard UI policies such as a background, title
area, default key processing, etc.
<p>The only existing implementation of this abstract class is
android.view.PhoneWindow, which you should instantiate when needing a
Window.
*/
var Window = {
/**Flag for the "options panel" feature. This is enabled by default. */
FEATURE_OPTIONS_PANEL : "0",
/**Flag for the "no title" feature, turning off the title at the top
of the screen. */
FEATURE_NO_TITLE : "1",
/** Flag for the progress indicator feature.
@deprecated No longer supported starting in API 21.
*/
FEATURE_PROGRESS : "2",
/**Flag for having an icon on the left side of the title bar */
FEATURE_LEFT_ICON : "3",
/**Flag for having an icon on the right side of the title bar */
FEATURE_RIGHT_ICON : "4",
/** Flag for indeterminate progress.
@deprecated No longer supported starting in API 21.
*/
FEATURE_INDETERMINATE_PROGRESS : "5",
/**Flag for the context menu. This is enabled by default. */
FEATURE_CONTEXT_MENU : "6",
/**Flag for custom title. You cannot combine this feature with other title features. */
FEATURE_CUSTOM_TITLE : "7",
/** Flag for enabling the Action Bar.
This is enabled by default for some devices. The Action Bar
replaces the title bar and provides an alternate location
for an on-screen menu button on some devices.
*/
FEATURE_ACTION_BAR : "8",
/** Flag for requesting an Action Bar that overlays window content.
Normally an Action Bar will sit in the space above window content, but if this
feature is requested along with {@link #FEATURE_ACTION_BAR} it will be layered over
the window content itself. This is useful if you would like your app to have more control
over how the Action Bar is displayed, such as letting application content scroll beneath
an Action Bar with a transparent background or otherwise displaying a transparent/translucent
Action Bar over application content.
<p>This mode is especially useful with {@link android.view.View#SYSTEM_UI_FLAG_FULLSCREEN
android.view.View.SYSTEM_UI_FLAG_FULLSCREEN}, which allows you to seamlessly hide the
action bar in conjunction with other screen decorations.
<p>As of {@link android.os.Build.VERSION_CODES#JELLY_BEAN}, when an
ActionBar is in this mode it will adjust the insets provided to
{@link android.view.View#fitSystemWindows(android.graphics.Rect) android.view.View.fitSystemWindows(Rect)}
to include the content covered by the action bar, so you can do layout within
that space.
*/
FEATURE_ACTION_BAR_OVERLAY : "9",
/** Flag for specifying the behavior of action modes when an Action Bar is not present.
If overlay is enabled, the action mode UI will be allowed to cover existing window content.
*/
FEATURE_ACTION_MODE_OVERLAY : "10",
/** Flag for requesting a decoration-free window that is dismissed by swiping from the left.
*/
FEATURE_SWIPE_TO_DISMISS : "11",
/** Flag for requesting that window content changes should be animated using a
TransitionManager.
<p>The TransitionManager is set using
{@link #setTransitionManager(android.transition.TransitionManager)}. If none is set,
a default TransitionManager will be used.</p>
@see #setContentView
*/
FEATURE_CONTENT_TRANSITIONS : "12",
/** Enables Activities to run Activity Transitions either through sending or receiving
ActivityOptions bundle created with
{@link android.app.ActivityOptions#makeSceneTransitionAnimation(android.app.Activity,
android.util.Pair[])} or {@link android.app.ActivityOptions#makeSceneTransitionAnimation(
android.app.Activity, android.view.View, String)}.
*/
FEATURE_ACTIVITY_TRANSITIONS : "13",
/** Max value used as a feature ID
@hide
*/
FEATURE_MAX : "13",
/** Flag for setting the progress bar's visibility to VISIBLE.
@deprecated {@link #FEATURE_PROGRESS} and related methods are no longer
supported starting in API 21.
*/
PROGRESS_VISIBILITY_ON : "-1",
/** Flag for setting the progress bar's visibility to GONE.
@deprecated {@link #FEATURE_PROGRESS} and related methods are no longer
supported starting in API 21.
*/
PROGRESS_VISIBILITY_OFF : "-2",
/** Flag for setting the progress bar's indeterminate mode on.
@deprecated {@link #FEATURE_INDETERMINATE_PROGRESS} and related methods
are no longer supported starting in API 21.
*/
PROGRESS_INDETERMINATE_ON : "-3",
/** Flag for setting the progress bar's indeterminate mode off.
@deprecated {@link #FEATURE_INDETERMINATE_PROGRESS} and related methods
are no longer supported starting in API 21.
*/
PROGRESS_INDETERMINATE_OFF : "-4",
/** Starting value for the (primary) progress.
@deprecated {@link #FEATURE_PROGRESS} and related methods are no longer
supported starting in API 21.
*/
PROGRESS_START : "0",
/** Ending value for the (primary) progress.
@deprecated {@link #FEATURE_PROGRESS} and related methods are no longer
supported starting in API 21.
*/
PROGRESS_END : "10000",
/** Lowest possible value for the secondary progress.
@deprecated {@link #FEATURE_PROGRESS} and related methods are no longer
supported starting in API 21.
*/
PROGRESS_SECONDARY_START : "20000",
/** Highest possible value for the secondary progress.
@deprecated {@link #FEATURE_PROGRESS} and related methods are no longer
supported starting in API 21.
*/
PROGRESS_SECONDARY_END : "30000",
/** The transitionName for the status bar background View when a custom background is used.
@see android.view.Window#setStatusBarColor(int)
*/
STATUS_BAR_BACKGROUND_TRANSITION_NAME : "android:status:background",
/** The transitionName for the navigation bar background View when a custom background is used.
@see android.view.Window#setNavigationBarColor(int)
*/
NAVIGATION_BAR_BACKGROUND_TRANSITION_NAME : "android:navigation:background",
/** The ID that the main layout in the XML layout file should have.
*/
ID_ANDROID_CONTENT : "null",
/** Flag for letting the theme drive the color of the window caption controls. Use with
{@link #setDecorCaptionShade}(int). This is the default value.
*/
DECOR_CAPTION_SHADE_AUTO : "0",
/** Flag for setting light-color controls on the window caption. Use with
{@link #setDecorCaptionShade}(int).
*/
DECOR_CAPTION_SHADE_LIGHT : "1",
/** Flag for setting dark-color controls on the window caption. Use with
{@link #setDecorCaptionShade}(int).
*/
DECOR_CAPTION_SHADE_DARK : "2",
/**Return the Context this window policy is running in, for retrieving
resources and other information.
@return {Object {android.content.Context}} Context The Context that was supplied to the constructor.
*/
getContext : function( ) {},
/**Return the {@link android.R.styleable#Window} attributes from this
window's theme.
*/
getWindowStyle : function( ) {},
/**Set the container for this window. If not set, the DecorWindow
operates as a top-level window; otherwise, it negotiates with the
container to display itself appropriately.
@param {Object {Window}} container The desired containing Window.
*/
setContainer : function( ) {},
/**Return the container for this Window.
@return {Object {android.view.Window}} Window The containing window, or null if this is a
top-level window.
*/
getContainer : function( ) {},
/**
*/
hasChildren : function( ) {},
/**
@hide
*/
destroy : function( ) {},
/**
@hide
*/
isDestroyed : function( ) {},
/**Set the window manager for use by this Window to, for example,
display panels. This is <em>not</em> used for displaying the
Window itself -- that must be done by the client.
@param {Object {WindowManager}} wm The window manager for adding new windows.
*/
setWindowManager : function( ) {},
/**Set the window manager for use by this Window to, for example,
display panels. This is <em>not</em> used for displaying the
Window itself -- that must be done by the client.
@param {Object {WindowManager}} wm The window manager for adding new windows.
*/
setWindowManager : function( ) {},
/**Return the window manager allowing this Window to display its own
windows.
@return {Object {android.view.WindowManager}} WindowManager The ViewManager.
*/
getWindowManager : function( ) {},
/**Set the Callback interface for this window, used to intercept key
events and other dynamic operations in the window.
@param {Object {Window.Callback}} callback The desired Callback interface.
*/
setCallback : function( ) {},
/**Return the current Callback interface for this window.
*/
getCallback : function( ) {},
/**Set an observer to collect frame stats for each frame rendered in this window.
Must be in hardware rendering mode.
*/
addOnFrameMetricsAvailableListener : function( ) {},
/**Remove observer and stop listening to frame stats for this window.
*/
removeOnFrameMetricsAvailableListener : function( ) {},
/**
@hide
*/
setOnWindowDismissedCallback : function( ) {},
/**
@hide
*/
dispatchOnWindowDismissed : function( ) {},
/**
@hide
*/
setOnWindowSwipeDismissedCallback : function( ) {},
/**
@hide
*/
dispatchOnWindowSwipeDismissed : function( ) {},
/**
@hide
*/
setWindowControllerCallback : function( ) {},
/**
@hide
*/
getWindowControllerCallback : function( ) {},
/**Set a callback for changes of area where caption will draw its content.
@param {Object {Window.OnRestrictedCaptionAreaChangedListener}} listener Callback that will be called when the area changes.
*/
setRestrictedCaptionAreaListener : function( ) {},
/**Take ownership of this window's surface. The window's view hierarchy
will no longer draw into the surface, though it will otherwise continue
to operate (such as for receiving input events). The given SurfaceHolder
callback will be used to tell you about state changes to the surface.
*/
takeSurface : function( ) {},
/**Take ownership of this window's InputQueue. The window will no
longer read and dispatch input events from the queue; it is your
responsibility to do so.
*/
takeInputQueue : function( ) {},
/**Return whether this window is being displayed with a floating style
(based on the {@link android.R.attr#windowIsFloating} attribute in
the style/theme).
@return {Boolean} Returns true if the window is configured to be displayed floating
on top of whatever is behind it.
*/
isFloating : function( ) {},
/**Set the width and height layout parameters of the window. The default
for both of these is MATCH_PARENT; you can change them to WRAP_CONTENT
or an absolute value to make a window that is not full-screen.
@param {Number} width The desired layout width of the window.
@param {Number} height The desired layout height of the window.
@see ViewGroup.LayoutParams#height
@see ViewGroup.LayoutParams#width
*/
setLayout : function( ) {},
/**Set the gravity of the window, as per the Gravity constants. This
controls how the window manager is positioned in the overall window; it
is only useful when using WRAP_CONTENT for the layout width or height.
@param {Number} gravity The desired gravity constant.
@see Gravity
@see #setLayout
*/
setGravity : function( ) {},
/**Set the type of the window, as per the WindowManager.LayoutParams
types.
@param {Number} type The new window type (see WindowManager.LayoutParams).
*/
setType : function( ) {},
/**Set the format of window, as per the PixelFormat types. This overrides
the default format that is selected by the Window based on its
window decorations.
@param {Number} format The new window format (see PixelFormat). Use
PixelFormat.UNKNOWN to allow the Window to select
the format.
@see PixelFormat
*/
setFormat : function( ) {},
/**Specify custom animations to use for the window, as per
{@link android.view.WindowManager.LayoutParams#windowAnimations
android.view.WindowManager.LayoutParams.windowAnimations}. Providing anything besides
0 here will override the animations the window would
normally retrieve from its theme.
*/
setWindowAnimations : function( ) {},
/**Specify an explicit soft input mode to use for the window, as per
{@link android.view.WindowManager.LayoutParams#softInputMode
android.view.WindowManager.LayoutParams.softInputMode}. Providing anything besides
"unspecified" here will override the input mode the window would
normally retrieve from its theme.
*/
setSoftInputMode : function( ) {},
/**Convenience function to set the flag bits as specified in flags, as
per {@link #setFlags}.
@param {Number} flags The flag bits to be set.
@see #setFlags
@see #clearFlags
*/
addFlags : function( ) {},
/**Add private flag bits.
<p>Refer to the individual flags for the permissions needed.
@param {Number} flags The flag bits to add.
@hide
*/
addPrivateFlags : function( ) {},
/**Add system flag bits.
<p>Refer to the individual flags for the permissions needed.
<p>Note: Only for updateable system components (aka. mainline modules)
@param {Number} flags The flag bits to add.
@hide
*/
addSystemFlags : function( ) {},
/**Convenience function to clear the flag bits as specified in flags, as
per {@link #setFlags}.
@param {Number} flags The flag bits to be cleared.
@see #setFlags
@see #addFlags
*/
clearFlags : function( ) {},
/**Set the flags of the window, as per the
{@link android.view.WindowManager.LayoutParams android.view.WindowManager.LayoutParams}
flags.
<p>Note that some flags must be set before the window decoration is
created (by the first call to
{@link #setContentView(View, android.view.ViewGroup.LayoutParams)} or
{@link #getDecorView}():
{@link android.view.WindowManager.LayoutParams#FLAG_LAYOUT_IN_SCREEN} and
{@link android.view.WindowManager.LayoutParams#FLAG_LAYOUT_INSET_DECOR}. These
will be set for you based on the {@link android.R.attr#windowIsFloating}
attribute.
@param {Number} flags The new window flags (see WindowManager.LayoutParams).
@param {Number} mask Which of the window flag bits to modify.
@see #addFlags
@see #clearFlags
*/
setFlags : function( ) {},
/**<p>Sets the requested color mode of the window. The requested the color mode might
override the window's pixel {@link android.view.WindowManager.LayoutParams#format format}.</p>
<p>The requested color mode must be one of {@link ActivityInfo#COLOR_MODE_DEFAULT},
{@link ActivityInfo#COLOR_MODE_WIDE_COLOR_GAMUT} or {@link ActivityInfo#COLOR_MODE_HDR}.</p>
<p>The requested color mode is not guaranteed to be honored. Please refer to
{@link #getColorMode}() for more information.</p>
@see #getColorMode()
@see Display#isWideColorGamut()
@see Configuration#isScreenWideColorGamut()
*/
setColorMode : function( ) {},
/**Returns the requested color mode of the window, one of
{@link ActivityInfo#COLOR_MODE_DEFAULT}, {@link ActivityInfo#COLOR_MODE_WIDE_COLOR_GAMUT}
or {@link ActivityInfo#COLOR_MODE_HDR}. If {@link ActivityInfo#COLOR_MODE_WIDE_COLOR_GAMUT}
was requested it is possible the window will not be put in wide color gamut mode depending
on device and display support for that mode. Use {@link #isWideColorGamut} to determine
if the window is currently in wide color gamut mode.
@see #setColorMode(int)
@see Display#isWideColorGamut()
@see Configuration#isScreenWideColorGamut()
*/
getColorMode : function( ) {},
/**Returns true if this window's color mode is {@link ActivityInfo#COLOR_MODE_WIDE_COLOR_GAMUT},
the display has a wide color gamut and this device supports wide color gamut rendering.
@see Display#isWideColorGamut()
@see Configuration#isScreenWideColorGamut()
*/
isWideColorGamut : function( ) {},
/**Set the amount of dim behind the window when using
{@link android.view.WindowManager.LayoutParams#FLAG_DIM_BEHIND}. This overrides
the default dim amount of that is selected by the Window based on
its theme.
@param {Number} amount The new dim amount, from 0 for no dim to 1 for full dim.
*/
setDimAmount : function( ) {},
/**Specify custom window attributes. <strong>PLEASE NOTE:</strong> the
layout params you give here should generally be from values previously
retrieved with {@link #getAttributes}(); you probably do not want to
blindly create and apply your own, since this will blow away any values
set by the framework that you are not interested in.
@param {Object {WindowManager.LayoutParams}} a The new window attributes, which will completely override any
current values.
*/
setAttributes : function( ) {},
/**Retrieve the current window attributes associated with this panel.
@return {Object {android.view.WindowManager.LayoutParams}} WindowManager.LayoutParams Either the existing window
attributes object, or a freshly created one if there is none.
*/
getAttributes : function( ) {},
/**
@hide
*/
setCloseOnTouchOutside : function( ) {},
/**
@hide
*/
setCloseOnTouchOutsideIfNotSet : function( ) {},
/**
@hide
*/
alwaysReadCloseOnTouchAttr : function( ) {},
/**
@hide
*/
shouldCloseOnTouch : function( ) {},
/**
*/
setSustainedPerformanceMode : function( ) {},
/**Enable extended screen features. This must be called before
setContentView(). May be called as many times as desired as long as it
is before setContentView(). If not called, no extended features
will be available. You can not turn off a feature once it is requested.
You canot use other title features with {@link #FEATURE_CUSTOM_TITLE}.
@param {Number} featureId The desired features, defined as constants by Window.
@return {Boolean} The features that are now set.
*/
requestFeature : function( ) {},
/**
*/
makeActive : function( ) {},
/**
*/
isActive : function( ) {},
/**Finds a view that was identified by the {@code android:id} XML attribute
that was processed in {@link android.app.Activity#onCreate}.
<p>
This will implicitly call {@link #getDecorView} with all of the associated side-effects.
<p>
<strong>Note:</strong> In most cases -- depending on compiler support --
the resulting view is automatically cast to the target class type. If
the target class type is unconstrained, an explicit cast may be
necessary.
@param {Number} id the ID to search for
@return {Object {android.view.View}} a view with given ID if found, or {@code null} otherwise
@see View#findViewById(int)
@see Window#requireViewById(int)
*/
findViewById : function( ) {},
/**Finds a view that was identified by the {@code android:id} XML attribute
that was processed in {@link android.app.Activity#onCreate}, or throws an
IllegalArgumentException if the ID is invalid, or there is no matching view in the hierarchy.
<p>
<strong>Note:</strong> In most cases -- depending on compiler support --
the resulting view is automatically cast to the target class type. If
the target class type is unconstrained, an explicit cast may be
necessary.
@param {Number} id the ID to search for
@return {Object {android.view.View}} a view with given ID
@see View#requireViewById(int)
@see Window#findViewById(int)
*/
requireViewById : function( ) {},
/**Convenience for
{@link #setContentView(View, android.view.ViewGroup.LayoutParams)}
to set the screen content from a layout resource. The resource will be
inflated, adding all top-level views to the screen.
@param {Number} layoutResID Resource ID to be inflated.
@see #setContentView(View, android.view.ViewGroup.LayoutParams)
*/
setContentView : function( ) {},
/**Convenience for
{@link #setContentView(View, android.view.ViewGroup.LayoutParams)}
set the screen content to an explicit view. This view is placed
directly into the screen's view hierarchy. It can itself be a complex
view hierarhcy.
@param {Object {View}} view The desired content to display.
@see #setContentView(View, android.view.ViewGroup.LayoutParams)
*/
setContentView : function( ) {},
/**Set the screen content to an explicit view. This view is placed
directly into the screen's view hierarchy. It can itself be a complex
view hierarchy.
<p>Note that calling this function "locks in" various characteristics
of the window that can not, from this point forward, be changed: the
features that have been requested with {@link #requestFeature}(int),
and certain window flags as described in {@link #setFlags(int, int)}.</p>
<p>If {@link #FEATURE_CONTENT_TRANSITIONS} is set, the window's
TransitionManager will be used to animate content from the current
content View to view.</p>
@param {Object {View}} view The desired content to display.
@param {Object {ViewGroup.LayoutParams}} params Layout parameters for the view.
@see #getTransitionManager()
@see #setTransitionManager(android.transition.TransitionManager)
*/
setContentView : function( ) {},
/**Variation on
{@link #setContentView(View, android.view.ViewGroup.LayoutParams)}
to add an additional content view to the screen. Added after any existing
ones in the screen -- existing views are NOT removed.
@param {Object {View}} view The desired content to display.
@param {Object {ViewGroup.LayoutParams}} params Layout parameters for the view.
*/
addContentView : function( ) {},
/**Remove the view that was used as the screen content.
@hide
*/
clearContentView : function( ) {},
/**Return the view in this Window that currently has focus, or null if
there are none. Note that this does not look in any containing
Window.
@return {Object {android.view.View}} View The current View with focus or null.
*/
getCurrentFocus : function( ) {},
/**Quick access to the {@link android.view.LayoutInflater} instance that this Window
retrieved from its Context.
@return {Object {android.view.LayoutInflater}} LayoutInflater The shared LayoutInflater.
*/
getLayoutInflater : function( ) {},
/**
*/
setTitle : function( ) {},
/**
*/
setTitleColor : function( ) {},
/**
*/
openPanel : function( ) {},
/**
*/
closePanel : function( ) {},
/**
*/
togglePanel : function( ) {},
/**
*/
invalidatePanelMenu : function( ) {},
/**
*/
performPanelShortcut : function( ) {},
/**
*/
performPanelIdentifierAction : function( ) {},
/**
*/
closeAllPanels : function( ) {},
/**
*/
performContextMenuIdentifierAction : function( ) {},
/**Should be called when the configuration is changed.
@param {Object {Configuration}} newConfig The new configuration.
*/
onConfigurationChanged : function( ) {},
/**Sets the window elevation.
<p>
Changes to this property take effect immediately and will cause the
window surface to be recreated. This is an expensive operation and as a
result, this property should not be animated.
@param {Number} elevation The window elevation.
@see View#setElevation(float)
@see android.R.styleable#Window_windowElevation
*/
setElevation : function( ) {},
/**Gets the window elevation.
@hide
*/
getElevation : function( ) {},
/**Sets whether window content should be clipped to the outline of the
window background.
@param {Boolean} clipToOutline Whether window content should be clipped to the
outline of the window background.
@see View#setClipToOutline(boolean)
@see android.R.styleable#Window_windowClipToOutline
*/
setClipToOutline : function( ) {},
/**Change the background of this window to a Drawable resource. Setting the
background to null will make the window be opaque. To make the window
transparent, you can use an empty drawable (for instance a ColorDrawable
with the color 0 or the system drawable android:drawable/empty.)
@param {Number} resId The resource identifier of a drawable resource which will
be installed as the new background.
*/
setBackgroundDrawableResource : function( ) {},
/**Change the background of this window to a custom Drawable. Setting the
background to null will make the window be opaque. To make the window
transparent, you can use an empty drawable (for instance a ColorDrawable
with the color 0 or the system drawable android:drawable/empty.)
@param {Object {Drawable}} drawable The new Drawable to use for this window's background.
*/
setBackgroundDrawable : function( ) {},
/**Set the value for a drawable feature of this window, from a resource
identifier. You must have called requestFeature(featureId) before
calling this function.
@param {Number} featureId The desired drawable feature to change, defined as a
constant by Window.
@param {Number} resId Resource identifier of the desired image.
@param resId Resource identifier of the desired image.
*/
setFeatureDrawableResource : function( ) {},
/**Set the value for a drawable feature of this window, from a URI. You
must have called requestFeature(featureId) before calling this
function.
<p>The only URI currently supported is "content:", specifying an image
in a content provider.
@param {Number} featureId The desired drawable feature to change. Features are
constants defined by Window.
@param {Object {Uri}} uri The desired URI.
@param uri The desired URI.
*/
setFeatureDrawableUri : function( ) {},
/**Set an explicit Drawable value for feature of this window. You must
have called requestFeature(featureId) before calling this function.
@param {Number} featureId The desired drawable feature to change. Features are
constants defined by Window.
@param {Object {Drawable}} drawable A Drawable object to display.
*/
setFeatureDrawable : function( ) {},
/**Set a custom alpha value for the given drawable feature, controlling how
much the background is visible through it.
@param {Number} featureId The desired drawable feature to change. Features are
constants defined by Window.
@param {Number} alpha The alpha amount, 0 is completely transparent and 255 is
completely opaque.
*/
setFeatureDrawableAlpha : function( ) {},
/**Set the integer value for a feature. The range of the value depends on
the feature being set. For {@link #FEATURE_PROGRESS}, it should go from
0 to 10000. At 10000 the progress is complete and the indicator hidden.
@param {Number} featureId The desired feature to change. Features are constants
defined by Window.
@param {Number} value The value for the feature. The interpretation of this
value is feature-specific.
*/
setFeatureInt : function( ) {},
/**Request that key events come to this activity. Use this if your
activity has no views with focus, but the activity still wants
a chance to process key events.
*/
takeKeyEvents : function( ) {},
/**Used by custom windows, such as Dialog, to pass the key press event
further down the view hierarchy. Application developers should
not need to implement or call this.
*/
superDispatchKeyEvent : function( ) {},
/**Used by custom windows, such as Dialog, to pass the key shortcut press event
further down the view hierarchy. Application developers should
not need to implement or call this.
*/
superDispatchKeyShortcutEvent : function( ) {},
/**Used by custom windows, such as Dialog, to pass the touch screen event
further down the view hierarchy. Application developers should
not need to implement or call this.
*/
superDispatchTouchEvent : function( ) {},
/**Used by custom windows, such as Dialog, to pass the trackball event
further down the view hierarchy. Application developers should
not need to implement or call this.
*/
superDispatchTrackballEvent : function( ) {},
/**Used by custom windows, such as Dialog, to pass the generic motion event
further down the view hierarchy. Application developers should
not need to implement or call this.
*/
superDispatchGenericMotionEvent : function( ) {},
/**Retrieve the top-level window decor view (containing the standard
window frame/decorations and the client's content inside of that), which
can be added as a window to the window manager.
<p><em>Note that calling this function for the first time "locks in"
various window characteristics as described in
{@link #setContentView(View, android.view.ViewGroup.LayoutParams)}.</em></p>
@return {Object {android.view.View}} Returns the top-level window decor view.
*/
getDecorView : function( ) {},
/**Retrieve the current decor view, but only if it has already been created;
otherwise returns null.
@return {Object {android.view.View}} Returns the top-level window decor or null.
@see #getDecorView
*/
peekDecorView : function( ) {},
/**
*/
saveHierarchyState : function( ) {},
/**
*/
restoreHierarchyState : function( ) {},
/**Return the feature bits set by default on a window.
@param {Object {Context}} context The context used to access resources
*/
getDefaultFeatures : function( ) {},
/**Query for the availability of a certain feature.
@param {Number} feature The feature ID to check
@return {Boolean} true if the feature is enabled, false otherwise.
*/
hasFeature : function( ) {},
/**
*/
setChildDrawable : function( ) {},
/**
*/
setChildInt : function( ) {},
/**Is a keypress one of the defined shortcut keys for this window.
@param {Number} keyCode the key code from {@link android.view.KeyEvent} to check.
@param {Object {KeyEvent}} event the {@link android.view.KeyEvent} to use to help check.
*/
isShortcutKey : function( ) {},
/**
@see android.app.Activity#setVolumeControlStream(int)
*/
setVolumeControlStream : function( ) {},
/**
@see android.app.Activity#getVolumeControlStream()
*/
getVolumeControlStream : function( ) {},
/**Sets a {@link MediaController} to send media keys and volume changes to.
If set, this should be preferred for all media keys and volume requests
sent to this window.
@param {Object {MediaController}} controller The controller for the session which should receive
media keys and volume changes.
@see android.app.Activity#setMediaController(android.media.session.MediaController)
*/
setMediaController : function( ) {},
/**Gets the {@link MediaController} that was previously set.
@return {Object {android.media.session.MediaController}} The controller which should receive events.
@see #setMediaController(android.media.session.MediaController)
@see android.app.Activity#getMediaController()
*/
getMediaController : function( ) {},
/**Set extra options that will influence the UI for this window.
@param {Number} uiOptions Flags specifying extra options for this window.
*/
setUiOptions : function( ) {},
/**Set extra options that will influence the UI for this window.
Only the bits filtered by mask will be modified.
@param {Number} uiOptions Flags specifying extra options for this window.
@param {Number} mask Flags specifying which options should be modified. Others will remain unchanged.
*/
setUiOptions : function( ) {},
/**Set the primary icon for this window.
@param {Number} resId resource ID of a drawable to set
*/
setIcon : function( ) {},
/**Set the default icon for this window.
This will be overridden by any other icon set operation which could come from the
theme or another explicit set.
@hide
*/
setDefaultIcon : function( ) {},
/**Set the logo for this window. A logo is often shown in place of an
{@link #setIcon(int) icon} but is generally wider and communicates window title information
as well.
@param {Number} resId resource ID of a drawable to set
*/
setLogo : function( ) {},
/**Set the default logo for this window.
This will be overridden by any other logo set operation which could come from the
theme or another explicit set.
@hide
*/
setDefaultLogo : function( ) {},
/**Set focus locally. The window should have the
{@link android.view.WindowManager.LayoutParams#FLAG_LOCAL_FOCUS_MODE} flag set already.
@param {Boolean} hasFocus Whether this window has focus or not.
@param {Boolean} inTouchMode Whether this window is in touch mode or not.
*/
setLocalFocus : function( ) {},
/**Inject an event to window locally.
@param {Object {InputEvent}} event A key or touch event to inject to this window.
*/
injectInputEvent : function( ) {},
/**Retrieve the {@link TransitionManager} responsible for for default transitions
in this window. Requires {@link #FEATURE_CONTENT_TRANSITIONS}.
<p>This method will return non-null after content has been initialized (e.g. by using
{@link #setContentView}) if {@link #FEATURE_CONTENT_TRANSITIONS} has been granted.</p>
@return {Object {android.transition.TransitionManager}} This window's content TransitionManager or null if none is set.
@attr ref android.R.styleable#Window_windowContentTransitionManager
*/
getTransitionManager : function( ) {},
/**Set the {@link TransitionManager} to use for default transitions in this window.
Requires {@link #FEATURE_CONTENT_TRANSITIONS}.
@param {Object {TransitionManager}} tm The TransitionManager to use for scene changes.
@attr ref android.R.styleable#Window_windowContentTransitionManager
*/
setTransitionManager : function( ) {},
/**Retrieve the {@link Scene} representing this window's current content.
Requires {@link #FEATURE_CONTENT_TRANSITIONS}.
<p>This method will return null if the current content is not represented by a Scene.</p>
@return {Object {android.transition.Scene}} Current Scene being shown or null
*/
getContentScene : function( ) {},
/**Sets the Transition that will be used to move Views into the initial scene. The entering
Views will be those that are regular Views or ViewGroups that have
{@link android.view.ViewGroup#isTransitionGroup} return true. Typical Transitions will extend
{@link android.transition.Visibility} as entering is governed by changing visibility from
{@link android.view.View#INVISIBLE} to {@link android.view.View#VISIBLE}. If <code>transition</code> is null,
entering Views will remain unaffected.
@param {Object {Transition}} transition The Transition to use to move Views into the initial Scene.
@attr ref android.R.styleable#Window_windowEnterTransition
*/
setEnterTransition : function( ) {},
/**Sets the Transition that will be used to move Views out of the scene when the Window is
preparing to close, for example after a call to
{@link android.app.Activity#finishAfterTransition()}. The exiting
Views will be those that are regular Views or ViewGroups that have
{@link android.view.ViewGroup#isTransitionGroup} return true. Typical Transitions will extend
{@link android.transition.Visibility} as entering is governed by changing visibility from
{@link android.view.View#VISIBLE} to {@link android.view.View#INVISIBLE}. If <code>transition</code> is null,
entering Views will remain unaffected. If nothing is set, the default will be to
use the same value as set in {@link #setEnterTransition(android.transition.Transition)}.
@param {Object {Transition}} transition The Transition to use to move Views out of the Scene when the Window
is preparing to close.
@attr ref android.R.styleable#Window_windowReturnTransition
*/
setReturnTransition : function( ) {},
/**Sets the Transition that will be used to move Views out of the scene when starting a
new Activity. The exiting Views will be those that are regular Views or ViewGroups that
have {@link android.view.ViewGroup#isTransitionGroup} return true. Typical Transitions will extend
{@link android.transition.Visibility} as exiting is governed by changing visibility
from {@link android.view.View#VISIBLE} to {@link android.view.View#INVISIBLE}. If transition is null, the views will
remain unaffected. Requires {@link #FEATURE_ACTIVITY_TRANSITIONS}.
@param {Object {Transition}} transition The Transition to use to move Views out of the scene when calling a
new Activity.
@attr ref android.R.styleable#Window_windowExitTransition
*/
setExitTransition : function( ) {},
/**Sets the Transition that will be used to move Views in to the scene when returning from
a previously-started Activity. The entering Views will be those that are regular Views
or ViewGroups that have {@link android.view.ViewGroup#isTransitionGroup} return true. Typical Transitions
will extend {@link android.transition.Visibility} as exiting is governed by changing
visibility from {@link android.view.View#VISIBLE} to {@link android.view.View#INVISIBLE}. If transition is null,
the views will remain unaffected. If nothing is set, the default will be to use the same
transition as {@link #setExitTransition(android.transition.Transition)}.
Requires {@link #FEATURE_ACTIVITY_TRANSITIONS}.
@param {Object {Transition}} transition The Transition to use to move Views into the scene when reentering from a
previously-started Activity.
@attr ref android.R.styleable#Window_windowReenterTransition
*/
setReenterTransition : function( ) {},
/**Returns the transition used to move Views into the initial scene. The entering
Views will be those that are regular Views or ViewGroups that have
{@link android.view.ViewGroup#isTransitionGroup} return true. Typical Transitions will extend
{@link android.transition.Visibility} as entering is governed by changing visibility from
{@link android.view.View#INVISIBLE} to {@link android.view.View#VISIBLE}. If <code>transition</code> is null,
entering Views will remain unaffected. Requires {@link #FEATURE_ACTIVITY_TRANSITIONS}.
@return {Object {android.transition.Transition}} the Transition to use to move Views into the initial Scene.
@attr ref android.R.styleable#Window_windowEnterTransition
*/
getEnterTransition : function( ) {},
/**Returns the Transition that will be used to move Views out of the scene when the Window is
preparing to close, for example after a call to
{@link android.app.Activity#finishAfterTransition()}. The exiting
Views will be those that are regular Views or ViewGroups that have
{@link android.view.ViewGroup#isTransitionGroup} return true. Typical Transitions will extend
{@link android.transition.Visibility} as entering is governed by changing visibility from
{@link android.view.View#VISIBLE} to {@link android.view.View#INVISIBLE}.
@return {Object {android.transition.Transition}} The Transition to use to move Views out of the Scene when the Window
is preparing to close.
@attr ref android.R.styleable#Window_windowReturnTransition
*/
getReturnTransition : function( ) {},
/**Returns the Transition that will be used to move Views out of the scene when starting a
new Activity. The exiting Views will be those that are regular Views or ViewGroups that
have {@link android.view.ViewGroup#isTransitionGroup} return true. Typical Transitions will extend
{@link android.transition.Visibility} as exiting is governed by changing visibility
from {@link android.view.View#VISIBLE} to {@link android.view.View#INVISIBLE}. If transition is null, the views will
remain unaffected. Requires {@link #FEATURE_ACTIVITY_TRANSITIONS}.
@return {Object {android.transition.Transition}} the Transition to use to move Views out of the scene when calling a
new Activity.
@attr ref android.R.styleable#Window_windowExitTransition
*/
getExitTransition : function( ) {},
/**Returns the Transition that will be used to move Views in to the scene when returning from
a previously-started Activity. The entering Views will be those that are regular Views
or ViewGroups that have {@link android.view.ViewGroup#isTransitionGroup} return true. Typical Transitions
will extend {@link android.transition.Visibility} as exiting is governed by changing
visibility from {@link android.view.View#VISIBLE} to {@link android.view.View#INVISIBLE}.
Requires {@link #FEATURE_ACTIVITY_TRANSITIONS}.
@return {Object {android.transition.Transition}} The Transition to use to move Views into the scene when reentering from a
previously-started Activity.
@attr ref android.R.styleable#Window_windowReenterTransition
*/
getReenterTransition : function( ) {},
/**Sets the Transition that will be used for shared elements transferred into the content
Scene. Typical Transitions will affect size and location, such as
{@link android.transition.ChangeBounds}. A null
value will cause transferred shared elements to blink to the final position.
Requires {@link #FEATURE_ACTIVITY_TRANSITIONS}.
@param {Object {Transition}} transition The Transition to use for shared elements transferred into the content
Scene.
@attr ref android.R.styleable#Window_windowSharedElementEnterTransition
*/
setSharedElementEnterTransition : function( ) {},
/**Sets the Transition that will be used for shared elements transferred back to a
calling Activity. Typical Transitions will affect size and location, such as
{@link android.transition.ChangeBounds}. A null
value will cause transferred shared elements to blink to the final position.
If no value is set, the default will be to use the same value as
{@link #setSharedElementEnterTransition(android.transition.Transition)}.
Requires {@link #FEATURE_ACTIVITY_TRANSITIONS}.
@param {Object {Transition}} transition The Transition to use for shared elements transferred out of the content
Scene.
@attr ref android.R.styleable#Window_windowSharedElementReturnTransition
*/
setSharedElementReturnTransition : function( ) {},
/**Returns the Transition that will be used for shared elements transferred into the content
Scene. Requires {@link #FEATURE_ACTIVITY_TRANSITIONS}.
@return {Object {android.transition.Transition}} Transition to use for sharend elements transferred into the content Scene.
@attr ref android.R.styleable#Window_windowSharedElementEnterTransition
*/
getSharedElementEnterTransition : function( ) {},
/**Returns the Transition that will be used for shared elements transferred back to a
calling Activity. Requires {@link #FEATURE_ACTIVITY_TRANSITIONS}.
@return {Object {android.transition.Transition}} Transition to use for sharend elements transferred into the content Scene.
@attr ref android.R.styleable#Window_windowSharedElementReturnTransition
*/
getSharedElementReturnTransition : function( ) {},
/**Sets the Transition that will be used for shared elements after starting a new Activity
before the shared elements are transferred to the called Activity. If the shared elements
must animate during the exit transition, this Transition should be used. Upon completion,
the shared elements may be transferred to the started Activity.
Requires {@link #FEATURE_ACTIVITY_TRANSITIONS}.
@param {Object {Transition}} transition The Transition to use for shared elements in the launching Window
prior to transferring to the launched Activity's Window.
@attr ref android.R.styleable#Window_windowSharedElementExitTransition
*/
setSharedElementExitTransition : function( ) {},
/**Sets the Transition that will be used for shared elements reentering from a started
Activity after it has returned the shared element to it start location. If no value
is set, this will default to
{@link #setSharedElementExitTransition(android.transition.Transition)}.
Requires {@link #FEATURE_ACTIVITY_TRANSITIONS}.
@param {Object {Transition}} transition The Transition to use for shared elements in the launching Window
after the shared element has returned to the Window.
@attr ref android.R.styleable#Window_windowSharedElementReenterTransition
*/
setSharedElementReenterTransition : function( ) {},
/**Returns the Transition to use for shared elements in the launching Window prior
to transferring to the launched Activity's Window.
Requires {@link #FEATURE_ACTIVITY_TRANSITIONS}.
@return {Object {android.transition.Transition}} the Transition to use for shared elements in the launching Window prior
to transferring to the launched Activity's Window.
@attr ref android.R.styleable#Window_windowSharedElementExitTransition
*/
getSharedElementExitTransition : function( ) {},
/**Returns the Transition that will be used for shared elements reentering from a started
Activity after it has returned the shared element to it start location.
Requires {@link #FEATURE_ACTIVITY_TRANSITIONS}.
@return {Object {android.transition.Transition}} the Transition that will be used for shared elements reentering from a started
Activity after it has returned the shared element to it start location.
@attr ref android.R.styleable#Window_windowSharedElementReenterTransition
*/
getSharedElementReenterTransition : function( ) {},
/**Controls how the transition set in
{@link #setEnterTransition(android.transition.Transition)} overlaps with the exit
transition of the calling Activity. When true, the transition will start as soon as possible.
When false, the transition will wait until the remote exiting transition completes before
starting. The default value is true.
@param {Boolean} allow true to start the enter transition when possible or false to
wait until the exiting transition completes.
@attr ref android.R.styleable#Window_windowAllowEnterTransitionOverlap
*/
setAllowEnterTransitionOverlap : function( ) {},
/**Returns how the transition set in
{@link #setEnterTransition(android.transition.Transition)} overlaps with the exit
transition of the calling Activity. When true, the transition will start as soon as possible.
When false, the transition will wait until the remote exiting transition completes before
starting. The default value is true.
@return {Boolean} true when the enter transition should start as soon as possible or false to
when it should wait until the exiting transition completes.
@attr ref android.R.styleable#Window_windowAllowEnterTransitionOverlap
*/
getAllowEnterTransitionOverlap : function( ) {},
/**Controls how the transition set in
{@link #setExitTransition(android.transition.Transition)} overlaps with the exit
transition of the called Activity when reentering after if finishes. When true,
the transition will start as soon as possible. When false, the transition will wait
until the called Activity's exiting transition completes before starting.
The default value is true.
@param {Boolean} allow true to start the transition when possible or false to wait until the
called Activity's exiting transition completes.
@attr ref android.R.styleable#Window_windowAllowReturnTransitionOverlap
*/
setAllowReturnTransitionOverlap : function( ) {},
/**Returns how the transition set in
{@link #setExitTransition(android.transition.Transition)} overlaps with the exit
transition of the called Activity when reentering after if finishes. When true,
the transition will start as soon as possible. When false, the transition will wait
until the called Activity's exiting transition completes before starting.
The default value is true.
@return {Boolean} true when the transition should start when possible or false when it should wait
until the called Activity's exiting transition completes.
@attr ref android.R.styleable#Window_windowAllowReturnTransitionOverlap
*/
getAllowReturnTransitionOverlap : function( ) {},
/**Returns the duration, in milliseconds, of the window background fade
when transitioning into or away from an Activity when called with an Activity Transition.
<p>When executing the enter transition, the background starts transparent
and fades in. This requires {@link #FEATURE_ACTIVITY_TRANSITIONS}. The default is
300 milliseconds.</p>
@return {Number} The duration of the window background fade to opaque during enter transition.
@see #getEnterTransition()
@attr ref android.R.styleable#Window_windowTransitionBackgroundFadeDuration
*/
getTransitionBackgroundFadeDuration : function( ) {},
/**Sets the duration, in milliseconds, of the window background fade
when transitioning into or away from an Activity when called with an Activity Transition.
<p>When executing the enter transition, the background starts transparent
and fades in. This requires {@link #FEATURE_ACTIVITY_TRANSITIONS}. The default is
300 milliseconds.</p>
@param {Number} fadeDurationMillis The duration of the window background fade to or from opaque
during enter transition.
@see #setEnterTransition(android.transition.Transition)
@attr ref android.R.styleable#Window_windowTransitionBackgroundFadeDuration
*/
setTransitionBackgroundFadeDuration : function( ) {},
/**Returns <code>true</code> when shared elements should use an Overlay during
shared element transitions or <code>false</code> when they should animate as
part of the normal View hierarchy. The default value is true.
@return {Boolean} <code>true</code> when shared elements should use an Overlay during
shared element transitions or <code>false</code> when they should animate as
part of the normal View hierarchy.
@attr ref android.R.styleable#Window_windowSharedElementsUseOverlay
*/
getSharedElementsUseOverlay : function( ) {},
/**Sets whether or not shared elements should use an Overlay during shared element transitions.
The default value is true.
@param {Boolean} sharedElementsUseOverlay <code>true</code> indicates that shared elements should
be transitioned with an Overlay or <code>false</code>
to transition within the normal View hierarchy.
@attr ref android.R.styleable#Window_windowSharedElementsUseOverlay
*/
setSharedElementsUseOverlay : function( ) {},
/**
@return {Number} the color of the status bar.
*/
getStatusBarColor : function( ) {},
/**Sets the color of the status bar to {@code color}.
For this to take effect,
the window must be drawing the system bar backgrounds with
{@link android.view.WindowManager.LayoutParams#FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS} and
{@link android.view.WindowManager.LayoutParams#FLAG_TRANSLUCENT_STATUS} must not be set.
If {@code color} is not opaque, consider setting
{@link android.view.View#SYSTEM_UI_FLAG_LAYOUT_STABLE} and
{@link android.view.View#SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN}.
<p>
The transitionName for the view background will be "android:status:background".
</p>
*/
setStatusBarColor : function( ) {},
/**
@return {Number} the color of the navigation bar.
*/
getNavigationBarColor : function( ) {},
/**Sets the color of the navigation bar to {@param color}.
For this to take effect,
the window must be drawing the system bar backgrounds with
{@link android.view.WindowManager.LayoutParams#FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS} and
{@link android.view.WindowManager.LayoutParams#FLAG_TRANSLUCENT_NAVIGATION} must not be set.
If {@param color} is not opaque, consider setting
{@link android.view.View#SYSTEM_UI_FLAG_LAYOUT_STABLE} and
{@link android.view.View#SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION}.
<p>
The transitionName for the view background will be "android:navigation:background".
</p>
@attr ref android.R.styleable#Window_navigationBarColor
*/
setNavigationBarColor : function( ) {},
/**Shows a thin line of the specified color between the navigation bar and the app
content.
<p>
For this to take effect,
the window must be drawing the system bar backgrounds with
{@link android.view.WindowManager.LayoutParams#FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS} and
{@link android.view.WindowManager.LayoutParams#FLAG_TRANSLUCENT_NAVIGATION} must not be set.
@param {Number} dividerColor The color of the thin line.
@attr ref android.R.styleable#Window_navigationBarDividerColor
*/
setNavigationBarDividerColor : function( ) {},
/**Retrieves the color of the navigation bar divider.
@return {Number} The color of the navigation bar divider color.
@see #setNavigationBarColor(int)
@attr ref android.R.styleable#Window_navigationBarDividerColor
*/
getNavigationBarDividerColor : function( ) {},
/**Sets whether the system should ensure that the status bar has enough
contrast when a fully transparent background is requested.
<p>If set to this value, the system will determine whether a scrim is necessary
to ensure that the status bar has enough contrast with the contents of
this app, and set an appropriate effective bar background color accordingly.
<p>When the status bar color has a non-zero alpha value, the value of this
property has no effect.
@see android.R.attr#enforceStatusBarContrast
@see #isStatusBarContrastEnforced
@see #setStatusBarColor
*/
setStatusBarContrastEnforced : function( ) {},
/**Returns whether the system is ensuring that the status bar has enough contrast when a
fully transparent background is requested.
<p>When the status bar color has a non-zero alpha value, the value of this
property has no effect.
@return {Boolean} true, if the system is ensuring contrast, false otherwise.
@see android.R.attr#enforceStatusBarContrast
@see #setStatusBarContrastEnforced
@see #setStatusBarColor
*/
isStatusBarContrastEnforced : function( ) {},
/**Sets whether the system should ensure that the navigation bar has enough
contrast when a fully transparent background is requested.
<p>If set to this value, the system will determine whether a scrim is necessary
to ensure that the navigation bar has enough contrast with the contents of
this app, and set an appropriate effective bar background color accordingly.
<p>When the navigation bar color has a non-zero alpha value, the value of this
property has no effect.
@see android.R.attr#enforceNavigationBarContrast
@see #isNavigationBarContrastEnforced
@see #setNavigationBarColor
*/
setNavigationBarContrastEnforced : function( ) {},
/**Returns whether the system is ensuring that the navigation bar has enough contrast when a
fully transparent background is requested.
<p>When the navigation bar color has a non-zero alpha value, the value of this
property has no effect.
@return {Boolean} true, if the system is ensuring contrast, false otherwise.
@see android.R.attr#enforceNavigationBarContrast
@see #setNavigationBarContrastEnforced
@see #setNavigationBarColor
*/
isNavigationBarContrastEnforced : function( ) {},
/**Sets a list of areas within this window's coordinate space where the system should not
intercept touch or other pointing device gestures.
<p>This method should be used by apps that make use of
{@link #takeSurface(SurfaceHolder.Callback2)} and do not have a view hierarchy available.
Apps that do have a view hierarchy should use
{@link android.view.View#setSystemGestureExclusionRects(List)} instead. This method does not modify or
replace the gesture exclusion rects populated by individual views in this window's view
hierarchy using {@link android.view.View#setSystemGestureExclusionRects(List)}.</p>
<p>Use this to tell the system which specific sub-areas of a view need to receive gesture
input in order to function correctly in the presence of global system gestures that may
conflict. For example, if the system wishes to capture swipe-in-from-screen-edge gestures
to provide system-level navigation functionality, a view such as a navigation drawer
container can mark the left (or starting) edge of itself as requiring gesture capture
priority using this API. The system may then choose to relax its own gesture recognition
to allow the app to consume the user's gesture. It is not necessary for an app to register
exclusion rects for broadly spanning regions such as the entirety of a
<code>ScrollView</code> or for simple press and release click targets such as
<code>Button</code>. Mark an exclusion rect when interacting with a view requires
a precision touch gesture in a small area in either the X or Y dimension, such as
an edge swipe or dragging a <code>SeekBar</code> thumb.</p>
<p>Do not modify the provided list after this method is called.</p>
@param {Object {java.util.List}} rects A list of precision gesture regions that this window needs to function correctly
*/
setSystemGestureExclusionRects : function( ) {},
/**Retrieve the list of areas within this window's coordinate space where the system should not
intercept touch or other pointing device gestures. This is the list as set by
{@link #setSystemGestureExclusionRects}(List) or an empty list if
{@link #setSystemGestureExclusionRects}(List) has not been called. It does not include
exclusion rects set by this window's view hierarchy.
@return {Object {java.util.List}} a list of system gesture exclusion rects specific to this window
*/
getSystemGestureExclusionRects : function( ) {},
/**
@hide
*/
setTheme : function( ) {},
/**Whether the caption should be displayed directly on the content rather than push the content
down. This affects only freeform windows since they display the caption.
@hide
*/
setOverlayWithDecorCaptionEnabled : function( ) {},
/**
@hide
*/
isOverlayWithDecorCaptionEnabled : function( ) {},
/**
@hide
*/
notifyRestrictedCaptionAreaCallback : function( ) {},
/**Set what color should the caption controls be. By default the system will try to determine
the color from the theme. You can overwrite this by using {@link #DECOR_CAPTION_SHADE_DARK},
{@link #DECOR_CAPTION_SHADE_LIGHT}, or {@link #DECOR_CAPTION_SHADE_AUTO}.
@see #DECOR_CAPTION_SHADE_DARK
@see #DECOR_CAPTION_SHADE_LIGHT
@see #DECOR_CAPTION_SHADE_AUTO
*/
setDecorCaptionShade : function( ) {},
/**Set the drawable that is drawn underneath the caption during the resizing.
During the resizing the caption might not be drawn fast enough to match the new dimensions.
There is a second caption drawn underneath it that will be fast enough. By default the
caption is constructed from the theme. You can provide a drawable, that will be drawn instead
to better match your application.
*/
setResizingCaptionDrawable : function( ) {},
/**Called when the activity changes from fullscreen mode to multi-window mode and visa-versa.
@hide
*/
onMultiWindowModeChanged : function( ) {},
/**Called when the activity changes to/from picture-in-picture mode.
@hide
*/
onPictureInPictureModeChanged : function( ) {},
/**Called when the activity just relaunched.
@hide
*/
reportActivityRelaunched : function( ) {},
/**Called to set flag to check if the close on swipe is enabled. This will only function if
FEATURE_SWIPE_TO_DISMISS has been set.
@hide
*/
setCloseOnSwipeEnabled : function( ) {},
/**
@return {Boolean} {@code true} if the close on swipe is enabled.
@hide
*/
isCloseOnSwipeEnabled : function( ) {},
/**
@return {Object {android.view.WindowInsetsController}} The {@link WindowInsetsController} associated with this window
@see View#getWindowInsetsController()
@hide pending unhide
*/
getInsetsController : function( ) {},
};