1 /* 2 * Copyright (C) 2006 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #pragma once 18 19 #include <android/gui/DisplayBrightness.h> 20 #include <android/gui/IFpsListener.h> 21 #include <android/gui/IHdrLayerInfoListener.h> 22 #include <android/gui/IScreenCaptureListener.h> 23 #include <android/gui/ITransactionTraceListener.h> 24 #include <android/gui/ITunnelModeEnabledListener.h> 25 #include <binder/IBinder.h> 26 #include <binder/IInterface.h> 27 #include <gui/FrameTimelineInfo.h> 28 #include <gui/ITransactionCompletedListener.h> 29 #include <input/Flags.h> 30 #include <math/vec4.h> 31 #include <stdint.h> 32 #include <sys/types.h> 33 #include <ui/ConfigStoreTypes.h> 34 #include <ui/DisplayId.h> 35 #include <ui/DisplayMode.h> 36 #include <ui/DisplayedFrameStats.h> 37 #include <ui/FrameStats.h> 38 #include <ui/GraphicBuffer.h> 39 #include <ui/GraphicTypes.h> 40 #include <ui/PixelFormat.h> 41 #include <ui/Rotation.h> 42 #include <utils/Errors.h> 43 #include <utils/RefBase.h> 44 #include <utils/Timers.h> 45 #include <utils/Vector.h> 46 47 #include <optional> 48 #include <unordered_set> 49 #include <vector> 50 51 namespace android { 52 53 struct client_cache_t; 54 struct ComposerState; 55 struct DisplayCaptureArgs; 56 struct DisplayStatInfo; 57 struct DisplayState; 58 struct InputWindowCommands; 59 struct LayerCaptureArgs; 60 class LayerDebugInfo; 61 class HdrCapabilities; 62 class IDisplayEventConnection; 63 class IGraphicBufferProducer; 64 class ISurfaceComposerClient; 65 class IRegionSamplingListener; 66 class Rect; 67 enum class FrameEvent; 68 69 using gui::IScreenCaptureListener; 70 71 namespace ui { 72 73 struct DisplayMode; 74 struct DisplayState; 75 struct DynamicDisplayInfo; 76 struct StaticDisplayInfo; 77 78 } // namespace ui 79 80 /* 81 * This class defines the Binder IPC interface for accessing various 82 * SurfaceFlinger features. 83 */ 84 class ISurfaceComposer: public IInterface { 85 public: 86 DECLARE_META_INTERFACE(SurfaceComposer) 87 88 static constexpr size_t MAX_LAYERS = 4096; 89 90 // flags for setTransactionState() 91 enum { 92 eSynchronous = 0x01, 93 eAnimation = 0x02, 94 95 // Explicit indication that this transaction and others to follow will likely result in a 96 // lot of layers being composed, and thus, SurfaceFlinger should wake-up earlier to avoid 97 // missing frame deadlines. In this case SurfaceFlinger will wake up at 98 // (sf vsync offset - debug.sf.early_phase_offset_ns). SurfaceFlinger will continue to be 99 // in the early configuration until it receives eEarlyWakeupEnd. These flags are 100 // expected to be used by WindowManager only and are guarded by 101 // android.permission.ACCESS_SURFACE_FLINGER 102 eEarlyWakeupStart = 0x08, 103 eEarlyWakeupEnd = 0x10, 104 }; 105 106 enum VsyncSource { 107 eVsyncSourceApp = 0, 108 eVsyncSourceSurfaceFlinger = 1 109 }; 110 111 enum class EventRegistration { 112 modeChanged = 1 << 0, 113 frameRateOverride = 1 << 1, 114 }; 115 116 using EventRegistrationFlags = Flags<EventRegistration>; 117 118 /* 119 * Create a connection with SurfaceFlinger. 120 */ 121 virtual sp<ISurfaceComposerClient> createConnection() = 0; 122 123 /* return an IDisplayEventConnection */ 124 virtual sp<IDisplayEventConnection> createDisplayEventConnection( 125 VsyncSource vsyncSource = eVsyncSourceApp, 126 EventRegistrationFlags eventRegistration = {}) = 0; 127 128 /* create a virtual display 129 * requires ACCESS_SURFACE_FLINGER permission. 130 */ 131 virtual sp<IBinder> createDisplay(const String8& displayName, 132 bool secure) = 0; 133 134 /* destroy a virtual display 135 * requires ACCESS_SURFACE_FLINGER permission. 136 */ 137 virtual void destroyDisplay(const sp<IBinder>& display) = 0; 138 139 /* get stable IDs for connected physical displays. 140 */ 141 virtual std::vector<PhysicalDisplayId> getPhysicalDisplayIds() const = 0; 142 143 // TODO(b/74619554): Remove this stopgap once the framework is display-agnostic. getInternalDisplayId()144 std::optional<PhysicalDisplayId> getInternalDisplayId() const { 145 const auto displayIds = getPhysicalDisplayIds(); 146 return displayIds.empty() ? std::nullopt : std::make_optional(displayIds.front()); 147 } 148 149 /* get token for a physical display given its stable ID obtained via getPhysicalDisplayIds or a 150 * DisplayEventReceiver hotplug event. 151 */ 152 virtual sp<IBinder> getPhysicalDisplayToken(PhysicalDisplayId displayId) const = 0; 153 154 // TODO(b/74619554): Remove this stopgap once the framework is display-agnostic. getInternalDisplayToken()155 sp<IBinder> getInternalDisplayToken() const { 156 const auto displayId = getInternalDisplayId(); 157 return displayId ? getPhysicalDisplayToken(*displayId) : nullptr; 158 } 159 160 /* open/close transactions. requires ACCESS_SURFACE_FLINGER permission */ 161 virtual status_t setTransactionState( 162 const FrameTimelineInfo& frameTimelineInfo, const Vector<ComposerState>& state, 163 const Vector<DisplayState>& displays, uint32_t flags, const sp<IBinder>& applyToken, 164 const InputWindowCommands& inputWindowCommands, int64_t desiredPresentTime, 165 bool isAutoTimestamp, const client_cache_t& uncacheBuffer, bool hasListenerCallbacks, 166 const std::vector<ListenerCallbacks>& listenerCallbacks, uint64_t transactionId) = 0; 167 168 /* signal that we're done booting. 169 * Requires ACCESS_SURFACE_FLINGER permission 170 */ 171 virtual void bootFinished() = 0; 172 173 /* verify that an IGraphicBufferProducer was created by SurfaceFlinger. 174 */ 175 virtual bool authenticateSurfaceTexture( 176 const sp<IGraphicBufferProducer>& surface) const = 0; 177 178 /* Returns the frame timestamps supported by SurfaceFlinger. 179 */ 180 virtual status_t getSupportedFrameTimestamps( 181 std::vector<FrameEvent>* outSupported) const = 0; 182 183 /* set display power mode. depending on the mode, it can either trigger 184 * screen on, off or low power mode and wait for it to complete. 185 * requires ACCESS_SURFACE_FLINGER permission. 186 */ 187 virtual void setPowerMode(const sp<IBinder>& display, int mode) = 0; 188 189 190 /* returns display statistics for a given display 191 * intended to be used by the media framework to properly schedule 192 * video frames */ 193 virtual status_t getDisplayStats(const sp<IBinder>& display, 194 DisplayStatInfo* stats) = 0; 195 196 /** 197 * Get transactional state of given display. 198 */ 199 virtual status_t getDisplayState(const sp<IBinder>& display, ui::DisplayState*) = 0; 200 201 /** 202 * Gets immutable information about given physical display. 203 */ 204 virtual status_t getStaticDisplayInfo(const sp<IBinder>& display, ui::StaticDisplayInfo*) = 0; 205 206 /** 207 * Gets dynamic information about given physical display. 208 */ 209 virtual status_t getDynamicDisplayInfo(const sp<IBinder>& display, ui::DynamicDisplayInfo*) = 0; 210 211 virtual status_t getDisplayNativePrimaries(const sp<IBinder>& display, 212 ui::DisplayPrimaries& primaries) = 0; 213 virtual status_t setActiveColorMode(const sp<IBinder>& display, 214 ui::ColorMode colorMode) = 0; 215 216 /** 217 * Switches Auto Low Latency Mode on/off on the connected display, if it is 218 * available. This should only be called if the display supports Auto Low 219 * Latency Mode as reported in #getDynamicDisplayInfo. 220 * For more information, see the HDMI 2.1 specification. 221 */ 222 virtual void setAutoLowLatencyMode(const sp<IBinder>& display, bool on) = 0; 223 224 /** 225 * This will start sending infoframes to the connected display with 226 * ContentType=Game (if on=true). This should only be called if the display 227 * Game Content Type as reported in #getDynamicDisplayInfo. 228 * For more information, see the HDMI 1.4 specification. 229 */ 230 virtual void setGameContentType(const sp<IBinder>& display, bool on) = 0; 231 232 /** 233 * Capture the specified screen. This requires READ_FRAME_BUFFER 234 * permission. This function will fail if there is a secure window on 235 * screen and DisplayCaptureArgs.captureSecureLayers is false. 236 * 237 * This function can capture a subregion (the source crop) of the screen. 238 * The subregion can be optionally rotated. It will also be scaled to 239 * match the size of the output buffer. 240 */ 241 virtual status_t captureDisplay(const DisplayCaptureArgs& args, 242 const sp<IScreenCaptureListener>& captureListener) = 0; 243 244 virtual status_t captureDisplay(uint64_t displayOrLayerStack, 245 const sp<IScreenCaptureListener>& captureListener) = 0; 246 247 template <class AA> 248 struct SpHash { operatorSpHash249 size_t operator()(const sp<AA>& k) const { return std::hash<AA*>()(k.get()); } 250 }; 251 252 /** 253 * Capture a subtree of the layer hierarchy, potentially ignoring the root node. 254 * This requires READ_FRAME_BUFFER permission. This function will fail if there 255 * is a secure window on screen 256 */ 257 virtual status_t captureLayers(const LayerCaptureArgs& args, 258 const sp<IScreenCaptureListener>& captureListener) = 0; 259 260 /* Clears the frame statistics for animations. 261 * 262 * Requires the ACCESS_SURFACE_FLINGER permission. 263 */ 264 virtual status_t clearAnimationFrameStats() = 0; 265 266 /* Gets the frame statistics for animations. 267 * 268 * Requires the ACCESS_SURFACE_FLINGER permission. 269 */ 270 virtual status_t getAnimationFrameStats(FrameStats* outStats) const = 0; 271 272 /* Overrides the supported HDR modes for the given display device. 273 * 274 * Requires the ACCESS_SURFACE_FLINGER permission. 275 */ 276 virtual status_t overrideHdrTypes(const sp<IBinder>& display, 277 const std::vector<ui::Hdr>& hdrTypes) = 0; 278 279 /* Pulls surfaceflinger atoms global stats and layer stats to pipe to statsd. 280 * 281 * Requires the calling uid be from system server. 282 */ 283 virtual status_t onPullAtom(const int32_t atomId, std::string* outData, bool* success) = 0; 284 285 virtual status_t enableVSyncInjections(bool enable) = 0; 286 287 virtual status_t injectVSync(nsecs_t when) = 0; 288 289 /* Gets the list of active layers in Z order for debugging purposes 290 * 291 * Requires the ACCESS_SURFACE_FLINGER permission. 292 */ 293 virtual status_t getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) = 0; 294 295 virtual status_t getColorManagement(bool* outGetColorManagement) const = 0; 296 297 /* Gets the composition preference of the default data space and default pixel format, 298 * as well as the wide color gamut data space and wide color gamut pixel format. 299 * If the wide color gamut data space is V0_SRGB, then it implies that the platform 300 * has no wide color gamut support. 301 * 302 * Requires the ACCESS_SURFACE_FLINGER permission. 303 */ 304 virtual status_t getCompositionPreference(ui::Dataspace* defaultDataspace, 305 ui::PixelFormat* defaultPixelFormat, 306 ui::Dataspace* wideColorGamutDataspace, 307 ui::PixelFormat* wideColorGamutPixelFormat) const = 0; 308 /* 309 * Requires the ACCESS_SURFACE_FLINGER permission. 310 */ 311 virtual status_t getDisplayedContentSamplingAttributes(const sp<IBinder>& display, 312 ui::PixelFormat* outFormat, 313 ui::Dataspace* outDataspace, 314 uint8_t* outComponentMask) const = 0; 315 316 /* Turns on the color sampling engine on the display. 317 * 318 * Requires the ACCESS_SURFACE_FLINGER permission. 319 */ 320 virtual status_t setDisplayContentSamplingEnabled(const sp<IBinder>& display, bool enable, 321 uint8_t componentMask, 322 uint64_t maxFrames) = 0; 323 324 /* Returns statistics on the color profile of the last frame displayed for a given display 325 * 326 * Requires the ACCESS_SURFACE_FLINGER permission. 327 */ 328 virtual status_t getDisplayedContentSample(const sp<IBinder>& display, uint64_t maxFrames, 329 uint64_t timestamp, 330 DisplayedFrameStats* outStats) const = 0; 331 332 /* 333 * Gets whether SurfaceFlinger can support protected content in GPU composition. 334 * Requires the ACCESS_SURFACE_FLINGER permission. 335 */ 336 virtual status_t getProtectedContentSupport(bool* outSupported) const = 0; 337 338 /* 339 * Queries whether the given display is a wide color display. 340 * Requires the ACCESS_SURFACE_FLINGER permission. 341 */ 342 virtual status_t isWideColorDisplay(const sp<IBinder>& token, 343 bool* outIsWideColorDisplay) const = 0; 344 345 /* Registers a listener to stream median luma updates from SurfaceFlinger. 346 * 347 * The sampling area is bounded by both samplingArea and the given stopLayerHandle 348 * (i.e., only layers behind the stop layer will be captured and sampled). 349 * 350 * Multiple listeners may be provided so long as they have independent listeners. 351 * If multiple listeners are provided, the effective sampling region for each listener will 352 * be bounded by whichever stop layer has a lower Z value. 353 * 354 * Requires the same permissions as captureLayers and captureScreen. 355 */ 356 virtual status_t addRegionSamplingListener(const Rect& samplingArea, 357 const sp<IBinder>& stopLayerHandle, 358 const sp<IRegionSamplingListener>& listener) = 0; 359 360 /* 361 * Removes a listener that was streaming median luma updates from SurfaceFlinger. 362 */ 363 virtual status_t removeRegionSamplingListener(const sp<IRegionSamplingListener>& listener) = 0; 364 365 /* Registers a listener that streams fps updates from SurfaceFlinger. 366 * 367 * The listener will stream fps updates for the layer tree rooted at the layer denoted by the 368 * task ID, i.e., the layer must have the task ID as part of its layer metadata with key 369 * METADATA_TASK_ID. If there is no such layer, then no fps is expected to be reported. 370 * 371 * Multiple listeners may be supported. 372 * 373 * Requires the READ_FRAME_BUFFER permission. 374 */ 375 virtual status_t addFpsListener(int32_t taskId, const sp<gui::IFpsListener>& listener) = 0; 376 /* 377 * Removes a listener that was streaming fps updates from SurfaceFlinger. 378 */ 379 virtual status_t removeFpsListener(const sp<gui::IFpsListener>& listener) = 0; 380 381 /* Registers a listener to receive tunnel mode enabled updates from SurfaceFlinger. 382 * 383 * Requires ACCESS_SURFACE_FLINGER permission. 384 */ 385 virtual status_t addTunnelModeEnabledListener( 386 const sp<gui::ITunnelModeEnabledListener>& listener) = 0; 387 388 /* 389 * Removes a listener that was receiving tunnel mode enabled updates from SurfaceFlinger. 390 * 391 * Requires ACCESS_SURFACE_FLINGER permission. 392 */ 393 virtual status_t removeTunnelModeEnabledListener( 394 const sp<gui::ITunnelModeEnabledListener>& listener) = 0; 395 396 /* Sets the refresh rate boundaries for the display. 397 * 398 * The primary refresh rate range represents display manager's general guidance on the display 399 * modes we'll consider when switching refresh rates. Unless we get an explicit signal from an 400 * app, we should stay within this range. 401 * 402 * The app request refresh rate range allows us to consider more display modes when switching 403 * refresh rates. Although we should generally stay within the primary range, specific 404 * considerations, such as layer frame rate settings specified via the setFrameRate() api, may 405 * cause us to go outside the primary range. We never go outside the app request range. The app 406 * request range will be greater than or equal to the primary refresh rate range, never smaller. 407 * 408 * defaultMode is used to narrow the list of display modes SurfaceFlinger will consider 409 * switching between. Only modes with a mode group and resolution matching defaultMode 410 * will be considered for switching. The defaultMode corresponds to an ID of mode in the list 411 * of supported modes returned from getDynamicDisplayInfo(). 412 */ 413 virtual status_t setDesiredDisplayModeSpecs( 414 const sp<IBinder>& displayToken, ui::DisplayModeId defaultMode, 415 bool allowGroupSwitching, float primaryRefreshRateMin, float primaryRefreshRateMax, 416 float appRequestRefreshRateMin, float appRequestRefreshRateMax) = 0; 417 418 virtual status_t getDesiredDisplayModeSpecs(const sp<IBinder>& displayToken, 419 ui::DisplayModeId* outDefaultMode, 420 bool* outAllowGroupSwitching, 421 float* outPrimaryRefreshRateMin, 422 float* outPrimaryRefreshRateMax, 423 float* outAppRequestRefreshRateMin, 424 float* outAppRequestRefreshRateMax) = 0; 425 /* 426 * Gets whether brightness operations are supported on a display. 427 * 428 * displayToken 429 * The token of the display. 430 * outSupport 431 * An output parameter for whether brightness operations are supported. 432 * 433 * Returns NO_ERROR upon success. Otherwise, 434 * NAME_NOT_FOUND if the display is invalid, or 435 * BAD_VALUE if the output parameter is invalid. 436 */ 437 virtual status_t getDisplayBrightnessSupport(const sp<IBinder>& displayToken, 438 bool* outSupport) const = 0; 439 440 /* 441 * Sets the brightness of a display. 442 * 443 * displayToken 444 * The token of the display whose brightness is set. 445 * brightness 446 * The DisplayBrightness info to set on the desired display. 447 * 448 * Returns NO_ERROR upon success. Otherwise, 449 * NAME_NOT_FOUND if the display is invalid, or 450 * BAD_VALUE if the brightness is invalid, or 451 * INVALID_OPERATION if brightness operations are not supported. 452 */ 453 virtual status_t setDisplayBrightness(const sp<IBinder>& displayToken, 454 const gui::DisplayBrightness& brightness) = 0; 455 456 /* 457 * Adds a listener that receives HDR layer information. This is used in combination 458 * with setDisplayBrightness to adjust the display brightness depending on factors such 459 * as whether or not HDR is in use. 460 * 461 * Returns NO_ERROR upon success or NAME_NOT_FOUND if the display is invalid. 462 */ 463 virtual status_t addHdrLayerInfoListener(const sp<IBinder>& displayToken, 464 const sp<gui::IHdrLayerInfoListener>& listener) = 0; 465 /* 466 * Removes a listener that was added with addHdrLayerInfoListener. 467 * 468 * Returns NO_ERROR upon success, NAME_NOT_FOUND if the display is invalid, and BAD_VALUE if 469 * the listener wasn't registered. 470 * 471 */ 472 virtual status_t removeHdrLayerInfoListener(const sp<IBinder>& displayToken, 473 const sp<gui::IHdrLayerInfoListener>& listener) = 0; 474 475 /* 476 * Sends a power boost to the composer. This function is asynchronous. 477 * 478 * boostId 479 * boost id according to android::hardware::power::Boost 480 * 481 * Returns NO_ERROR upon success. 482 */ 483 virtual status_t notifyPowerBoost(int32_t boostId) = 0; 484 485 /* 486 * Sets the global configuration for all the shadows drawn by SurfaceFlinger. Shadow follows 487 * material design guidelines. 488 * 489 * ambientColor 490 * Color to the ambient shadow. The alpha is premultiplied. 491 * 492 * spotColor 493 * Color to the spot shadow. The alpha is premultiplied. The position of the spot shadow 494 * depends on the light position. 495 * 496 * lightPosY/lightPosZ 497 * Position of the light used to cast the spot shadow. The X value is always the display 498 * width / 2. 499 * 500 * lightRadius 501 * Radius of the light casting the shadow. 502 */ 503 virtual status_t setGlobalShadowSettings(const half4& ambientColor, const half4& spotColor, 504 float lightPosY, float lightPosZ, 505 float lightRadius) = 0; 506 507 /* 508 * Sets the intended frame rate for a surface. See ANativeWindow_setFrameRate() for more info. 509 */ 510 virtual status_t setFrameRate(const sp<IGraphicBufferProducer>& surface, float frameRate, 511 int8_t compatibility, int8_t changeFrameRateStrategy) = 0; 512 513 /* 514 * Acquire a frame rate flexibility token from SurfaceFlinger. While this token is acquired, 515 * surface flinger will freely switch between frame rates in any way it sees fit, regardless of 516 * the current restrictions applied by DisplayManager. This is useful to get consistent behavior 517 * for tests. Release the token by releasing the returned IBinder reference. 518 */ 519 virtual status_t acquireFrameRateFlexibilityToken(sp<IBinder>* outToken) = 0; 520 521 /* 522 * Sets the frame timeline vsync info received from choreographer that corresponds to next 523 * buffer submitted on that surface. 524 */ 525 virtual status_t setFrameTimelineInfo(const sp<IGraphicBufferProducer>& surface, 526 const FrameTimelineInfo& frameTimelineInfo) = 0; 527 528 /* 529 * Adds a TransactionTraceListener to listen for transaction tracing state updates. 530 */ 531 virtual status_t addTransactionTraceListener( 532 const sp<gui::ITransactionTraceListener>& listener) = 0; 533 534 /** 535 * Gets priority of the RenderEngine in SurfaceFlinger. 536 */ 537 virtual int getGPUContextPriority() = 0; 538 539 /** 540 * Gets the number of buffers SurfaceFlinger would need acquire. This number 541 * would be propagated to the client via MIN_UNDEQUEUED_BUFFERS so that the 542 * client could allocate enough buffers to match SF expectations of the 543 * pipeline depth. SurfaceFlinger will make sure that it will give the app at 544 * least the time configured as the 'appDuration' before trying to latch 545 * the buffer. 546 * 547 * The total buffers needed for a given configuration is basically the 548 * numbers of vsyncs a single buffer is used across the stack. For the default 549 * configuration a buffer is held ~1 vsync by the app, ~1 vsync by SurfaceFlinger 550 * and 1 vsync by the display. The extra buffers are calculated as the 551 * number of additional buffers on top of the 2 buffers already present 552 * in MIN_UNDEQUEUED_BUFFERS. 553 */ 554 virtual status_t getMaxAcquiredBufferCount(int* buffers) const = 0; 555 }; 556 557 // ---------------------------------------------------------------------------- 558 559 class BnSurfaceComposer: public BnInterface<ISurfaceComposer> { 560 public: 561 enum ISurfaceComposerTag { 562 // Note: BOOT_FINISHED must remain this value, it is called from 563 // Java by ActivityManagerService. 564 BOOT_FINISHED = IBinder::FIRST_CALL_TRANSACTION, 565 CREATE_CONNECTION, 566 GET_STATIC_DISPLAY_INFO, 567 CREATE_DISPLAY_EVENT_CONNECTION, 568 CREATE_DISPLAY, 569 DESTROY_DISPLAY, 570 GET_PHYSICAL_DISPLAY_TOKEN, 571 SET_TRANSACTION_STATE, 572 AUTHENTICATE_SURFACE, 573 GET_SUPPORTED_FRAME_TIMESTAMPS, 574 GET_DISPLAY_MODES, // Deprecated. Use GET_DYNAMIC_DISPLAY_INFO instead. 575 GET_ACTIVE_DISPLAY_MODE, // Deprecated. Use GET_DYNAMIC_DISPLAY_INFO instead. 576 GET_DISPLAY_STATE, 577 CAPTURE_DISPLAY, 578 CAPTURE_LAYERS, 579 CLEAR_ANIMATION_FRAME_STATS, 580 GET_ANIMATION_FRAME_STATS, 581 SET_POWER_MODE, 582 GET_DISPLAY_STATS, 583 GET_HDR_CAPABILITIES, // Deprecated. Use GET_DYNAMIC_DISPLAY_INFO instead. 584 GET_DISPLAY_COLOR_MODES, // Deprecated. Use GET_DYNAMIC_DISPLAY_INFO instead. 585 GET_ACTIVE_COLOR_MODE, // Deprecated. Use GET_DYNAMIC_DISPLAY_INFO instead. 586 SET_ACTIVE_COLOR_MODE, 587 ENABLE_VSYNC_INJECTIONS, 588 INJECT_VSYNC, 589 GET_LAYER_DEBUG_INFO, 590 GET_COMPOSITION_PREFERENCE, 591 GET_COLOR_MANAGEMENT, 592 GET_DISPLAYED_CONTENT_SAMPLING_ATTRIBUTES, 593 SET_DISPLAY_CONTENT_SAMPLING_ENABLED, 594 GET_DISPLAYED_CONTENT_SAMPLE, 595 GET_PROTECTED_CONTENT_SUPPORT, 596 IS_WIDE_COLOR_DISPLAY, 597 GET_DISPLAY_NATIVE_PRIMARIES, 598 GET_PHYSICAL_DISPLAY_IDS, 599 ADD_REGION_SAMPLING_LISTENER, 600 REMOVE_REGION_SAMPLING_LISTENER, 601 SET_DESIRED_DISPLAY_MODE_SPECS, 602 GET_DESIRED_DISPLAY_MODE_SPECS, 603 GET_DISPLAY_BRIGHTNESS_SUPPORT, 604 SET_DISPLAY_BRIGHTNESS, 605 CAPTURE_DISPLAY_BY_ID, 606 NOTIFY_POWER_BOOST, 607 SET_GLOBAL_SHADOW_SETTINGS, 608 GET_AUTO_LOW_LATENCY_MODE_SUPPORT, // Deprecated. Use GET_DYNAMIC_DISPLAY_INFO instead. 609 SET_AUTO_LOW_LATENCY_MODE, 610 GET_GAME_CONTENT_TYPE_SUPPORT, // Deprecated. Use GET_DYNAMIC_DISPLAY_INFO instead. 611 SET_GAME_CONTENT_TYPE, 612 SET_FRAME_RATE, 613 ACQUIRE_FRAME_RATE_FLEXIBILITY_TOKEN, 614 SET_FRAME_TIMELINE_INFO, 615 ADD_TRANSACTION_TRACE_LISTENER, 616 GET_GPU_CONTEXT_PRIORITY, 617 GET_MAX_ACQUIRED_BUFFER_COUNT, 618 GET_DYNAMIC_DISPLAY_INFO, 619 ADD_FPS_LISTENER, 620 REMOVE_FPS_LISTENER, 621 OVERRIDE_HDR_TYPES, 622 ADD_HDR_LAYER_INFO_LISTENER, 623 REMOVE_HDR_LAYER_INFO_LISTENER, 624 ON_PULL_ATOM, 625 ADD_TUNNEL_MODE_ENABLED_LISTENER, 626 REMOVE_TUNNEL_MODE_ENABLED_LISTENER, 627 // Always append new enum to the end. 628 }; 629 630 virtual status_t onTransact(uint32_t code, const Parcel& data, 631 Parcel* reply, uint32_t flags = 0); 632 }; 633 634 } // namespace android 635