/**@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(  ) {},

 {@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(  ) {},

 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(  ) {},


};