Display

DEFAULT_DISPLAY

static val DEFAULT_DISPLAY: Int

The default Display id, which is the id of the primary display assuming there is one.

Value: 0

FLAG_PRESENTATION

static val FLAG_PRESENTATION: Int

Display flag: Indicates that the display is a presentation display.

This flag identifies secondary displays that are suitable for use as presentation displays such as external or wireless displays. Applications may automatically project their content to presentation displays to provide richer second screen experiences.

Value: 8

FLAG_PRIVATE

static val FLAG_PRIVATE: Int

Display flag: Indicates that the display is private. Only the application that owns the display and apps that are already on the display can create windows on it.

Value: 4

FLAG_ROUND

static val FLAG_ROUND: Int

Display flag: Indicates that the display has a round shape.

This flag identifies displays that are circular, elliptical or otherwise do not permit the user to see all the way to the logical corners of the display.

Value: 16

FLAG_SECURE

static val FLAG_SECURE: Int

Display flag: Indicates that the display has a secure video output and supports compositing secure surfaces.

If this flag is set then the display device has a secure video output and is capable of showing secure surfaces. It may also be capable of showing protected buffers.

If this flag is not set then the display device may not have a secure video output; the user may see a blank region on the screen instead of the contents of secure surfaces or protected buffers.

Secure surfaces are used to prevent content rendered into those surfaces by applications from appearing in screenshots or from being viewed on non-secure displays. Protected buffers are used by secure video decoders for a similar purpose.

An application creates a window with a secure surface by specifying the WindowManager.LayoutParams#FLAG_SECURE window flag. Likewise, an application creates a SurfaceView with a secure surface by calling SurfaceView#setSecure before attaching the secure view to its containing window.

An application can use the absence of this flag as a hint that it should not create secure surfaces or protected buffers on this display because the content may not be visible. For example, if the flag is not set then the application may choose not to show content on this display, show an informative error message, select an alternate content stream or adopt a different strategy for decoding content that does not rely on secure surfaces or protected buffers.

Value: 2

FLAG_SUPPORTS_PROTECTED_BUFFERS

static val FLAG_SUPPORTS_PROTECTED_BUFFERS: Int

Display flag: Indicates that the display supports compositing content that is stored in protected graphics buffers.

If this flag is set then the display device supports compositing protected buffers.

If this flag is not set then the display device may not support compositing protected buffers; the user may see a blank region on the screen instead of the protected content.

Secure (DRM) video decoders may allocate protected graphics buffers to request that a hardware-protected path be provided between the video decoder and the external display sink. If a hardware-protected path is not available, then content stored in protected graphics buffers may not be composited.

An application can use the absence of this flag as a hint that it should not use protected buffers for this display because the content may not be visible. For example, if the flag is not set then the application may choose not to show content on this display, show an informative error message, select an alternate content stream or adopt a different strategy for decoding content that does not rely on protected buffers.

Value: 1

INVALID_DISPLAY

static val INVALID_DISPLAY: Int

Invalid display id.

Value: -1

STATE_DOZE

static val STATE_DOZE: Int

Display state: The display is dozing in a low power state; it is still on but is optimized for showing system-provided content while the device is non-interactive.

Value: 3

STATE_DOZE_SUSPEND

static val STATE_DOZE_SUSPEND: Int

Display state: The display is dozing in a suspended low power state; it is still on but the CPU is not updating it. This may be used in one of two ways: to show static system-provided content while the device is non-interactive, or to allow a "Sidekick" compute resource to update the display. For this reason, the CPU must not control the display in this mode.

Value: 4

STATE_OFF

static val STATE_OFF: Int

Display state: The display is off.

Value: 1

STATE_ON

static val STATE_ON: Int

Display state: The display is on.

Value: 2

STATE_ON_SUSPEND

static val STATE_ON_SUSPEND: Int

Display state: The display is in a suspended full power state; it is still on but the CPU is not updating it. This may be used in one of two ways: to show static system-provided content while the device is non-interactive, or to allow a "Sidekick" compute resource to update the display. For this reason, the CPU must not control the display in this mode.

Value: 6

STATE_UNKNOWN

static val STATE_UNKNOWN: Int

Display state: The display state is unknown.

Value: 0

STATE_VR

static val STATE_VR: Int

