services/surfaceflinger/DisplayDevice.cpp - SHIFTPHONES/android_frameworks_native - Gitiles

 /*
  * Copyright (C) 2007 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.
  */

 // TODO(b/129481165): remove the #pragma below and fix conversion issues
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wconversion"

 // #define LOG_NDEBUG 0
 #undef LOG_TAG
 #define LOG_TAG "DisplayDevice"

 #define ATRACE_TAG ATRACE_TAG_GRAPHICS

 #include <compositionengine/CompositionEngine.h>
 #include <compositionengine/Display.h>
 #include <compositionengine/DisplayColorProfile.h>
 #include <compositionengine/DisplayColorProfileCreationArgs.h>
 #include <compositionengine/DisplayCreationArgs.h>
 #include <compositionengine/DisplaySurface.h>
 #include <compositionengine/ProjectionSpace.h>
 #include <compositionengine/RenderSurface.h>
 #include <compositionengine/RenderSurfaceCreationArgs.h>
 #include <compositionengine/impl/OutputCompositionState.h>
 #include <configstore/Utils.h>
 #include <log/log.h>
 #include <system/window.h>
 #include <ui/GraphicTypes.h>

 #include "DisplayDevice.h"
 #include "Layer.h"
 #include "RefreshRateOverlay.h"
 #include "SurfaceFlinger.h"

 namespace android {

 namespace hal = hardware::graphics::composer::hal;

 ui::Transform::RotationFlags DisplayDevice::sPrimaryDisplayRotationFlags = ui::Transform::ROT_0;

 DisplayDeviceCreationArgs::DisplayDeviceCreationArgs(
         const sp<SurfaceFlinger>& flinger, HWComposer& hwComposer, const wp<IBinder>& displayToken,
         std::shared_ptr<compositionengine::Display> compositionDisplay)
       : flinger(flinger),
         hwComposer(hwComposer),
         displayToken(displayToken),
         compositionDisplay(compositionDisplay) {}

 DisplayDevice::DisplayDevice(DisplayDeviceCreationArgs& args)
       : mFlinger(args.flinger),
         mHwComposer(args.hwComposer),
         mDisplayToken(args.displayToken),
         mSequenceId(args.sequenceId),
         mConnectionType(args.connectionType),
         mCompositionDisplay{args.compositionDisplay},
         mActiveModeFPSTrace("ActiveModeFPS -" + to_string(getId())),
         mActiveModeFPSHwcTrace("ActiveModeFPS_HWC -" + to_string(getId())),
         mPhysicalOrientation(args.physicalOrientation),
         mSupportedModes(std::move(args.supportedModes)),
         mIsPrimary(args.isPrimary),
         mRefreshRateConfigs(std::move(args.refreshRateConfigs)) {
     mCompositionDisplay->editState().isSecure = args.isSecure;
     mCompositionDisplay->createRenderSurface(
             compositionengine::RenderSurfaceCreationArgsBuilder()
                     .setDisplayWidth(ANativeWindow_getWidth(args.nativeWindow.get()))
                     .setDisplayHeight(ANativeWindow_getHeight(args.nativeWindow.get()))
                     .setNativeWindow(std::move(args.nativeWindow))
                     .setDisplaySurface(std::move(args.displaySurface))
                     .setMaxTextureCacheSize(
                             static_cast<size_t>(SurfaceFlinger::maxFrameBufferAcquiredBuffers))
                     .build());

     if (!mFlinger->mDisableClientCompositionCache &&
         SurfaceFlinger::maxFrameBufferAcquiredBuffers > 0) {
         mCompositionDisplay->createClientCompositionCache(
                 static_cast<uint32_t>(SurfaceFlinger::maxFrameBufferAcquiredBuffers));
     }

     mCompositionDisplay->setPredictCompositionStrategy(mFlinger->mPredictCompositionStrategy);
     mCompositionDisplay->setTreat170mAsSrgb(mFlinger->mTreat170mAsSrgb);
     mCompositionDisplay->createDisplayColorProfile(
             compositionengine::DisplayColorProfileCreationArgsBuilder()
                     .setHasWideColorGamut(args.hasWideColorGamut)
                     .setHdrCapabilities(std::move(args.hdrCapabilities))
                     .setSupportedPerFrameMetadata(args.supportedPerFrameMetadata)
                     .setHwcColorModes(std::move(args.hwcColorModes))
                     .Build());

     if (!mCompositionDisplay->isValid()) {
         ALOGE("Composition Display did not validate!");
     }

     mCompositionDisplay->getRenderSurface()->initialize();

     setPowerMode(args.initialPowerMode);

     // initialize the display orientation transform.
     setProjection(ui::ROTATION_0, Rect::INVALID_RECT, Rect::INVALID_RECT);
 }

 DisplayDevice::~DisplayDevice() = default;

 void DisplayDevice::disconnect() {
     mCompositionDisplay->disconnect();
 }

 int DisplayDevice::getWidth() const {
     return mCompositionDisplay->getState().displaySpace.getBounds().width;
 }

 int DisplayDevice::getHeight() const {
     return mCompositionDisplay->getState().displaySpace.getBounds().height;
 }

 void DisplayDevice::setDisplayName(const std::string& displayName) {
     if (!displayName.empty()) {
         // never override the name with an empty name
         mDisplayName = displayName;
         mCompositionDisplay->setName(displayName);
     }
 }

 void DisplayDevice::setDeviceProductInfo(std::optional<DeviceProductInfo> info) {
     mDeviceProductInfo = std::move(info);
 }

 uint32_t DisplayDevice::getPageFlipCount() const {
     return mCompositionDisplay->getRenderSurface()->getPageFlipCount();
 }

 auto DisplayDevice::getInputInfo() const -> InputInfo {
     gui::DisplayInfo info;
     info.displayId = getLayerStack().id;

     // The physical orientation is set when the orientation of the display panel is
     // different than the default orientation of the device. Other services like
     // InputFlinger do not know about this, so we do not need to expose the physical
     // orientation of the panel outside of SurfaceFlinger.
     const ui::Rotation inversePhysicalOrientation = ui::ROTATION_0 - mPhysicalOrientation;
     auto width = getWidth();
     auto height = getHeight();
     if (inversePhysicalOrientation == ui::ROTATION_90 ||
         inversePhysicalOrientation == ui::ROTATION_270) {
         std::swap(width, height);
     }
     const ui::Transform undoPhysicalOrientation(ui::Transform::toRotationFlags(
                                                         inversePhysicalOrientation),
                                                 width, height);
     const auto& displayTransform = undoPhysicalOrientation * getTransform();
     // Send the inverse display transform to input so it can convert display coordinates to
     // logical display.
     info.transform = displayTransform.inverse();

     info.logicalWidth = getLayerStackSpaceRect().width();
     info.logicalHeight = getLayerStackSpaceRect().height();

     return {.info = info,
             .transform = displayTransform,
             .receivesInput = receivesInput(),
             .isSecure = isSecure()};
 }

 void DisplayDevice::setPowerMode(hal::PowerMode mode) {
     mPowerMode = mode;
     getCompositionDisplay()->setCompositionEnabled(mPowerMode != hal::PowerMode::OFF);
 }

 void DisplayDevice::enableLayerCaching(bool enable) {
     getCompositionDisplay()->setLayerCachingEnabled(enable);
 }

 hal::PowerMode DisplayDevice::getPowerMode() const {
     return mPowerMode;
 }

 bool DisplayDevice::isPoweredOn() const {
     return mPowerMode != hal::PowerMode::OFF;
 }

 void DisplayDevice::setActiveMode(DisplayModeId id) {
     const auto mode = getMode(id);
     LOG_FATAL_IF(!mode, "Cannot set active mode which is not supported.");
     ATRACE_INT(mActiveModeFPSTrace.c_str(), mode->getFps().getIntValue());
     mActiveMode = mode;
     if (mRefreshRateConfigs) {
         mRefreshRateConfigs->setActiveModeId(mActiveMode->getId());
     }
     if (mRefreshRateOverlay) {
         mRefreshRateOverlay->changeRefreshRate(mActiveMode->getFps());
     }
 }

 status_t DisplayDevice::initiateModeChange(const ActiveModeInfo& info,
                                            const hal::VsyncPeriodChangeConstraints& constraints,
                                            hal::VsyncPeriodChangeTimeline* outTimeline) {
     if (!info.mode || info.mode->getPhysicalDisplayId() != getPhysicalId()) {
         ALOGE("Trying to initiate a mode change to invalid mode %s on display %s",
               info.mode ? std::to_string(info.mode->getId().value()).c_str() : "null",
               to_string(getId()).c_str());
         return BAD_VALUE;
     }
     mUpcomingActiveMode = info;
     ATRACE_INT(mActiveModeFPSHwcTrace.c_str(), info.mode->getFps().getIntValue());
     return mHwComposer.setActiveModeWithConstraints(getPhysicalId(), info.mode->getHwcId(),
                                                     constraints, outTimeline);
 }

 const DisplayModePtr& DisplayDevice::getActiveMode() const {
     return mActiveMode;
 }

 const DisplayModes& DisplayDevice::getSupportedModes() const {
     return mSupportedModes;
 }

 DisplayModePtr DisplayDevice::getMode(DisplayModeId modeId) const {
     const DisplayModePtr nullMode;
     return mSupportedModes.get(modeId).value_or(std::cref(nullMode));
 }

 std::optional<DisplayModeId> DisplayDevice::translateModeId(hal::HWConfigId hwcId) const {
     const auto it =
             std::find_if(mSupportedModes.begin(), mSupportedModes.end(),
                          [hwcId](const auto& pair) { return pair.second->getHwcId() == hwcId; });
     if (it != mSupportedModes.end()) {
         return it->second->getId();
     }
     return {};
 }

 nsecs_t DisplayDevice::getVsyncPeriodFromHWC() const {
     const auto physicalId = getPhysicalId();
     if (!mHwComposer.isConnected(physicalId)) {
         return 0;
     }

     nsecs_t vsyncPeriod;
     const auto status = mHwComposer.getDisplayVsyncPeriod(physicalId, &vsyncPeriod);
     if (status == NO_ERROR) {
         return vsyncPeriod;
     }

     return getActiveMode()->getFps().getPeriodNsecs();
 }

 nsecs_t DisplayDevice::getRefreshTimestamp() const {
     const nsecs_t now = systemTime(CLOCK_MONOTONIC);
     const auto vsyncPeriodNanos = getVsyncPeriodFromHWC();
     return now - ((now - mLastHwVsync) % vsyncPeriodNanos);
 }

 void DisplayDevice::onVsync(nsecs_t timestamp) {
     mLastHwVsync = timestamp;
 }

 ui::Dataspace DisplayDevice::getCompositionDataSpace() const {
     return mCompositionDisplay->getState().dataspace;
 }

 void DisplayDevice::setLayerStack(ui::LayerStack stack) {
     mCompositionDisplay->setLayerFilter({stack, isInternal()});
     if (mRefreshRateOverlay) {
         mRefreshRateOverlay->setLayerStack(stack);
     }
 }

 void DisplayDevice::setFlags(uint32_t flags) {
     mFlags = flags;
 }

 void DisplayDevice::setDisplaySize(int width, int height) {
     LOG_FATAL_IF(!isVirtual(), "Changing the display size is supported only for virtual displays.");
     const auto size = ui::Size(width, height);
     mCompositionDisplay->setDisplaySize(size);
     if (mRefreshRateOverlay) {
         mRefreshRateOverlay->setViewport(size);
     }
 }

 void DisplayDevice::setProjection(ui::Rotation orientation, Rect layerStackSpaceRect,
                                   Rect orientedDisplaySpaceRect) {
     mOrientation = orientation;

     if (isPrimary()) {
         sPrimaryDisplayRotationFlags = ui::Transform::toRotationFlags(orientation);
     }

     // We need to take care of display rotation for globalTransform for case if the panel is not
     // installed aligned with device orientation.
     const auto transformOrientation = orientation + mPhysicalOrientation;

     const auto& state = getCompositionDisplay()->getState();

     // If the layer stack and destination frames have never been set, then configure them to be the
     // same as the physical device, taking into account the total transform.
     if (!orientedDisplaySpaceRect.isValid()) {
         ui::Size bounds = state.displaySpace.getBounds();
         bounds.rotate(transformOrientation);
         orientedDisplaySpaceRect = Rect(bounds);
     }
     if (layerStackSpaceRect.isEmpty()) {
         ui::Size bounds = state.framebufferSpace.getBounds();
         bounds.rotate(transformOrientation);
         layerStackSpaceRect = Rect(bounds);
     }
     getCompositionDisplay()->setProjection(transformOrientation, layerStackSpaceRect,
                                            orientedDisplaySpaceRect);
 }

 void DisplayDevice::stageBrightness(float brightness) {
     mStagedBrightness = brightness;
 }

 void DisplayDevice::persistBrightness(bool needsComposite) {
     if (needsComposite && mStagedBrightness && mBrightness != *mStagedBrightness) {
         getCompositionDisplay()->setNextBrightness(*mStagedBrightness);
         mBrightness = *mStagedBrightness;
     }
     mStagedBrightness = std::nullopt;
 }

 std::optional<float> DisplayDevice::getStagedBrightness() const {
     return mStagedBrightness;
 }

 ui::Transform::RotationFlags DisplayDevice::getPrimaryDisplayRotationFlags() {
     return sPrimaryDisplayRotationFlags;
 }

 std::string DisplayDevice::getDebugName() const {
     using namespace std::string_literals;

     std::string name = "Display "s + to_string(getId()) + " ("s;

     if (mConnectionType) {
         name += isInternal() ? "internal"s : "external"s;
     } else {
         name += "virtual"s;
     }

     if (isPrimary()) {
         name += ", primary"s;
     }

     return name + ", \""s + mDisplayName + "\")"s;
 }

 void DisplayDevice::dump(std::string& result) const {
     using namespace std::string_literals;

     result += getDebugName();

     if (!isVirtual()) {
         result += "\n   deviceProductInfo="s;
         if (mDeviceProductInfo) {
             mDeviceProductInfo->dump(result);
         } else {
             result += "{}"s;
         }
     }

     result += "\n   powerMode="s;
     result += to_string(mPowerMode);
     result += '\n';

     if (mRefreshRateConfigs) {
         mRefreshRateConfigs->dump(result);
     }
 }

 bool DisplayDevice::hasRenderIntent(ui::RenderIntent intent) const {
     return mCompositionDisplay->getDisplayColorProfile()->hasRenderIntent(intent);
 }

 DisplayId DisplayDevice::getId() const {
     return mCompositionDisplay->getId();
 }

 bool DisplayDevice::isSecure() const {
     return mCompositionDisplay->isSecure();
 }

 const Rect DisplayDevice::getBounds() const {
     return mCompositionDisplay->getState().displaySpace.getBoundsAsRect();
 }

 const Region& DisplayDevice::getUndefinedRegion() const {
     return mCompositionDisplay->getState().undefinedRegion;
 }

 bool DisplayDevice::needsFiltering() const {
     return mCompositionDisplay->getState().needsFiltering;
 }

 ui::LayerStack DisplayDevice::getLayerStack() const {
     return mCompositionDisplay->getState().layerFilter.layerStack;
 }

 ui::Transform::RotationFlags DisplayDevice::getTransformHint() const {
     return mCompositionDisplay->getTransformHint();
 }

 const ui::Transform& DisplayDevice::getTransform() const {
     return mCompositionDisplay->getState().transform;
 }

 const Rect& DisplayDevice::getLayerStackSpaceRect() const {
     return mCompositionDisplay->getState().layerStackSpace.getContent();
 }

 const Rect& DisplayDevice::getOrientedDisplaySpaceRect() const {
     return mCompositionDisplay->getState().orientedDisplaySpace.getContent();
 }

 bool DisplayDevice::hasWideColorGamut() const {
     return mCompositionDisplay->getDisplayColorProfile()->hasWideColorGamut();
 }

 bool DisplayDevice::hasHDR10PlusSupport() const {
     return mCompositionDisplay->getDisplayColorProfile()->hasHDR10PlusSupport();
 }

 bool DisplayDevice::hasHDR10Support() const {
     return mCompositionDisplay->getDisplayColorProfile()->hasHDR10Support();
 }

 bool DisplayDevice::hasHLGSupport() const {
     return mCompositionDisplay->getDisplayColorProfile()->hasHLGSupport();
 }

 bool DisplayDevice::hasDolbyVisionSupport() const {
     return mCompositionDisplay->getDisplayColorProfile()->hasDolbyVisionSupport();
 }

 int DisplayDevice::getSupportedPerFrameMetadata() const {
     return mCompositionDisplay->getDisplayColorProfile()->getSupportedPerFrameMetadata();
 }

 void DisplayDevice::overrideHdrTypes(const std::vector<ui::Hdr>& hdrTypes) {
     mOverrideHdrTypes = hdrTypes;
 }

 HdrCapabilities DisplayDevice::getHdrCapabilities() const {
     const HdrCapabilities& capabilities =
             mCompositionDisplay->getDisplayColorProfile()->getHdrCapabilities();
     std::vector<ui::Hdr> hdrTypes = capabilities.getSupportedHdrTypes();
     if (!mOverrideHdrTypes.empty()) {
         hdrTypes = mOverrideHdrTypes;
     }
     return HdrCapabilities(hdrTypes, capabilities.getDesiredMaxLuminance(),
                            capabilities.getDesiredMaxAverageLuminance(),
                            capabilities.getDesiredMinLuminance());
 }

 void DisplayDevice::enableRefreshRateOverlay(bool enable, bool showSpinnner) {
     if (!enable) {
         mRefreshRateOverlay.reset();
         return;
     }

     const auto fpsRange = mRefreshRateConfigs->getSupportedRefreshRateRange();
     mRefreshRateOverlay = std::make_unique<RefreshRateOverlay>(fpsRange, showSpinnner);
     mRefreshRateOverlay->setLayerStack(getLayerStack());
     mRefreshRateOverlay->setViewport(getSize());
     mRefreshRateOverlay->changeRefreshRate(getActiveMode()->getFps());
 }

 bool DisplayDevice::onKernelTimerChanged(std::optional<DisplayModeId> desiredModeId,
                                          bool timerExpired) {
     if (mRefreshRateConfigs && mRefreshRateOverlay) {
         const auto newRefreshRate =
                 mRefreshRateConfigs->onKernelTimerChanged(desiredModeId, timerExpired);
         if (newRefreshRate) {
             mRefreshRateOverlay->changeRefreshRate(*newRefreshRate);
             return true;
         }
     }

     return false;
 }

 void DisplayDevice::animateRefreshRateOverlay() {
     if (mRefreshRateOverlay) {
         mRefreshRateOverlay->animate();
     }
 }

 bool DisplayDevice::setDesiredActiveMode(const ActiveModeInfo& info) {
     ATRACE_CALL();

     LOG_ALWAYS_FATAL_IF(!info.mode, "desired mode not provided");
     LOG_ALWAYS_FATAL_IF(getPhysicalId() != info.mode->getPhysicalDisplayId(), "DisplayId mismatch");

     ALOGV("%s(%s)", __func__, to_string(*info.mode).c_str());

     std::scoped_lock lock(mActiveModeLock);
     if (mDesiredActiveModeChanged) {
         // If a mode change is pending, just cache the latest request in mDesiredActiveMode
         const auto prevConfig = mDesiredActiveMode.event;
         mDesiredActiveMode = info;
         mDesiredActiveMode.event = mDesiredActiveMode.event | prevConfig;
         return false;
     }

     // Check if we are already at the desired mode
     if (getActiveMode()->getId() == info.mode->getId()) {
         return false;
     }

     // Initiate a mode change.
     mDesiredActiveModeChanged = true;
     mDesiredActiveMode = info;
     return true;
 }

 std::optional<DisplayDevice::ActiveModeInfo> DisplayDevice::getDesiredActiveMode() const {
     std::scoped_lock lock(mActiveModeLock);
     if (mDesiredActiveModeChanged) return mDesiredActiveMode;
     return std::nullopt;
 }

 void DisplayDevice::clearDesiredActiveModeState() {
     std::scoped_lock lock(mActiveModeLock);
     mDesiredActiveMode.event = scheduler::DisplayModeEvent::None;
     mDesiredActiveModeChanged = false;
 }

 std::atomic<int32_t> DisplayDeviceState::sNextSequenceId(1);

 }  // namespace android

 // TODO(b/129481165): remove the #pragma below and fix conversion issues
 #pragma clang diagnostic pop // ignored "-Wconversion"
	/*
	* Copyright (C) 2007 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.
	*/

	// TODO(b/129481165): remove the #pragma below and fix conversion issues
	#pragma clang diagnostic push
	#pragma clang diagnostic ignored "-Wconversion"

	// #define LOG_NDEBUG 0
	#undef LOG_TAG
	#define LOG_TAG "DisplayDevice"

	#define ATRACE_TAG ATRACE_TAG_GRAPHICS

	#include <compositionengine/CompositionEngine.h>
	#include <compositionengine/Display.h>
	#include <compositionengine/DisplayColorProfile.h>
	#include <compositionengine/DisplayColorProfileCreationArgs.h>
	#include <compositionengine/DisplayCreationArgs.h>
	#include <compositionengine/DisplaySurface.h>
	#include <compositionengine/ProjectionSpace.h>
	#include <compositionengine/RenderSurface.h>
	#include <compositionengine/RenderSurfaceCreationArgs.h>
	#include <compositionengine/impl/OutputCompositionState.h>
	#include <configstore/Utils.h>
	#include <log/log.h>
	#include <system/window.h>
	#include <ui/GraphicTypes.h>

	#include "DisplayDevice.h"
	#include "Layer.h"
	#include "RefreshRateOverlay.h"
	#include "SurfaceFlinger.h"

	namespace android {

	namespace hal = hardware::graphics::composer::hal;

	ui::Transform::RotationFlags DisplayDevice::sPrimaryDisplayRotationFlags = ui::Transform::ROT_0;

	DisplayDeviceCreationArgs::DisplayDeviceCreationArgs(
	const sp<SurfaceFlinger>& flinger, HWComposer& hwComposer, const wp<IBinder>& displayToken,
	std::shared_ptr<compositionengine::Display> compositionDisplay)
	: flinger(flinger),
	hwComposer(hwComposer),
	displayToken(displayToken),
	compositionDisplay(compositionDisplay) {}

	DisplayDevice::DisplayDevice(DisplayDeviceCreationArgs& args)
	: mFlinger(args.flinger),
	mHwComposer(args.hwComposer),
	mDisplayToken(args.displayToken),
	mSequenceId(args.sequenceId),
	mConnectionType(args.connectionType),
	mCompositionDisplay{args.compositionDisplay},
	mActiveModeFPSTrace("ActiveModeFPS -" + to_string(getId())),
	mActiveModeFPSHwcTrace("ActiveModeFPS_HWC -" + to_string(getId())),
	mPhysicalOrientation(args.physicalOrientation),
	mSupportedModes(std::move(args.supportedModes)),
	mIsPrimary(args.isPrimary),
	mRefreshRateConfigs(std::move(args.refreshRateConfigs)) {
	mCompositionDisplay->editState().isSecure = args.isSecure;
	mCompositionDisplay->createRenderSurface(
	compositionengine::RenderSurfaceCreationArgsBuilder()
	.setDisplayWidth(ANativeWindow_getWidth(args.nativeWindow.get()))
	.setDisplayHeight(ANativeWindow_getHeight(args.nativeWindow.get()))
	.setNativeWindow(std::move(args.nativeWindow))
	.setDisplaySurface(std::move(args.displaySurface))
	.setMaxTextureCacheSize(
	static_cast<size_t>(SurfaceFlinger::maxFrameBufferAcquiredBuffers))
	.build());

	if (!mFlinger->mDisableClientCompositionCache &&
	SurfaceFlinger::maxFrameBufferAcquiredBuffers > 0) {
	mCompositionDisplay->createClientCompositionCache(
	static_cast<uint32_t>(SurfaceFlinger::maxFrameBufferAcquiredBuffers));
	}

	mCompositionDisplay->setPredictCompositionStrategy(mFlinger->mPredictCompositionStrategy);
	mCompositionDisplay->setTreat170mAsSrgb(mFlinger->mTreat170mAsSrgb);
	mCompositionDisplay->createDisplayColorProfile(
	compositionengine::DisplayColorProfileCreationArgsBuilder()
	.setHasWideColorGamut(args.hasWideColorGamut)
	.setHdrCapabilities(std::move(args.hdrCapabilities))
	.setSupportedPerFrameMetadata(args.supportedPerFrameMetadata)
	.setHwcColorModes(std::move(args.hwcColorModes))
	.Build());

	if (!mCompositionDisplay->isValid()) {
	ALOGE("Composition Display did not validate!");
	}

	mCompositionDisplay->getRenderSurface()->initialize();

	setPowerMode(args.initialPowerMode);

	// initialize the display orientation transform.
	setProjection(ui::ROTATION_0, Rect::INVALID_RECT, Rect::INVALID_RECT);
	}

	DisplayDevice::~DisplayDevice() = default;

	void DisplayDevice::disconnect() {
	mCompositionDisplay->disconnect();
	}

	int DisplayDevice::getWidth() const {
	return mCompositionDisplay->getState().displaySpace.getBounds().width;
	}

	int DisplayDevice::getHeight() const {
	return mCompositionDisplay->getState().displaySpace.getBounds().height;
	}

	void DisplayDevice::setDisplayName(const std::string& displayName) {
	if (!displayName.empty()) {
	// never override the name with an empty name
	mDisplayName = displayName;
	mCompositionDisplay->setName(displayName);
	}
	}

	void DisplayDevice::setDeviceProductInfo(std::optional<DeviceProductInfo> info) {
	mDeviceProductInfo = std::move(info);
	}

	uint32_t DisplayDevice::getPageFlipCount() const {
	return mCompositionDisplay->getRenderSurface()->getPageFlipCount();
	}

	auto DisplayDevice::getInputInfo() const -> InputInfo {
	gui::DisplayInfo info;
	info.displayId = getLayerStack().id;

	// The physical orientation is set when the orientation of the display panel is
	// different than the default orientation of the device. Other services like
	// InputFlinger do not know about this, so we do not need to expose the physical
	// orientation of the panel outside of SurfaceFlinger.
	const ui::Rotation inversePhysicalOrientation = ui::ROTATION_0 - mPhysicalOrientation;
	auto width = getWidth();
	auto height = getHeight();
	if (inversePhysicalOrientation == ui::ROTATION_90 \|\|
	inversePhysicalOrientation == ui::ROTATION_270) {
	std::swap(width, height);
	}
	const ui::Transform undoPhysicalOrientation(ui::Transform::toRotationFlags(
	inversePhysicalOrientation),
	width, height);
	const auto& displayTransform = undoPhysicalOrientation * getTransform();
	// Send the inverse display transform to input so it can convert display coordinates to
	// logical display.
	info.transform = displayTransform.inverse();

	info.logicalWidth = getLayerStackSpaceRect().width();
	info.logicalHeight = getLayerStackSpaceRect().height();

	return {.info = info,
	.transform = displayTransform,
	.receivesInput = receivesInput(),
	.isSecure = isSecure()};
	}

	void DisplayDevice::setPowerMode(hal::PowerMode mode) {
	mPowerMode = mode;
	getCompositionDisplay()->setCompositionEnabled(mPowerMode != hal::PowerMode::OFF);
	}

	void DisplayDevice::enableLayerCaching(bool enable) {
	getCompositionDisplay()->setLayerCachingEnabled(enable);
	}

	hal::PowerMode DisplayDevice::getPowerMode() const {
	return mPowerMode;
	}

	bool DisplayDevice::isPoweredOn() const {
	return mPowerMode != hal::PowerMode::OFF;
	}

	void DisplayDevice::setActiveMode(DisplayModeId id) {
	const auto mode = getMode(id);
	LOG_FATAL_IF(!mode, "Cannot set active mode which is not supported.");
	ATRACE_INT(mActiveModeFPSTrace.c_str(), mode->getFps().getIntValue());
	mActiveMode = mode;
	if (mRefreshRateConfigs) {
	mRefreshRateConfigs->setActiveModeId(mActiveMode->getId());
	}
	if (mRefreshRateOverlay) {
	mRefreshRateOverlay->changeRefreshRate(mActiveMode->getFps());
	}
	}

	status_t DisplayDevice::initiateModeChange(const ActiveModeInfo& info,
	const hal::VsyncPeriodChangeConstraints& constraints,
	hal::VsyncPeriodChangeTimeline* outTimeline) {
	if (!info.mode \|\| info.mode->getPhysicalDisplayId() != getPhysicalId()) {
	ALOGE("Trying to initiate a mode change to invalid mode %s on display %s",
	info.mode ? std::to_string(info.mode->getId().value()).c_str() : "null",
	to_string(getId()).c_str());
	return BAD_VALUE;
	}
	mUpcomingActiveMode = info;
	ATRACE_INT(mActiveModeFPSHwcTrace.c_str(), info.mode->getFps().getIntValue());
	return mHwComposer.setActiveModeWithConstraints(getPhysicalId(), info.mode->getHwcId(),
	constraints, outTimeline);
	}

	const DisplayModePtr& DisplayDevice::getActiveMode() const {
	return mActiveMode;
	}

	const DisplayModes& DisplayDevice::getSupportedModes() const {
	return mSupportedModes;
	}

	DisplayModePtr DisplayDevice::getMode(DisplayModeId modeId) const {
	const DisplayModePtr nullMode;
	return mSupportedModes.get(modeId).value_or(std::cref(nullMode));
	}

	std::optional<DisplayModeId> DisplayDevice::translateModeId(hal::HWConfigId hwcId) const {
	const auto it =
	std::find_if(mSupportedModes.begin(), mSupportedModes.end(),
	[hwcId](const auto& pair) { return pair.second->getHwcId() == hwcId; });
	if (it != mSupportedModes.end()) {
	return it->second->getId();
	}
	return {};
	}

	nsecs_t DisplayDevice::getVsyncPeriodFromHWC() const {
	const auto physicalId = getPhysicalId();
	if (!mHwComposer.isConnected(physicalId)) {
	return 0;
	}

	nsecs_t vsyncPeriod;
	const auto status = mHwComposer.getDisplayVsyncPeriod(physicalId, &vsyncPeriod);
	if (status == NO_ERROR) {
	return vsyncPeriod;
	}

	return getActiveMode()->getFps().getPeriodNsecs();
	}

	nsecs_t DisplayDevice::getRefreshTimestamp() const {
	const nsecs_t now = systemTime(CLOCK_MONOTONIC);
	const auto vsyncPeriodNanos = getVsyncPeriodFromHWC();
	return now - ((now - mLastHwVsync) % vsyncPeriodNanos);
	}

	void DisplayDevice::onVsync(nsecs_t timestamp) {
	mLastHwVsync = timestamp;
	}

	ui::Dataspace DisplayDevice::getCompositionDataSpace() const {
	return mCompositionDisplay->getState().dataspace;
	}

	void DisplayDevice::setLayerStack(ui::LayerStack stack) {
	mCompositionDisplay->setLayerFilter({stack, isInternal()});
	if (mRefreshRateOverlay) {
	mRefreshRateOverlay->setLayerStack(stack);
	}
	}

	void DisplayDevice::setFlags(uint32_t flags) {
	mFlags = flags;
	}

	void DisplayDevice::setDisplaySize(int width, int height) {
	LOG_FATAL_IF(!isVirtual(), "Changing the display size is supported only for virtual displays.");
	const auto size = ui::Size(width, height);
	mCompositionDisplay->setDisplaySize(size);
	if (mRefreshRateOverlay) {
	mRefreshRateOverlay->setViewport(size);
	}
	}

	void DisplayDevice::setProjection(ui::Rotation orientation, Rect layerStackSpaceRect,
	Rect orientedDisplaySpaceRect) {
	mOrientation = orientation;

	if (isPrimary()) {
	sPrimaryDisplayRotationFlags = ui::Transform::toRotationFlags(orientation);
	}

	// We need to take care of display rotation for globalTransform for case if the panel is not
	// installed aligned with device orientation.
	const auto transformOrientation = orientation + mPhysicalOrientation;

	const auto& state = getCompositionDisplay()->getState();

	// If the layer stack and destination frames have never been set, then configure them to be the
	// same as the physical device, taking into account the total transform.
	if (!orientedDisplaySpaceRect.isValid()) {
	ui::Size bounds = state.displaySpace.getBounds();
	bounds.rotate(transformOrientation);
	orientedDisplaySpaceRect = Rect(bounds);
	}
	if (layerStackSpaceRect.isEmpty()) {
	ui::Size bounds = state.framebufferSpace.getBounds();
	bounds.rotate(transformOrientation);
	layerStackSpaceRect = Rect(bounds);
	}
	getCompositionDisplay()->setProjection(transformOrientation, layerStackSpaceRect,
	orientedDisplaySpaceRect);
	}

	void DisplayDevice::stageBrightness(float brightness) {
	mStagedBrightness = brightness;
	}

	void DisplayDevice::persistBrightness(bool needsComposite) {
	if (needsComposite && mStagedBrightness && mBrightness != *mStagedBrightness) {
	getCompositionDisplay()->setNextBrightness(*mStagedBrightness);
	mBrightness = *mStagedBrightness;
	}
	mStagedBrightness = std::nullopt;
	}

	std::optional<float> DisplayDevice::getStagedBrightness() const {
	return mStagedBrightness;
	}

	ui::Transform::RotationFlags DisplayDevice::getPrimaryDisplayRotationFlags() {
	return sPrimaryDisplayRotationFlags;
	}

	std::string DisplayDevice::getDebugName() const {
	using namespace std::string_literals;

	std::string name = "Display "s + to_string(getId()) + " ("s;

	if (mConnectionType) {
	name += isInternal() ? "internal"s : "external"s;
	} else {
	name += "virtual"s;
	}

	if (isPrimary()) {
	name += ", primary"s;
	}

	return name + ", \""s + mDisplayName + "\")"s;
	}

	void DisplayDevice::dump(std::string& result) const {
	using namespace std::string_literals;

	result += getDebugName();

	if (!isVirtual()) {
	result += "\n deviceProductInfo="s;
	if (mDeviceProductInfo) {
	mDeviceProductInfo->dump(result);
	} else {
	result += "{}"s;
	}
	}

	result += "\n powerMode="s;
	result += to_string(mPowerMode);
	result += '\n';

	if (mRefreshRateConfigs) {
	mRefreshRateConfigs->dump(result);
	}
	}

	bool DisplayDevice::hasRenderIntent(ui::RenderIntent intent) const {
	return mCompositionDisplay->getDisplayColorProfile()->hasRenderIntent(intent);
	}

	DisplayId DisplayDevice::getId() const {
	return mCompositionDisplay->getId();
	}

	bool DisplayDevice::isSecure() const {
	return mCompositionDisplay->isSecure();
	}

	const Rect DisplayDevice::getBounds() const {
	return mCompositionDisplay->getState().displaySpace.getBoundsAsRect();
	}

	const Region& DisplayDevice::getUndefinedRegion() const {
	return mCompositionDisplay->getState().undefinedRegion;
	}

	bool DisplayDevice::needsFiltering() const {
	return mCompositionDisplay->getState().needsFiltering;
	}

	ui::LayerStack DisplayDevice::getLayerStack() const {
	return mCompositionDisplay->getState().layerFilter.layerStack;
	}

	ui::Transform::RotationFlags DisplayDevice::getTransformHint() const {
	return mCompositionDisplay->getTransformHint();
	}

	const ui::Transform& DisplayDevice::getTransform() const {
	return mCompositionDisplay->getState().transform;
	}

	const Rect& DisplayDevice::getLayerStackSpaceRect() const {
	return mCompositionDisplay->getState().layerStackSpace.getContent();
	}

	const Rect& DisplayDevice::getOrientedDisplaySpaceRect() const {
	return mCompositionDisplay->getState().orientedDisplaySpace.getContent();
	}

	bool DisplayDevice::hasWideColorGamut() const {
	return mCompositionDisplay->getDisplayColorProfile()->hasWideColorGamut();
	}

	bool DisplayDevice::hasHDR10PlusSupport() const {
	return mCompositionDisplay->getDisplayColorProfile()->hasHDR10PlusSupport();
	}

	bool DisplayDevice::hasHDR10Support() const {
	return mCompositionDisplay->getDisplayColorProfile()->hasHDR10Support();
	}

	bool DisplayDevice::hasHLGSupport() const {
	return mCompositionDisplay->getDisplayColorProfile()->hasHLGSupport();
	}

	bool DisplayDevice::hasDolbyVisionSupport() const {
	return mCompositionDisplay->getDisplayColorProfile()->hasDolbyVisionSupport();
	}

	int DisplayDevice::getSupportedPerFrameMetadata() const {
	return mCompositionDisplay->getDisplayColorProfile()->getSupportedPerFrameMetadata();
	}

	void DisplayDevice::overrideHdrTypes(const std::vector<ui::Hdr>& hdrTypes) {
	mOverrideHdrTypes = hdrTypes;
	}

	HdrCapabilities DisplayDevice::getHdrCapabilities() const {
	const HdrCapabilities& capabilities =
	mCompositionDisplay->getDisplayColorProfile()->getHdrCapabilities();
	std::vector<ui::Hdr> hdrTypes = capabilities.getSupportedHdrTypes();
	if (!mOverrideHdrTypes.empty()) {
	hdrTypes = mOverrideHdrTypes;
	}
	return HdrCapabilities(hdrTypes, capabilities.getDesiredMaxLuminance(),
	capabilities.getDesiredMaxAverageLuminance(),
	capabilities.getDesiredMinLuminance());
	}

	void DisplayDevice::enableRefreshRateOverlay(bool enable, bool showSpinnner) {
	if (!enable) {
	mRefreshRateOverlay.reset();
	return;
	}

	const auto fpsRange = mRefreshRateConfigs->getSupportedRefreshRateRange();
	mRefreshRateOverlay = std::make_unique<RefreshRateOverlay>(fpsRange, showSpinnner);
	mRefreshRateOverlay->setLayerStack(getLayerStack());
	mRefreshRateOverlay->setViewport(getSize());
	mRefreshRateOverlay->changeRefreshRate(getActiveMode()->getFps());
	}

	bool DisplayDevice::onKernelTimerChanged(std::optional<DisplayModeId> desiredModeId,
	bool timerExpired) {
	if (mRefreshRateConfigs && mRefreshRateOverlay) {
	const auto newRefreshRate =
	mRefreshRateConfigs->onKernelTimerChanged(desiredModeId, timerExpired);
	if (newRefreshRate) {
	mRefreshRateOverlay->changeRefreshRate(*newRefreshRate);
	return true;
	}
	}

	return false;
	}

	void DisplayDevice::animateRefreshRateOverlay() {
	if (mRefreshRateOverlay) {
	mRefreshRateOverlay->animate();
	}
	}

	bool DisplayDevice::setDesiredActiveMode(const ActiveModeInfo& info) {
	ATRACE_CALL();

	LOG_ALWAYS_FATAL_IF(!info.mode, "desired mode not provided");
	LOG_ALWAYS_FATAL_IF(getPhysicalId() != info.mode->getPhysicalDisplayId(), "DisplayId mismatch");

	ALOGV("%s(%s)", __func__, to_string(*info.mode).c_str());

	std::scoped_lock lock(mActiveModeLock);
	if (mDesiredActiveModeChanged) {
	// If a mode change is pending, just cache the latest request in mDesiredActiveMode
	const auto prevConfig = mDesiredActiveMode.event;
	mDesiredActiveMode = info;
	mDesiredActiveMode.event = mDesiredActiveMode.event \| prevConfig;
	return false;
	}

	// Check if we are already at the desired mode
	if (getActiveMode()->getId() == info.mode->getId()) {
	return false;
	}

	// Initiate a mode change.
	mDesiredActiveModeChanged = true;
	mDesiredActiveMode = info;
	return true;
	}

	std::optional<DisplayDevice::ActiveModeInfo> DisplayDevice::getDesiredActiveMode() const {
	std::scoped_lock lock(mActiveModeLock);
	if (mDesiredActiveModeChanged) return mDesiredActiveMode;
	return std::nullopt;
	}

	void DisplayDevice::clearDesiredActiveModeState() {
	std::scoped_lock lock(mActiveModeLock);
	mDesiredActiveMode.event = scheduler::DisplayModeEvent::None;
	mDesiredActiveModeChanged = false;
	}

	std::atomic<int32_t> DisplayDeviceState::sNextSequenceId(1);

	} // namespace android

	// TODO(b/129481165): remove the #pragma below and fix conversion issues
	#pragma clang diagnostic pop // ignored "-Wconversion"