blob: a4ea64f815d39f5b203518aa10eb06f758851c33 [file] [log] [blame]
/**
* Copyright (c) 2021, The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.hardware.graphics.composer3;
import android.hardware.graphics.common.DisplayDecorationSupport;
import android.hardware.graphics.common.Transform;
import android.hardware.graphics.composer3.ClientTargetProperty;
import android.hardware.graphics.composer3.ColorMode;
import android.hardware.graphics.composer3.CommandResultPayload;
import android.hardware.graphics.composer3.ContentType;
import android.hardware.graphics.composer3.DisplayAttribute;
import android.hardware.graphics.composer3.DisplayCapability;
import android.hardware.graphics.composer3.DisplayCommand;
import android.hardware.graphics.composer3.DisplayConnectionType;
import android.hardware.graphics.composer3.DisplayContentSample;
import android.hardware.graphics.composer3.DisplayContentSamplingAttributes;
import android.hardware.graphics.composer3.DisplayIdentification;
import android.hardware.graphics.composer3.FormatColorComponent;
import android.hardware.graphics.composer3.HdrCapabilities;
import android.hardware.graphics.composer3.IComposerCallback;
import android.hardware.graphics.composer3.PerFrameMetadataKey;
import android.hardware.graphics.composer3.PowerMode;
import android.hardware.graphics.composer3.ReadbackBufferAttributes;
import android.hardware.graphics.composer3.RenderIntent;
import android.hardware.graphics.composer3.VirtualDisplay;
import android.hardware.graphics.composer3.VsyncPeriodChangeConstraints;
import android.hardware.graphics.composer3.VsyncPeriodChangeTimeline;
@VintfStability
interface IComposerClient {
/**
* Invalid Config Exception
*/
const int EX_BAD_CONFIG = 1;
/**
* Invalid Display Exception
*/
const int EX_BAD_DISPLAY = 2;
/**
* Invalid Layer Exception
*/
const int EX_BAD_LAYER = 3;
/**
* Invalid width, height, etc.
*/
const int EX_BAD_PARAMETER = 4;
/**
* Reserved for historical reasons
*/
const int EX_RESERVED = 5;
/**
* Temporary failure due to resource contention Exception
*/
const int EX_NO_RESOURCES = 6;
/**
* validateDisplay has not been called Exception
*/
const int EX_NOT_VALIDATED = 7;
/**
* Seamless cannot be required for configurations that don't share a
* config group Exception
*/
const int EX_UNSUPPORTED = 8;
const int EX_SEAMLESS_NOT_ALLOWED = 9;
/**
* Seamless requirements cannot be met Exception
*/
const int EX_SEAMLESS_NOT_POSSIBLE = 10;
/**
* Integer.MAX_VALUE is reserved for the invalid configuration.
* This should not be returned as a valid configuration.
*/
const int INVALID_CONFIGURATION = 0x7fffffff;
/**
* Creates a new layer on the given display.
*
* @param display is the display on which to create the layer.
* @param bufferSlotCount is the number of buffer slot to be reserved.
*
* @return is the handle of the new layer.
*
* @exception EX_BAD_DISPLAY when an invalid display handle was passed in.
* @exception EX_NO_RESOURCES when the device was unable to create a layer this
* time.
*/
long createLayer(long display, int bufferSlotCount);
/**
* Creates a new virtual display with the given width and height. The
* format passed into this function is the default format requested by the
* consumer of the virtual display output buffers.
*
* The display must be assumed to be on from the time the first frame is
* presented until the display is destroyed.
*
* @param width is the width in pixels.
* @param height is the height in pixels.
* @param formatHint is the default output buffer format selected by
* the consumer.
* @param outputBufferSlotCount is the number of output buffer slots to be
* reserved.
*
* @return is the newly-created virtual display.
*
* @exception EX_UNSUPPORTED when the width or height is too large for the
* device to be able to create a virtual display.
* @exception EX_NO_RESOURCES when the device is unable to create a new virtual
* display at this time.
*/
VirtualDisplay createVirtualDisplay(int width, int height,
android.hardware.graphics.common.PixelFormat formatHint, int outputBufferSlotCount);
/**
* Destroys the given layer.
*
* @param display is the display on which the layer was created.
* @param layer is the layer to destroy.
*
* @exception EX_BAD_DISPLAY when an invalid display handle was passed in.
* @exception EX_BAD_LAYER when an invalid layer handle was passed in.
*/
void destroyLayer(long display, long layer);
/**
* Destroys a virtual display. After this call all resources consumed by
* this display may be freed by the device and any operations performed on
* this display must fail.
*
* @param display is the virtual display to destroy.
*
* @exception EX_BAD_DISPLAY when an invalid display handle was passed in.
* @exception EX_BAD_PARAMETER when the display handle which was passed in does
* not refer to a virtual display.
*/
void destroyVirtualDisplay(long display);
/**
* Executes commands.
*
* @param commands are the commands to be processed.
*
* @return are the command statuses.
*/
CommandResultPayload[] executeCommands(in DisplayCommand[] commands);
/**
* Retrieves which display configuration is currently active.
*
* If no display configuration is currently active, this function raise
* the exception EX_BAD_CONFIG. It is the responsibility of the client to call
* setActiveConfig with a valid configuration before attempting to present
* anything on the display.
*
* @param display is the display to which the active config is queried.
*
* @return is the currently active display configuration.
*
* @exception EX_BAD_DISPLAY when an invalid display handle was passed in.
* @exception EX_BAD_CONFIG when no configuration is currently active.
*/
int getActiveConfig(long display);
/**
* Returns the color modes supported on this display.
*
* All devices must support at least ColorMode.NATIVE.
*
* @param display is the display to query.
*
* @return is an array of color modes.
*
* @exception EX_BAD_DISPLAY when an invalid display handle was passed in.
*/
ColorMode[] getColorModes(long display);
/**
* By default, layer dataspaces are mapped to the current color mode
* colorimetrically with a few exceptions.
*
* When the layer dataspace is a legacy dataspace (see
* common@1.1::Dataspace) and the display render intent is
* RenderIntent.ENHANCE, the pixel values can go through an
* implementation-defined saturation transform before being mapped to the
* current color mode colorimetrically.
*
* Colors that are out of the gamut of the current color mode are
* hard-clipped.
*
*
* Returns the saturation matrix of the specified legacy dataspace.
*
* The saturation matrix can be used to approximate the legacy dataspace
* saturation transform. It is to be applied on linear pixel values like
* this:
*
* (in GLSL)
* linearSrgb = saturationMatrix * linearSrgb;
*
* @param dataspace must be Dataspace::SRGB_LINEAR.
*
* @return is the 4x4 column-major matrix used to approximate the
* legacy dataspace saturation operation. The last row must be
* [0.0, 0.0, 0.0, 1.0].
*
* @exception EX_BAD_PARAMETER when an invalid dataspace was passed in.
*/
float[] getDataspaceSaturationMatrix(android.hardware.graphics.common.Dataspace dataspace);
/**
* Returns a display attribute value for a particular display
* configuration.
*
* @param display is the display to query.
* @param config is the display configuration for which to return
* attribute values.
*
* @return is the value of the attribute.
*
* @exception EX_BAD_DISPLAY when an invalid display handle was passed in.
* @exception EX_BAD_CONFIG when config does not name a valid configuration for
* this display.
* @exception EX_BAD_PARAMETER when attribute is unrecognized.
* @exception EX_UNSUPPORTED when attribute cannot be queried for the config.
*/
int getDisplayAttribute(long display, int config, DisplayAttribute attribute);
/**
* Provides a list of supported capabilities (as described in the
* definition of DisplayCapability above). This list must not change after
* initialization.
*
* @return is a list of supported capabilities.
*
* @exception EX_BAD_DISPLAY when an invalid display handle was passed in.
*/
DisplayCapability[] getDisplayCapabilities(long display);
/**
* Returns handles for all of the valid display configurations on this
* display.
* This should never return INVALID_CONFIGURATION as a valid value.
*
* @param display is the display to query.
*
* @return is an array of configuration handles.
*
* @exception EX_BAD_DISPLAY when an invalid display handle was passed in.
*/
int[] getDisplayConfigs(long display);
/**
* Returns whether the given physical display is internal or external.
*
* @return is the connection type of the display.
*
* @exception EX_BAD_DISPLAY when the given display is invalid or virtual.
*/
DisplayConnectionType getDisplayConnectionType(long display);
/**
* Returns the port and data that describe a physical display. The port is
* a unique number that identifies a physical connector (e.g. eDP, HDMI)
* for display output. The data blob is parsed to determine its format,
* typically EDID 1.3 as specified in VESA E-EDID Standard Release A
* Revision 1.
*
* @param display is the display to query.
* @exception EX_BAD_DISPLAY when an invalid display handle was passed in.
* @exception EX_UNSUPPORTED when identification data is unavailable.
* @return the connector to which the display is connected and the EDID 1.3
* blob identifying the display.
*/
DisplayIdentification getDisplayIdentificationData(long display);
/**
* Returns a human-readable version of the display's name.
*
* @return is the name of the display.
*
* @exception EX_BAD_DISPLAY when an invalid display handle was passed in.
*/
String getDisplayName(long display);
/**
* Retrieves which vsync period the display is currently using.
*
* If no display configuration is currently active, this function must
* return BAD_CONFIG. If the vsync period is about to change due to a
* setActiveConfigWithConstraints call, this function must return the current vsync period
* until the change takes place.
*
* @param display is the display for which the vsync period is queried.
*
* @return is the current vsync period of the display.
*
* @exception EX_BAD_DISPLAY when an invalid display handle was passed in.
* @exception EX_BAD_CONFIG when no configuration is currently active.
*/
int getDisplayVsyncPeriod(long display);
/**
* Collects the results of display content color sampling for display.
*
* Collection of data can occur whether the sampling is in ENABLE or
* DISABLE state.
*
* @param display is the display to which the sampling is collected.
* @param maxFrames is the maximum number of frames that should be represented in the sample.
* The sample represents the most-recently posted frames.
* If maxFrames is 0, all frames are to be represented by the sample.
* @param timestamp is the timestamp after which any frames were posted that should be
* included in the sample. Timestamp is CLOCK_MONOTONIC.
* If timestamp is 0, do not filter from the sample by time.
*
* @return is the sample.
*
* @exception EX_BAD_DISPLAY when an invalid display was passed in, or
* @exception EX_UNSUPPORTED when there is no efficient way to sample, or
* @exception EX_BAD_PARAMETER when the component is not supported by the hardware.
*/
DisplayContentSample getDisplayedContentSample(long display, long maxFrames, long timestamp);
/**
* Query for what types of color sampling the hardware supports.
*
* @param display is the display where the samples are collected.
*
* @return are the sampling attributes
*
* @exception EX_BAD_DISPLAY when an invalid display was passed in, or
* @exception EX_UNSUPPORTED when there is no efficient way to sample.
*/
DisplayContentSamplingAttributes getDisplayedContentSamplingAttributes(long display);
/**
* Queries the physical orientation of a display. Orientation 'Transform::NONE'
* represents a display that doesn't require any transformation on layers
* to be presented at their natural orientation.
*
* @param display is the display where the physical orientation is queried.
*
* @return is one of the below values:
* Transform::NONE
* Transform::ROT_90
* Transform::ROT_180
* Transform::ROT_270
*
* @exception EX_BAD_DISPLAY when an invalid display was passed in.
*/
Transform getDisplayPhysicalOrientation(long display);
/**
* Returns the high dynamic range (HDR) capabilities of the given display,
* which are invariant with regard to the active configuration.
*
* Displays which are not HDR-capable must return no types.
*
* @param display is the display to query.
*
* @return are the HDR capabilities
*
* @exception EX_BAD_DISPLAY when an invalid display handle was passed in.
*/
HdrCapabilities getHdrCapabilities(long display);
/**
* Returns the maximum number of virtual displays supported by this device
* (which may be 0). The client must not attempt to create more than this
* many virtual displays on this device. This number must not change for
* the lifetime of the device.
*
* @return is the maximum number of virtual displays supported.
*/
int getMaxVirtualDisplayCount();
/**
* Returns the PerFrameMetadataKeys that are supported by this device.
*
* @param display is the display on which to create the layer.
* @return is the vector of PerFrameMetadataKey keys that are
* supported by this device.
* @exception EX_UNSUPPORTED if not supported on underlying HAL
*/
PerFrameMetadataKey[] getPerFrameMetadataKeys(long display);
/**
* Returns the format which should be used when allocating a buffer for use by
* device readback as well as the dataspace in which its contents must be
* interpreted.
*
* The width and height of this buffer must be those of the currently-active
* display configuration, and the usage flags must consist of the following:
* BufferUsage.CPU_READ | BufferUsage.GPU_TEXTURE |
* BufferUsage.COMPOSER_OUTPUT
*
* The format and dataspace provided must be sufficient such that if a
* correctly-configured buffer is passed into setReadbackBuffer, filled by
* the device, and then displayed by the client as a full-screen buffer, the
* output of the display remains the same (subject to the note about protected
* content in the description of setReadbackBuffer).
*
* If the active configuration or color mode of this display has changed
* since a previous call to this function, it must be called again prior to
* setting a readback buffer such that the returned format and dataspace will
* be updated accordingly.
*
* Parameters:
* @param display - the display on which to create the layer.
*
* @return is the readback buffer attributes.
*
* @exception EX_BAD_DISPLAY when an invalid display handle was passed in.
* @exception EX_UNSUPPORTED if not supported on underlying HAL
*
* See also:
* setReadbackBuffer
* getReadbackBufferFence
*/
ReadbackBufferAttributes getReadbackBufferAttributes(long display);
/**
* Returns an acquire sync fence file descriptor which must signal when the
* buffer provided to setReadbackBuffer has been filled by the device and is
* safe for the client to read.
*
* If it is already safe to read from this buffer, -1 may be returned instead.
* The client takes ownership of this file descriptor and is responsible for
* closing it when it is no longer needed.
*
* This function must be called immediately after the composition cycle being
* captured into the readback buffer. The complete ordering of a readback buffer
* capture is as follows:
*
* getReadbackBufferAttributes
* // Readback buffer is allocated
* // Many frames may pass
*
* setReadbackBuffer
* validateDisplay
* presentDisplay
* getReadbackBufferFence
* // Implicitly wait on the acquire fence before accessing the buffer
*
* Parameters:
* @param display - the display on which to create the layer.
*
* @return is a sync fence file descriptor as described above; pointer
* must be non-NULL
*
* @exception EX_BAD_DISPLAY - an invalid display handle was passed in
* @exception EX_NO_RESOURCES - the readback operation was successful, but
* resulted in a different validate result than would
* have occurred without readback
* @exception EX_UNSUPPORTED - the readback operation was unsuccessful because of
* resource constraints, the presence of protected
* content, or other reasons; -1 must be returned for
* acquireFence
*
* See also:
* getReadbackBufferAttributes
* setReadbackBuffer
*/
@nullable ParcelFileDescriptor getReadbackBufferFence(long display);
/**
* Returns the render intents supported by the specified display and color
* mode.
*
* For SDR color modes, RenderIntent.COLORIMETRIC must be supported. For
* HDR color modes, RenderIntent.TONE_MAP_COLORIMETRIC must be supported.
*
* @param display is the display to query.
* @param mode is the color mode to query.
*
* @return is an array of render intents.
*
* @exception EX_BAD_DISPLAY when an invalid display handle was passed in.
* @exception EX_BAD_PARAMETER when an invalid color mode was passed in.
*/
RenderIntent[] getRenderIntents(long display, ColorMode mode);
/**
* Provides a list of all the content types supported by this display (any of
* ContentType.{GRAPHICS, PHOTO, CINEMA, GAME}). This list must not change after
* initialization.
*
* Content types are introduced in HDMI 1.4 and supporting them is optional. The
* ContentType.NONE is always supported and will not be returned by this method..
*
* @return out is a list of supported content types.
*
* @exception EX_BAD_DISPLAY when an invalid display handle was passed in.
*/
ContentType[] getSupportedContentTypes(long display);
/**
* Report whether and how this display supports Composition.DISPLAY_DECORATION.
*
* @return A description of how the display supports DISPLAY_DECORATION, or null
* if it is unsupported.
*
* @exception EX_BAD_DISPLAY when an invalid display handle was passed in.
*/
@nullable DisplayDecorationSupport getDisplayDecorationSupport(long display);
/**
* Provides a IComposerCallback object for the device to call.
*
* This function must be called only once.
*
* @param callback is the IComposerCallback object.
*/
void registerCallback(in IComposerCallback callback);
/**
* Sets the active configuration for this display. Upon returning, the
* given display configuration must be active and remain so until either
* this function is called again or the display is disconnected.
*
* @param display is the display to which the active config is set.
* @param config is the new display configuration.
*
* @exception EX_BAD_DISPLAY when an invalid display handle was passed in.
* @exception EX_BAD_CONFIG when the configuration handle passed in is not valid
* for this display.
*/
void setActiveConfig(long display, int config);
/**
* Sets the active configuration and the refresh rate for this display.
* If the new config shares the same config group as the current config,
* only the vsync period shall change.
* Upon returning, the given display configuration, except vsync period, must be active and
* remain so until either this function is called again or the display is disconnected.
* When the display starts to refresh at the new vsync period, onVsync_2_4 callback must be
* called with the new vsync period.
*
* @param display is the display for which the active config is set.
* @param config is the new display configuration.
* @param vsyncPeriodChangeConstraints are the constraints required for changing vsync period.
*
* @exception EX_BAD_DISPLAY when an invalid display handle was passed in.
* @exception EX_BAD_CONFIG when the configuration handle passed in is not valid
* for this display.
* @exception EX_SEAMLESS_NOT_ALLOWED when seamlessRequired was true but config provided doesn't
* share the same config group as the current config.
* @exception EX_SEAMLESS_NOT_POSSIBLE when seamlessRequired was true but the display cannot
* achieve the vsync period change without a noticeable visual artifact. When the conditions
* change and it may be possible to change the vsync period seamlessly, onSeamlessPossible
* callback must be called to indicate that caller should retry.
*
* @return is the timeline for the vsync period change.
*/
VsyncPeriodChangeTimeline setActiveConfigWithConstraints(
long display, int config, in VsyncPeriodChangeConstraints vsyncPeriodChangeConstraints);
/**
* Sets the display config in which the device boots.
*
* If the device is unable to boot in this config for any reason (example HDMI display changed),
* the implementation should try to find a config which matches the resolution and refresh-rate
* of this config. If no such config exists, the implementation's preferred display config
* should be used.
*
* @param display is the display for which the boot config is set.
* @param config is the new boot config for the display.
*
* @exception EX_BAD_DISPLAY when an invalid display handle was passed in.
* @exception EX_BAD_CONFIG when an invalid config id was passed in.
* @exception EX_UNSUPPORTED when not supported by the underlying HAL
*
* @see getDisplayConfigs
* @see clearBootDisplayConfig
* @see getPreferredBootDisplayConfig
*/
void setBootDisplayConfig(long display, int config);
/**
* Clears the boot display config.
*
* The device should boot in the implementation's preferred display config.
*
* @param display is the display for which the cached boot config is cleared.
*
* @exception EX_BAD_DISPLAY when an invalid display handle was passed in.
* @exception EX_UNSUPPORTED when not supported by the underlying HAL
*
* @see getDisplayConfigs
* @see setBootDisplayConfig
* @see getPreferredBootDisplayConfig
*/
void clearBootDisplayConfig(long display);
/**
* Returns the implementation's preferred display config.
*
* This is the display config used by the implementation at boot time, if the boot display
* config has not been requested yet, or if it has been previously cleared.
*
* @param display is the display to which the preferred config is queried.
* @return the implementation's preferred display config.
*
* @exception EX_BAD_DISPLAY when an invalid display handle was passed in.
* @exception EX_UNSUPPORTED when not supported by the underlying HAL
*
* @see getDisplayConfigs
* @see setBootDisplayConfig
* @see clearBootDisplayConfig
*/
int getPreferredBootDisplayConfig(long display);
/**
* Requests the display to enable/disable its low latency mode.
*
* If the display is connected via HDMI 2.1, then Auto Low Latency Mode should be triggered. If
* the display is internally connected and a custom low latency mode is available, that should
* be triggered.
*
* This function should only be called if the display reports support for
* DisplayCapability.AUTO_LOW_LATENCY_MODE from getDisplayCapabilities_2_4.
*
* @exception EX_BAD_DISPLAY when an invalid display handle was passed in.
* @exception EX_UNSUPPORTED when AUTO_LOW_LATENCY_MODE is not supported by the composer
* implementation or the given display
*/
void setAutoLowLatencyMode(long display, boolean on);
/**
* Set the number of client target slots to be reserved.
*
* @param display is the display to which the slots are reserved.
* @param clientTargetSlotCount is the slot count for client targets.
* @exception EX_BAD_DISPLAY when an invalid display handle was passed in.
* @exception EX_NO_RESOURCES when unable to reserve the slots.
*/
void setClientTargetSlotCount(long display, int clientTargetSlotCount);
/**
* Sets the color mode and render intent of the given display.
*
* The color mode and render intent change must take effect on next
* presentDisplay.
*
* All devices must support at least ColorMode.NATIVE and
* RenderIntent.COLORIMETRIC, and displays are assumed to be in this mode
* upon hotplug.
*
* @param display is the display to which the color mode is set.
* @param mode is the color mode to set to.
* @param intent is the render intent to set to.
*
* @exception EX_BAD_DISPLAY when an invalid display handle was passed in.
* @exception EX_BAD_PARAMETER when mode or intent is invalid
* @exception EX_UNSUPPORTED when mode or intent is not supported on this
* display.
*/
void setColorMode(long display, ColorMode mode, RenderIntent intent);
/**
* Instructs the connected display that the content being shown is of the given type - one of
* GRAPHICS, PHOTO, CINEMA, GAME.
*
* Content types are introduced in HDMI 1.4 and supporting them is optional. If they are
* supported, this signal should switch the display to a mode that is optimal for the given
* type of content. See HDMI 1.4 specification for more information.
*
* If the display is internally connected (not through HDMI), and such modes are available,
* this method should trigger them.
*
* This function can be called for a content type even if no support for it is
* reported from getSupportedContentTypes.
*
* @exception EX_BAD_DISPLAY when an invalid display handle was passed in.
* @exception EX_UNSUPPORTED when the given content type is not supported by the composer
* implementation or the given display
*/
void setContentType(long display, ContentType type);
/**
* Enables or disables the collection of color content statistics
* on this display.
*
* Sampling occurs on the contents of the final composition on this display
* (i.e., the contents presented on screen). Samples should be collected after all
* color transforms have been applied.
*
* Sampling support is optional, and is set to DISABLE by default.
* On each call to ENABLE, all collected statistics must be reset.
*
* Sample data can be queried via getDisplayedContentSample().
*
* @param display is the display to which the sampling mode is set.
* @param enabled indicates whether to enable or disable sampling.
* @param componentMask The mask of which components should be sampled. If zero, all supported
* components are to be enabled.
* @param maxFrames is the maximum number of frames that should be stored before discard.
* The sample represents the most-recently posted frames.
* @exception EX_BAD_DISPLAY when an invalid display handle was passed in,
* @exception EX_BAD_PARAMETER when enabled was an invalid value, or
* @exception EX_NO_RESOURCES when the requested ringbuffer size via maxFrames was
* not available.
* @exception EX_UNSUPPORTED when there is no efficient way to sample.
*/
void setDisplayedContentSamplingEnabled(
long display, boolean enable, FormatColorComponent componentMask, long maxFrames);
/**
* Sets the power mode of the given display. The transition must be
* complete when this function returns. It is valid to call this function
* multiple times with the same power mode.
*
* All displays must support PowerMode.ON and PowerMode.OFF. Whether a
* display supports PowerMode.DOZE or PowerMode.DOZE_SUSPEND may be
* queried using getDozeSupport.
*
* @param display is the display to which the power mode is set.
* @param mode is the new power mode.
* @exception EX_BAD_DISPLAY when an invalid display handle was passed in.
* @exception EX_BAD_PARAMETER when mode was not a valid power mode.
* @exception EX_UNSUPPORTED when mode is not supported on this display.
*/
void setPowerMode(long display, PowerMode mode);
/**
* Sets the readback buffer to be filled with the contents of the next
* composition performed for this display (i.e., the contents present at the
* time of the next validateDisplay/presentDisplay cycle).
*
* This buffer must have been allocated as described in
* getReadbackBufferAttributes and is in the dataspace provided by the same.
*
* Also provides a file descriptor referring to a release sync fence
* object, which must be signaled when it is safe to write to the readback
* buffer. If it is already safe to write to the readback buffer, null may be passed instead.
*
* If there is hardware protected content on the display at the time of the next
* composition, the area of the readback buffer covered by such content must be
* completely black. Any areas of the buffer not covered by such content may
* optionally be black as well.
*
*
* This function must not be called between any call to validateDisplay and a
* subsequent call to presentDisplay.
*
* Parameters:
* @param display - the display on which to create the layer.
* @param buffer - the new readback buffer
* @param releaseFence - a sync fence file descriptor as described above or null if it is
* already safe to write to the readback buffer.
*
* @exception EX_BAD_DISPLAY - an invalid display handle was passed in
* @exception EX_BAD_PARAMETER - the new readback buffer handle was invalid
*
* See also:
* getReadbackBufferAttributes
* getReadbackBufferFence
*/
void setReadbackBuffer(long display, in android.hardware.common.NativeHandle buffer,
in @nullable ParcelFileDescriptor releaseFence);
/**
* Enables or disables the vsync signal for the given display. Virtual
* displays never generate vsync callbacks, and any attempt to enable
* vsync for a virtual display though this function must succeed and have
* no other effect.
*
* @param display is the display to which the vsync mode is set.
* @param enabled indicates whether to enable or disable vsync
* @exception EX_BAD_DISPLAY when an invalid display handle was passed in.
* @exception EX_BAD_PARAMETER when enabled was an invalid value.
*/
void setVsyncEnabled(long display, boolean enabled);
/**
* Enables or disables the idle timer on this display.
*
* Idle timer is used to allow the display to go into a panel idle mode after some
* idle period.
*
* This function should only be called if the display reports support for
* DisplayCapability.DISPLAY_IDLE_TIMER from getDisplayCapabilities.
*
* @param display is the display to which the idle timer is set.
* @param timeoutMs is the minimum requirements of idle period in milliseconds. Panel
* should not go into the idle state within the minimum requirement after
* idle for a while. 0 means disabled, panel should not go into idle state.
*
* @exception EX_BAD_DISPLAY when an invalid display handle was passed in.
* @exception EX_BAD_PARAMETER when timeout is a negative number.
* @exception EX_UNSUPPORTED when idle is not supported on this display.
*
*/
void setIdleTimerEnabled(long display, int timeoutMs);
}