Display state: The display is on and optimized for VR mode.

Value: 5

getAppVsyncOffsetNanos

fun getAppVsyncOffsetNanos(): Long

Gets the app VSYNC offset, in nanoseconds. This is a positive value indicating the phase offset of the VSYNC events provided by Choreographer relative to the display refresh. For example, if Choreographer reports that the refresh occurred at time N, it actually occurred at (N - appVsyncOffset).

Apps generally do not need to be aware of this. It's only useful for fine-grained A/V synchronization.

getCurrentSizeRange

fun getCurrentSizeRange(
    outSmallestSize: Point!, 
    outLargestSize: Point!
): Unit

Return the range of display sizes an application can expect to encounter under normal operation, as long as there is no physical change in screen size. This is basically the sizes you will see as the orientation changes, taking into account whatever screen decoration there is in each rotation. For example, the status bar is always at the top of the screen, so it will reduce the height both in landscape and portrait, and the smallest height returned here will be the smaller of the two. This is intended for applications to get an idea of the range of sizes they will encounter while going through device rotations, to provide a stable UI through rotation. The sizes here take into account all standard system decorations that reduce the size actually available to the application: the status bar, navigation bar, system bar, etc. It does not take into account more transient elements like an IME soft keyboard.

getCutout

fun getCutout(): DisplayCutout?

Returns the DisplayCutout, or null if there is none.

getDisplayId

fun getDisplayId(): Int

Gets the display id.

Each logical display has a unique id. The default display has id DEFAULT_DISPLAY.

getFlags

fun getFlags(): Int

Returns a combination of flags that describe the capabilities of the display.

getHdrCapabilities

fun getHdrCapabilities(): Display.HdrCapabilities!

Returns the display's HDR capabilities.

getHeight

fun getHeight(): Int

Deprecated: Use WindowMetrics#getBounds() instead.

getMetrics

fun getMetrics(outMetrics: DisplayMetrics!): Unit

Deprecated: Use WindowMetrics#getBounds() to get the dimensions of the application window area, and Configuration#densityDpi to get the current density.

Gets display metrics that describe the size and density of this display. The size returned by this method does not necessarily represent the actual raw size (native resolution) of the display.

1. The returned size may be adjusted to exclude certain system decor elements that are always visible.

2. It may be scaled to provide compatibility with older applications that were originally designed for smaller displays.

3. It can be different depending on the WindowManager to which the display belongs.

- If requested from non-Activity context (e.g. Application context via (WindowManager) getApplicationContext().getSystemService(Context.WINDOW_SERVICE)) metrics will report the size of the entire display based on current rotation and with subtracted system decoration areas.

- If requested from activity (either using getWindowManager() or (WindowManager) getSystemService(Context.WINDOW_SERVICE)) resulting metrics will correspond to current app window metrics. In this case the size can be smaller than physical size in multi-window mode.

getMode

fun getMode(): Display.Mode!

Returns the active mode of the display.

getName

fun getName(): String!

Gets the name of the display.

Note that some displays may be renamed by the user.

getOrientation

fun getOrientation(): Int

Deprecated: use getRotation

getPixelFormat

fun getPixelFormat(): Int

Deprecated: This method is no longer supported. The result is always PixelFormat#RGBA_8888.

Gets the pixel format of the display.

getPreferredWideGamutColorSpace

fun getPreferredWideGamutColorSpace(): ColorSpace?

Returns the preferred wide color space of the Display. The returned wide gamut color space is based on hardware capability and is preferred by the composition pipeline. Returns null if the display doesn't support wide color gamut. Display#isWideColorGamut().

getPresentationDeadlineNanos

fun getPresentationDeadlineNanos(): Long

This is how far in advance a buffer must be queued for presentation at a given time. If you want a buffer to appear on the screen at time N, you must submit the buffer before (N - presentationDeadline).

The desired presentation time for GLES rendering may be set with android.opengl.EGLExt#eglPresentationTimeANDROID. For video decoding, use android.media.MediaCodec#releaseOutputBuffer(int, long). Times are expressed in nanoseconds, using the system monotonic clock (System#nanoTime).

getRealMetrics

fun getRealMetrics(outMetrics: DisplayMetrics!): Unit

Gets display metrics based on the real size of this display.

The size is adjusted based on the current rotation of the display.

