| /** |
| * 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.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.LayerGenericMetadataKey; |
| 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); |
| |
| /** |
| * Use getDisplayCapabilities instead. If brightness is supported, must return |
| * DisplayCapability::BRIGHTNESS as one of the display capabilities via getDisplayCapabilities. |
| * Only use getDisplayCapabilities as the source of truth to query brightness support. |
| * |
| * Gets whether brightness operations are supported on a display. |
| * |
| * @param display The display. |
| * |
| * @return Whether brightness operations are supported on the display. |
| * |
| * @exception EX_BAD_DISPLAY when the display is invalid, or |
| * @exception EX_BAD_PARAMETER when the output parameter is invalid. |
| */ |
| boolean getDisplayBrightnessSupport(long display); |
| |
| /** |
| * 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); |
| |
| /** |
| * Returns whether the given display supports PowerMode::DOZE and |
| * PowerMode::DOZE_SUSPEND. DOZE_SUSPEND may not provide any benefit over |
| * DOZE (see the definition of PowerMode for more information), but if |
| * both DOZE and DOZE_SUSPEND are no different from PowerMode::ON, the |
| * device must not claim support. |
| * |
| * @param display is the display to query. |
| * |
| * @return is true only when the display supports doze modes. |
| * |
| * @exception EX_BAD_DISPLAY when an invalid display handle was passed in. |
| */ |
| boolean getDozeSupport(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); |
| |
| /** |
| * Retrieves the set of keys that may be passed into setLayerGenericMetadata |
| * |
| * Key names must meet the following requirements: |
| * - Must be specified in reverse domain name notation |
| * - Must not start with 'com.android' or 'android' |
| * - Must be unique within the returned vector |
| * - Must correspond to a matching HIDL struct type, which defines the |
| * structure of its values. For example, the key 'com.example.V1-3.Foo' |
| * should correspond to a value of type com.example@1.3::Foo, which is |
| * defined in a vendor HAL extension |
| */ |
| LayerGenericMetadataKey[] getLayerGenericMetadataKeys(); |
| |
| /** |
| * 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 |
| */ |
| 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); |
| |
| /** |
| * 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); |
| |
| /** |
| * 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); |
| |
| /** |
| * Sets the brightness of a display. |
| * |
| * Ideally, the brightness change should take effect in the next frame post (so that it can be |
| * aligned with color transforms). |
| * |
| * @param display |
| * The display whose brightness is set. |
| * @param brightness |
| * A number between 0.0f (minimum brightness) and 1.0f (maximum brightness), or -1.0 to |
| * turn the backlight off. |
| * |
| * @exception EX_BAD_DISPLAY when the display is invalid, or |
| * @exception EX_UNSUPPORTED when brightness operations are not supported, or |
| * @exception EX_BAD_PARAMETER when the brightness is invalid, or |
| * @exception EX_NO_RESOURCES when the brightness cannot be applied. |
| */ |
| void setDisplayBrightness(long display, float brightness); |
| |
| /** |
| * 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. |
| * |
| * 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. |
| * |
| * The release fence file descriptor provided works identically to the one |
| * described for setOutputBuffer. |
| * |
| * 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 in setOutputBuffer |
| * |
| * @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 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); |
| } |
