/**@class android.hardware.display.DisplayManager
@extends java.lang.Object

 Manages the properties of attached displays.
*/
var DisplayManager = {

/** Broadcast receiver that indicates when the Wifi display status changes.
 <p>
 The status is provided as a {@link android.hardware.display.WifiDisplayStatus} object in the
 {@link #EXTRA_WIFI_DISPLAY_STATUS} extra.
 </p><p>
 This broadcast is only sent to registered receivers and can only be sent by the system.
 </p>
 @hide
*/
ACTION_WIFI_DISPLAY_STATUS_CHANGED : "android.hardware.display.action.WIFI_DISPLAY_STATUS_CHANGED",
/** Contains a {@link android.hardware.display.WifiDisplayStatus} object.
 @hide
*/
EXTRA_WIFI_DISPLAY_STATUS : "android.hardware.display.extra.WIFI_DISPLAY_STATUS",
/** Display category: Presentation displays.
 <p>
 This category can be used to identify secondary displays that are suitable for
 use as presentation displays such as HDMI or Wireless displays.  Applications
 may automatically project their content to presentation displays to provide
 richer second screen experiences.
 </p>

 @see android.app.Presentation
 @see Display#FLAG_PRESENTATION
 @see #getDisplays(String)
*/
DISPLAY_CATEGORY_PRESENTATION : "android.hardware.display.category.PRESENTATION",
/** Virtual display flag: Create a public display.

 <h3>Public virtual displays</h3>
 <p>
 When this flag is set, the virtual display is public.
 </p><p>
 A public virtual display behaves just like most any other display that is connected
 to the system such as an HDMI or Wireless display.  Applications can open
 windows on the display and the system may mirror the contents of other displays
 onto it.
 </p><p>
 Creating a public virtual display that isn't restricted to own-content only implicitly
 creates an auto-mirroring display. See {@link #VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR} for
 restrictions on who is allowed to create an auto-mirroring display.
 </p>

 <h3>Private virtual displays</h3>
 <p>
 When this flag is not set, the virtual display is private as defined by the
 {@link Display#FLAG_PRIVATE} display flag.
 </p>

 <p>
 A private virtual display belongs to the application that created it.  Only the a owner of a
 private virtual display and the apps that are already on that display are allowed to place
 windows upon it.  The private virtual display also does not participate in display mirroring:
 it will neither receive mirrored content from another display nor allow its own content to be
 mirrored elsewhere.  More precisely, the only processes that are allowed to enumerate or
 interact with the private display are those that have the same UID as the application that
 originally created the private virtual display or as the activities that are already on that
 display.
 </p>

 @see #createVirtualDisplay
 @see #VIRTUAL_DISPLAY_FLAG_OWN_CONTENT_ONLY
 @see #VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR
*/
VIRTUAL_DISPLAY_FLAG_PUBLIC : "1",
/** Virtual display flag: Create a presentation display.

 <h3>Presentation virtual displays</h3>
 <p>
 When this flag is set, the virtual display is registered as a presentation
 display in the {@link #DISPLAY_CATEGORY_PRESENTATION presentation display category}.
 Applications may automatically project their content to presentation displays
 to provide richer second screen experiences.
 </p>

 <h3>Non-presentation virtual displays</h3>
 <p>
 When this flag is not set, the virtual display is not registered as a presentation
 display.  Applications can still project their content on the display but they
 will typically not do so automatically.  This option is appropriate for
 more special-purpose displays.
 </p>

 @see android.app.Presentation
 @see #createVirtualDisplay
 @see #DISPLAY_CATEGORY_PRESENTATION
 @see Display#FLAG_PRESENTATION
*/
VIRTUAL_DISPLAY_FLAG_PRESENTATION : "2",
/** Virtual display flag: Create a secure display.

 <h3>Secure virtual displays</h3>
 <p>
 When this flag is set, the virtual display is considered secure as defined
 by the {@link Display#FLAG_SECURE} display flag.  The caller promises to take
 reasonable measures, such as over-the-air encryption, to prevent the contents
 of the display from being intercepted or recorded on a persistent medium.
 </p><p>
 Creating a secure virtual display requires the CAPTURE_SECURE_VIDEO_OUTPUT permission.
 This permission is reserved for use by system components and is not available to
 third-party applications.
 </p>

 <h3>Non-secure virtual displays</h3>
 <p>
 When this flag is not set, the virtual display is considered unsecure.
 The content of secure windows will be blanked if shown on this display.
 </p>

 @see Display#FLAG_SECURE
 @see #createVirtualDisplay
*/
VIRTUAL_DISPLAY_FLAG_SECURE : "4",
/** Virtual display flag: Only show this display's own content; do not mirror
 the content of another display.

 <p>
 This flag is used in conjunction with {@link #VIRTUAL_DISPLAY_FLAG_PUBLIC}.
 Ordinarily public virtual displays will automatically mirror the content of the
 default display if they have no windows of their own.  When this flag is
 specified, the virtual display will only ever show its own content and
 will be blanked instead if it has no windows.
 </p>

 <p>
 This flag is mutually exclusive with {@link #VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR}.  If both
 flags are specified then the own-content only behavior will be applied.
 </p>

 <p>
 This behavior of this flag is implied whenever neither {@link #VIRTUAL_DISPLAY_FLAG_PUBLIC}
 nor {@link #VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR} have been set.  This flag is only required to
 override the default behavior when creating a public display.
 </p>

 @see #createVirtualDisplay
*/
VIRTUAL_DISPLAY_FLAG_OWN_CONTENT_ONLY : "8",
/** Virtual display flag: Allows content to be mirrored on private displays when no content is
 being shown.

 <p>
 This flag is mutually exclusive with {@link #VIRTUAL_DISPLAY_FLAG_OWN_CONTENT_ONLY}.
 If both flags are specified then the own-content only behavior will be applied.
 </p>

 <p>
 The behavior of this flag is implied whenever {@link #VIRTUAL_DISPLAY_FLAG_PUBLIC} is set
 and {@link #VIRTUAL_DISPLAY_FLAG_OWN_CONTENT_ONLY} has not been set.   This flag is only
 required to override the default behavior when creating a private display.
 </p>

 <p>
 Creating an auto-mirroing virtual display requires the CAPTURE_VIDEO_OUTPUT
 or CAPTURE_SECURE_VIDEO_OUTPUT permission.
 These permissions are reserved for use by system components and are not available to
 third-party applications.

 Alternatively, an appropriate {@link MediaProjection} may be used to create an
 auto-mirroring virtual display.
 </p>

 @see #createVirtualDisplay
*/
VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR : "16",
/** Virtual display flag: Allows content to be displayed on private virtual displays when
 keyguard is shown but is insecure.

 <p>
 This might be used in a case when the content of a virtual display is captured and sent to an
 external hardware display that is not visible to the system directly. This flag will allow
 the continued display of content while other displays will be covered by a keyguard which
 doesn't require providing credentials to unlock. This means that there is either no password
 or other authentication method set, or the device is in a trusted state -
 {@link android.service.trust.TrustAgentService} has available and active trust agent.
 </p><p>
 This flag can only be applied to private displays as defined by the
 {@link Display#FLAG_PRIVATE} display flag. It is mutually exclusive with
 {@link #VIRTUAL_DISPLAY_FLAG_PUBLIC}. If both flags are specified then this flag's behavior
 will not be applied.
 </p>

 @see #createVirtualDisplay
 @see KeyguardManager#isDeviceSecure()
 @see KeyguardManager#isDeviceLocked()
 @hide
*/
VIRTUAL_DISPLAY_FLAG_CAN_SHOW_WITH_INSECURE_KEYGUARD : "32",
/** Virtual display flag: Specifies that the virtual display can be associated with a
 touchpad device that matches its uniqueId.

 @see #createVirtualDisplay
 @hide
*/
VIRTUAL_DISPLAY_FLAG_SUPPORTS_TOUCH : "64",
/** Virtual display flag: Indicates that the orientation of this display device is coupled to
 the rotation of its associated logical display.

 @see #createVirtualDisplay
 @hide
*/
VIRTUAL_DISPLAY_FLAG_ROTATES_WITH_CONTENT : "128",
/** Virtual display flag: Indicates that the contents will be destroyed once
 the display is removed.

 Public virtual displays without this flag will move their content to main display
 stack once they're removed. Private vistual displays will always destroy their
 content on removal even without this flag.

 @see #createVirtualDisplay
 @hide
*/
VIRTUAL_DISPLAY_FLAG_DESTROY_CONTENT_ON_REMOVAL : "256",
/** Virtual display flag: Indicates that the display should support system decorations. Virtual
 displays without this flag shouldn't show home, IME or any other system decorations.

 @see #createVirtualDisplay
 @hide
*/
VIRTUAL_DISPLAY_FLAG_SHOULD_SHOW_SYSTEM_DECORATIONS : "512",
/**Gets information about a logical display.

 The display metrics may be adjusted to provide compatibility
 for legacy applications.
@param {Number} displayId The logical display id.
@return {Object {android.view.Display}} The display object, or null if there is no valid display with the given id.
*/
getDisplay : function(  ) {},

/**Gets all currently valid logical displays.
@return {Object {android.view.Display}} An array containing all displays.
*/
getDisplays : function(  ) {},

/**Gets all currently valid logical displays of the specified category.
 <p>
 When there are multiple displays in a category the returned displays are sorted
 of preference.  For example, if the requested category is
 {@link #DISPLAY_CATEGORY_PRESENTATION} and there are multiple presentation displays
 then the displays are sorted so that the first display in the returned array
 is the most preferred presentation display.  The application may simply
 use the first display or allow the user to choose.
 </p>
@param {String} category The requested display category or null to return all displays.
@return {Object {android.view.Display}} An array containing all displays sorted by order of preference.
@see #DISPLAY_CATEGORY_PRESENTATION
*/
getDisplays : function(  ) {},

/**Registers an display listener to receive notifications about when
 displays are added, removed or changed.
@param {Object {DisplayManager.DisplayListener}} listener The listener to register.
@param {Object {Handler}} handler The handler on which the listener should be invoked, or null
 if the listener should be invoked on the calling thread's looper.
@see #unregisterDisplayListener
*/
registerDisplayListener : function(  ) {},

/**Unregisters a display listener.
@param {Object {DisplayManager.DisplayListener}} listener The listener to unregister.
@see #registerDisplayListener
*/
unregisterDisplayListener : function(  ) {},

/**Starts scanning for available Wifi displays.
 The results are sent as a {@link #ACTION_WIFI_DISPLAY_STATUS_CHANGED} broadcast.
 <p>
 Calls to this method nest and must be matched by an equal number of calls to
 {@link #stopWifiDisplayScan}().
 </p><p>
 Requires {@link android.Manifest.permission#CONFIGURE_WIFI_DISPLAY}.
 </p>
@hide 
*/
startWifiDisplayScan : function(  ) {},

/**Stops scanning for available Wifi displays.
 <p>
 Requires {@link android.Manifest.permission#CONFIGURE_WIFI_DISPLAY}.
 </p>
@hide 
*/
stopWifiDisplayScan : function(  ) {},

/**Connects to a Wifi display.
 The results are sent as a {@link #ACTION_WIFI_DISPLAY_STATUS_CHANGED} broadcast.
 <p>
 Automatically remembers the display after a successful connection, if not
 already remembered.
 </p><p>
 Requires {@link android.Manifest.permission#CONFIGURE_WIFI_DISPLAY}.
 </p>
@param {String} deviceAddress The MAC address of the device to which we should connect.
@hide 
*/
connectWifiDisplay : function(  ) {},

/**
@hide 
*/
pauseWifiDisplay : function(  ) {},

/**
@hide 
*/
resumeWifiDisplay : function(  ) {},

/**Disconnects from the current Wifi display.
 The results are sent as a {@link #ACTION_WIFI_DISPLAY_STATUS_CHANGED} broadcast.
@hide 
*/
disconnectWifiDisplay : function(  ) {},

/**Renames a Wifi display.
 <p>
 The display must already be remembered for this call to succeed.  In other words,
 we must already have successfully connected to the display at least once and then
 not forgotten it.
 </p><p>
 Requires {@link android.Manifest.permission#CONFIGURE_WIFI_DISPLAY}.
 </p>
@param {String} deviceAddress The MAC address of the device to rename.
@param {String} alias The alias name by which to remember the device, or null
 or empty if no alias should be used.
@hide 
*/
renameWifiDisplay : function(  ) {},

/**Forgets a previously remembered Wifi display.
 <p>
 Automatically disconnects from the display if currently connected to it.
 </p><p>
 Requires {@link android.Manifest.permission#CONFIGURE_WIFI_DISPLAY}.
 </p>
@param {String} deviceAddress The MAC address of the device to forget.
@hide 
*/
forgetWifiDisplay : function(  ) {},

/**Gets the current Wifi display status.
 Watch for changes in the status by registering a broadcast receiver for
 {@link #ACTION_WIFI_DISPLAY_STATUS_CHANGED}.
@return {Object {android.hardware.display.WifiDisplayStatus}} The current Wifi display status.
@hide 
*/
getWifiDisplayStatus : function(  ) {},

/**Set the level of color saturation to apply to the display.
@param {Number} level The amount of saturation to apply, between 0 and 1 inclusive.
 0 produces a grayscale image, 1 is normal.
@hide 
@deprecated use {@link ColorDisplayManager#setSaturationLevel(int)} instead. The level passed
 as a parameter here will be rounded to the nearest hundredth.
*/
setSaturationLevel : function(  ) {},

/**Creates a virtual display.
@see #createVirtualDisplay(String, int, int, int, Surface, int,
 VirtualDisplay.Callback, Handler)
*/
createVirtualDisplay : function(  ) {},

/**Creates a virtual display.
 <p>
 The content of a virtual display is rendered to a {@link Surface} provided
 by the application.
 </p><p>
 The virtual display should be {@link android.hardware.display.VirtualDisplay#release released}
 when no longer needed.  Because a virtual display renders to a surface
 provided by the application, it will be released automatically when the
 process terminates and all remaining windows on it will be forcibly removed.
 </p><p>
 The behavior of the virtual display depends on the flags that are provided
 to this method.  By default, virtual displays are created to be private,
 non-presentation and unsecure.  Permissions may be required to use certain flags.
 </p><p>
 As of {@link android.os.Build.VERSION_CODES#KITKAT_WATCH}, the surface may
 be attached or detached dynamically using {@link android.hardware.display.VirtualDisplay#setSurface}.
 Previously, the surface had to be non-null when {@link #createVirtualDisplay}
 was called and could not be changed for the lifetime of the display.
 </p><p>
 Detaching the surface that backs a virtual display has a similar effect to
 turning off the screen.
 </p>
@param {String} name The name of the virtual display, must be non-empty.
@param {Number} width The width of the virtual display in pixels, must be greater than 0.
@param {Number} height The height of the virtual display in pixels, must be greater than 0.
@param {Number} densityDpi The density of the virtual display in dpi, must be greater than 0.
@param {Object {Surface}} surface The surface to which the content of the virtual display should
 be rendered, or null if there is none initially.
@param {Number} flags A combination of virtual display flags:
 {@link #VIRTUAL_DISPLAY_FLAG_PUBLIC}, {@link #VIRTUAL_DISPLAY_FLAG_PRESENTATION},
 {@link #VIRTUAL_DISPLAY_FLAG_SECURE}, {@link #VIRTUAL_DISPLAY_FLAG_OWN_CONTENT_ONLY},
 or {@link #VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR}.
@param {Object {VirtualDisplay.Callback}} callback Callback to call when the state of the {@link VirtualDisplay} changes
@param {Object {Handler}} handler The handler on which the listener should be invoked, or null
 if the listener should be invoked on the calling thread's looper.
@return {Object {android.hardware.display.VirtualDisplay}} The newly created virtual display, or null if the application could
 not create the virtual display.
@throws SecurityException if the caller does not have permission to create
 a virtual display with the specified flags.
*/
createVirtualDisplay : function(  ) {},

/**
@hide 
*/
createVirtualDisplay : function(  ) {},

/**Gets the stable device display size, in pixels.

 This should really only be used for things like server-side filtering of available
 applications. Most applications don't need the level of stability guaranteed by this and
 should instead query either the size of the display they're currently running on or the
 size of the default display.
@hide 
*/
getStableDisplaySize : function(  ) {},

/**Fetch {@link android.hardware.display.BrightnessChangeEvent}s.
@hide until we make it a system api.
*/
getBrightnessEvents : function(  ) {},

/**Fetch {@link android.hardware.display.AmbientBrightnessDayStats}s.
@hide until we make it a system api
*/
getAmbientBrightnessStats : function(  ) {},

/**Sets the global display brightness configuration.
@hide 
*/
setBrightnessConfiguration : function(  ) {},

/**Sets the global display brightness configuration for a specific user.

 Note this requires the INTERACT_ACROSS_USERS permission if setting the configuration for a
 user other than the one you're currently running as.
@hide 
*/
setBrightnessConfigurationForUser : function(  ) {},

/**Gets the global display brightness configuration or the default curve if one hasn't been set.
@hide 
*/
getBrightnessConfiguration : function(  ) {},

/**Gets the global display brightness configuration or the default curve if one hasn't been set
 for a specific user.

 Note this requires the INTERACT_ACROSS_USERS permission if getting the configuration for a
 user other than the one you're currently running as.
@hide 
*/
getBrightnessConfigurationForUser : function(  ) {},

/**Gets the default global display brightness configuration or null one hasn't
 been configured.
@hide 
*/
getDefaultBrightnessConfiguration : function(  ) {},

/**Temporarily sets the brightness of the display.
 <p>
 Requires the {@link android.Manifest.permission#CONTROL_DISPLAY_BRIGHTNESS} permission.
 </p>
@param {Number} brightness The brightness value from 0 to 255.
@hide Requires signature permission.
*/
setTemporaryBrightness : function(  ) {},

/**Temporarily sets the auto brightness adjustment factor.
 <p>
 Requires the {@link android.Manifest.permission#CONTROL_DISPLAY_BRIGHTNESS} permission.
 </p>
@param {Number} adjustment The adjustment factor from -1.0 to 1.0.
@hide Requires signature permission.
*/
setTemporaryAutoBrightnessAdjustment : function(  ) {},

/**Returns the minimum brightness curve, which guarantess that any brightness curve that dips
 below it is rejected by the system.
 This prevent auto-brightness from setting the screen so dark as to prevent the user from
 resetting or disabling it, and maps lux to the absolute minimum nits that are still readable
 in that ambient brightness.
@return {Object {android.util.Pair}} The minimum brightness curve (as lux values and their corresponding nits values).
@hide 
*/
getMinimumBrightnessCurve : function(  ) {},


};