The real size may be smaller than the physical size of the screen when the window manager is emulating a smaller display (using adb shell wm size).

getRealSize

fun getRealSize(outSize: Point!): Unit

Gets the real size of the display without subtracting any window decor or applying any compatibility scale factors.

The size is adjusted based on the current rotation of the display.

The real size may be smaller than the physical size of the screen when the window manager is emulating a smaller display (using adb shell wm size).

getRectSize

fun getRectSize(outSize: Rect!): Unit

Deprecated: Use WindowMetrics#getBounds() to get the dimensions of the application window area.

Gets the size of the display as a rectangle, in pixels.

getRefreshRate

fun getRefreshRate(): Float

Gets the refresh rate of this display in frames per second.

getRotation

fun getRotation(): Int

Returns the rotation of the screen from its "natural" orientation. The returned value may be Surface#ROTATION_0 (no rotation), Surface#ROTATION_90, Surface#ROTATION_180, or Surface#ROTATION_270. For example, if a device has a naturally tall screen, and the user has turned it on its side to go into a landscape orientation, the value returned here may be either Surface#ROTATION_90 or Surface#ROTATION_270 depending on the direction it was turned. The angle is the rotation of the drawn graphics on the screen, which is the opposite direction of the physical rotation of the device. For example, if the device is rotated 90 degrees counter-clockwise, to compensate rendering will be rotated by 90 degrees clockwise and thus the returned value here will be Surface#ROTATION_90.

getSize

fun getSize(outSize: Point!): Unit

Deprecated: Use WindowManager#getCurrentWindowMetrics() to obtain an instance of WindowMetrics and use WindowMetrics#getBounds() instead.

Gets the size of the display, in pixels. Value returned by this method does not necessarily represent the actual raw size (native resolution) of the display.

1. The returned size may be adjusted to exclude certain system decor elements that are always visible.

2. It may be scaled to provide compatibility with older applications that were originally designed for smaller displays.

3. It can be different depending on the WindowManager to which the display belongs.

- If requested from non-Activity context (e.g. Application context via (WindowManager) getApplicationContext().getSystemService(Context.WINDOW_SERVICE)) it will report the size of the entire display based on current rotation and with subtracted system decoration areas.

- If requested from activity (either using getWindowManager() or (WindowManager) getSystemService(Context.WINDOW_SERVICE)) resulting size will correspond to current app window size. In this case it can be smaller than physical size in multi-window mode.

Typically for the purposes of layout apps should make a request from activity context to obtain size available for the app content.

getState

fun getState(): Int

Gets the state of the display, such as whether it is on or off.

getSupportedModes

fun getSupportedModes(): Array<Display.Mode!>!

Gets the supported modes of this display.

getSupportedRefreshRates

fun getSupportedRefreshRates(): FloatArray!

Deprecated: use getSupportedModes() instead

Get the supported refresh rates of this display in frames per second.

This method only returns refresh rates for the display's default modes. For more options, use getSupportedModes().

getWidth

fun getWidth(): Int

Deprecated: Use WindowMetrics#getBounds instead.

isHdr

fun isHdr(): Boolean

Returns whether this display supports any HDR type.

isMinimalPostProcessingSupported

fun isMinimalPostProcessingSupported(): Boolean

Returns true if the connected display can be switched into a mode with minimal post processing.

If the Display sink is connected via HDMI, this method will return true if the display supports either Auto Low Latency Mode or Game Content Type.

If the Display sink has an internal connection or uses some other protocol than HDMI, this method will return true if the sink can be switched into an implementation-defined low latency image processing mode.

The ability to switch to a mode with minimal post processing may be disabled by a user setting in the system settings menu. In that case, this method returns false.

isValid

fun isValid(): Boolean

Returns true if this display is still valid, false if the display has been removed. If the display is invalid, then the methods of this class will continue to report the most recently observed display information. However, it is unwise (and rather fruitless) to continue using a Display object after the display's demise. It's possible for a display that was previously invalid to become valid again if a display with the same id is reconnected.

isWideColorGamut

fun isWideColorGamut(): Boolean

Returns whether this display can be used to display wide color gamut content. This does not necessarily mean the device itself can render wide color gamut content. To ensure wide color gamut content can be produced, refer to Configuration#isScreenWideColorGamut().

toString

fun toString(): String