Merge "Extend VTS to support multiple display if available." into main
diff --git a/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_TargetTest.cpp b/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_TargetTest.cpp
index 9669443..88e5cb5 100644
--- a/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_TargetTest.cpp
+++ b/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_TargetTest.cpp
@@ -23,7 +23,6 @@
#include <aidl/android/hardware/graphics/common/Rect.h>
#include <aidl/android/hardware/graphics/composer3/Composition.h>
#include <aidl/android/hardware/graphics/composer3/IComposer.h>
-#include <aidl/android/hardware/graphics/composer3/OutputType.h>
#include <android-base/properties.h>
#include <android/binder_process.h>
#include <android/hardware/graphics/composer3/ComposerClientReader.h>
@@ -34,7 +33,6 @@
#include <gtest/gtest.h>
#include <ui/Fence.h>
#include <ui/GraphicBuffer.h>
-#include <ui/PictureProfileHandle.h>
#include <ui/PixelFormat.h>
#include <algorithm>
#include <iterator>
@@ -125,29 +123,14 @@
[&](const Capability& activeCapability) { return activeCapability == capability; });
}
- bool hasDisplayCapability(int64_t displayId, DisplayCapability capability) {
- const auto& [status, capabilities] = mComposerClient->getDisplayCapabilities(displayId);
- EXPECT_TRUE(status.isOk());
- return std::any_of(capabilities.begin(), capabilities.end(),
- [&](const DisplayCapability& activeCapability) {
- return activeCapability == capability;
- });
- }
-
int getInterfaceVersion() {
const auto& [versionStatus, version] = mComposerClient->getInterfaceVersion();
EXPECT_TRUE(versionStatus.isOk());
return version;
}
- const DisplayWrapper& getPrimaryDisplay() const { return mDisplays[0]; }
-
- int64_t getPrimaryDisplayId() const { return getPrimaryDisplay().getDisplayId(); }
-
int64_t getInvalidDisplayId() const { return mComposerClient->getInvalidDisplayId(); }
- DisplayWrapper& getEditablePrimaryDisplay() { return mDisplays[0]; }
-
struct TestParameters {
nsecs_t delayForChange;
bool refreshMiss;
@@ -188,124 +171,145 @@
}
TEST_P(GraphicsComposerAidlTest, GetDisplayIdentificationData) {
- const auto& [status0, displayIdentification0] =
- mComposerClient->getDisplayIdentificationData(getPrimaryDisplayId());
- if (!status0.isOk() && status0.getExceptionCode() == EX_SERVICE_SPECIFIC &&
- status0.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
- GTEST_SUCCEED() << "Display identification data not supported, skipping test";
- return;
+ for (const auto& display : mDisplays) {
+ const auto& [status0, displayIdentification0] =
+ mComposerClient->getDisplayIdentificationData(display.getDisplayId());
+ if (!status0.isOk() && status0.getExceptionCode() == EX_SERVICE_SPECIFIC &&
+ status0.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
+ GTEST_SUCCEED() << "Display identification data not supported, skipping test";
+ return;
+ }
+ ASSERT_TRUE(status0.isOk()) << "failed to get display identification data";
+ ASSERT_FALSE(displayIdentification0.data.empty());
+
+ constexpr size_t kEdidBlockSize = 128;
+ ASSERT_TRUE(displayIdentification0.data.size() % kEdidBlockSize == 0)
+ << "EDID blob length is not a multiple of " << kEdidBlockSize;
+
+ const uint8_t kEdidHeader[] = {0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00};
+ ASSERT_TRUE(std::equal(std::begin(kEdidHeader), std::end(kEdidHeader),
+ displayIdentification0.data.begin()))
+ << "EDID blob doesn't start with the fixed EDID header";
+ ASSERT_EQ(0, std::accumulate(displayIdentification0.data.begin(),
+ displayIdentification0.data.begin() + kEdidBlockSize,
+ static_cast<uint8_t>(0)))
+ << "EDID base block doesn't checksum";
+
+ const auto& [status1, displayIdentification1] =
+ mComposerClient->getDisplayIdentificationData(display.getDisplayId());
+ ASSERT_TRUE(status1.isOk());
+
+ ASSERT_EQ(displayIdentification0.port, displayIdentification1.port)
+ << "ports are not stable";
+ ASSERT_TRUE(displayIdentification0.data.size() == displayIdentification1.data.size() &&
+ std::equal(displayIdentification0.data.begin(),
+ displayIdentification0.data.end(),
+ displayIdentification1.data.begin()))
+ << "data is not stable";
}
- ASSERT_TRUE(status0.isOk()) << "failed to get display identification data";
- ASSERT_FALSE(displayIdentification0.data.empty());
-
- constexpr size_t kEdidBlockSize = 128;
- ASSERT_TRUE(displayIdentification0.data.size() % kEdidBlockSize == 0)
- << "EDID blob length is not a multiple of " << kEdidBlockSize;
-
- const uint8_t kEdidHeader[] = {0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00};
- ASSERT_TRUE(std::equal(std::begin(kEdidHeader), std::end(kEdidHeader),
- displayIdentification0.data.begin()))
- << "EDID blob doesn't start with the fixed EDID header";
- ASSERT_EQ(0, std::accumulate(displayIdentification0.data.begin(),
- displayIdentification0.data.begin() + kEdidBlockSize,
- static_cast<uint8_t>(0)))
- << "EDID base block doesn't checksum";
-
- const auto& [status1, displayIdentification1] =
- mComposerClient->getDisplayIdentificationData(getPrimaryDisplayId());
- ASSERT_TRUE(status1.isOk());
-
- ASSERT_EQ(displayIdentification0.port, displayIdentification1.port) << "ports are not stable";
- ASSERT_TRUE(displayIdentification0.data.size() == displayIdentification1.data.size() &&
- std::equal(displayIdentification0.data.begin(), displayIdentification0.data.end(),
- displayIdentification1.data.begin()))
- << "data is not stable";
}
TEST_P(GraphicsComposerAidlTest, GetHdrCapabilities) {
- const auto& [status, hdrCapabilities] =
- mComposerClient->getHdrCapabilities(getPrimaryDisplayId());
+ for (const auto& display : mDisplays) {
+ const auto& [status, hdrCapabilities] =
+ mComposerClient->getHdrCapabilities(display.getDisplayId());
- ASSERT_TRUE(status.isOk());
- EXPECT_TRUE(hdrCapabilities.maxLuminance >= hdrCapabilities.minLuminance);
+ ASSERT_TRUE(status.isOk());
+ EXPECT_TRUE(hdrCapabilities.maxLuminance >= hdrCapabilities.minLuminance);
+ }
}
TEST_P(GraphicsComposerAidlTest, GetPerFrameMetadataKeys) {
- const auto& [status, keys] = mComposerClient->getPerFrameMetadataKeys(getPrimaryDisplayId());
- if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
- status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
- GTEST_SUCCEED() << "getPerFrameMetadataKeys is not supported";
- return;
- }
+ for (const auto& display : mDisplays) {
+ const auto& [status, keys] =
+ mComposerClient->getPerFrameMetadataKeys(display.getDisplayId());
+ if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
+ status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
+ GTEST_SUCCEED() << "getPerFrameMetadataKeys is not supported";
+ return;
+ }
- ASSERT_TRUE(status.isOk());
- EXPECT_TRUE(keys.size() >= 0);
+ ASSERT_TRUE(status.isOk());
+ EXPECT_TRUE(keys.size() >= 0);
+ }
}
TEST_P(GraphicsComposerAidlTest, GetReadbackBufferAttributes) {
- const auto& [status, _] = mComposerClient->getReadbackBufferAttributes(getPrimaryDisplayId());
- if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
- status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
- GTEST_SUCCEED() << "getReadbackBufferAttributes is not supported";
- return;
+ for (const auto& display : mDisplays) {
+ const auto& [status, _] =
+ mComposerClient->getReadbackBufferAttributes(display.getDisplayId());
+ if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
+ status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
+ GTEST_SUCCEED() << "getReadbackBufferAttributes is not supported";
+ return;
+ }
+ ASSERT_TRUE(status.isOk());
}
- ASSERT_TRUE(status.isOk());
}
TEST_P(GraphicsComposerAidlTest, GetRenderIntents) {
- const auto& [status, modes] = mComposerClient->getColorModes(getPrimaryDisplayId());
- EXPECT_TRUE(status.isOk());
+ for (const auto& display : mDisplays) {
+ const auto& [status, modes] = mComposerClient->getColorModes(display.getDisplayId());
+ EXPECT_TRUE(status.isOk());
- for (auto mode : modes) {
- const auto& [intentStatus, intents] =
- mComposerClient->getRenderIntents(getPrimaryDisplayId(), mode);
- EXPECT_TRUE(intentStatus.isOk());
- bool isHdr;
- switch (mode) {
- case ColorMode::BT2100_PQ:
- case ColorMode::BT2100_HLG:
- isHdr = true;
- break;
- default:
- isHdr = false;
- break;
+ for (auto mode : modes) {
+ const auto& [intentStatus, intents] =
+ mComposerClient->getRenderIntents(display.getDisplayId(), mode);
+ EXPECT_TRUE(intentStatus.isOk());
+ bool isHdr;
+ switch (mode) {
+ case ColorMode::BT2100_PQ:
+ case ColorMode::BT2100_HLG:
+ isHdr = true;
+ break;
+ default:
+ isHdr = false;
+ break;
+ }
+ RenderIntent requiredIntent =
+ isHdr ? RenderIntent::TONE_MAP_COLORIMETRIC : RenderIntent::COLORIMETRIC;
+
+ const auto iter = std::find(intents.cbegin(), intents.cend(), requiredIntent);
+ EXPECT_NE(intents.cend(), iter);
}
- RenderIntent requiredIntent =
- isHdr ? RenderIntent::TONE_MAP_COLORIMETRIC : RenderIntent::COLORIMETRIC;
-
- const auto iter = std::find(intents.cbegin(), intents.cend(), requiredIntent);
- EXPECT_NE(intents.cend(), iter);
}
}
TEST_P(GraphicsComposerAidlTest, GetRenderIntents_BadDisplay) {
- const auto& [status, modes] = mComposerClient->getColorModes(getPrimaryDisplayId());
- ASSERT_TRUE(status.isOk());
+ for (const auto& display : mDisplays) {
+ const auto& [status, modes] = mComposerClient->getColorModes(display.getDisplayId());
+ ASSERT_TRUE(status.isOk());
- for (auto mode : modes) {
- const auto& [intentStatus, _] =
- mComposerClient->getRenderIntents(getInvalidDisplayId(), mode);
+ for (auto mode : modes) {
+ const auto& [intentStatus, _] =
+ mComposerClient->getRenderIntents(getInvalidDisplayId(), mode);
- EXPECT_FALSE(intentStatus.isOk());
- EXPECT_NO_FATAL_FAILURE(
- assertServiceSpecificError(intentStatus, IComposerClient::EX_BAD_DISPLAY));
+ EXPECT_FALSE(intentStatus.isOk());
+ EXPECT_NO_FATAL_FAILURE(
+ assertServiceSpecificError(intentStatus, IComposerClient::EX_BAD_DISPLAY));
+ }
}
}
TEST_P(GraphicsComposerAidlTest, GetRenderIntents_BadParameter) {
- const auto& [status, _] =
- mComposerClient->getRenderIntents(getPrimaryDisplayId(), static_cast<ColorMode>(-1));
+ for (const auto& display : mDisplays) {
+ const auto& [status, _] = mComposerClient->getRenderIntents(display.getDisplayId(),
+ static_cast<ColorMode>(-1));
- EXPECT_FALSE(status.isOk());
- EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
+ EXPECT_FALSE(status.isOk());
+ EXPECT_NO_FATAL_FAILURE(
+ assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
+ }
}
TEST_P(GraphicsComposerAidlTest, GetColorModes) {
- const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
- ASSERT_TRUE(status.isOk());
+ for (const auto& display : mDisplays) {
+ const auto& [status, colorModes] = mComposerClient->getColorModes(display.getDisplayId());
+ ASSERT_TRUE(status.isOk());
- const auto native = std::find(colorModes.cbegin(), colorModes.cend(), ColorMode::NATIVE);
- EXPECT_NE(colorModes.cend(), native);
+ const auto native = std::find(colorModes.cbegin(), colorModes.cend(), ColorMode::NATIVE);
+ EXPECT_NE(colorModes.cend(), native);
+ }
}
TEST_P(GraphicsComposerAidlTest, GetColorMode_BadDisplay) {
@@ -316,128 +320,145 @@
}
TEST_P(GraphicsComposerAidlTest, SetColorMode) {
- const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
- EXPECT_TRUE(status.isOk());
+ for (const auto& display : mDisplays) {
+ const auto& [status, colorModes] = mComposerClient->getColorModes(display.getDisplayId());
+ EXPECT_TRUE(status.isOk());
- for (auto mode : colorModes) {
- const auto& [intentStatus, intents] =
- mComposerClient->getRenderIntents(getPrimaryDisplayId(), mode);
- EXPECT_TRUE(intentStatus.isOk()) << "failed to get render intents";
+ for (auto mode : colorModes) {
+ const auto& [intentStatus, intents] =
+ mComposerClient->getRenderIntents(display.getDisplayId(), mode);
+ EXPECT_TRUE(intentStatus.isOk()) << "failed to get render intents";
- for (auto intent : intents) {
- const auto modeStatus =
- mComposerClient->setColorMode(getPrimaryDisplayId(), mode, intent);
- EXPECT_TRUE(modeStatus.isOk() ||
+ for (auto intent : intents) {
+ const auto modeStatus =
+ mComposerClient->setColorMode(display.getDisplayId(), mode, intent);
+ EXPECT_TRUE(
+ modeStatus.isOk() ||
(modeStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
IComposerClient::EX_UNSUPPORTED == modeStatus.getServiceSpecificError()))
- << "failed to set color mode";
+ << "failed to set color mode";
+ }
}
- }
- const auto modeStatus = mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE,
- RenderIntent::COLORIMETRIC);
- EXPECT_TRUE(modeStatus.isOk() ||
- (modeStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
- IComposerClient::EX_UNSUPPORTED == modeStatus.getServiceSpecificError()))
- << "failed to set color mode";
+ const auto modeStatus = mComposerClient->setColorMode(
+ display.getDisplayId(), ColorMode::NATIVE, RenderIntent::COLORIMETRIC);
+ EXPECT_TRUE(modeStatus.isOk() ||
+ (modeStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
+ IComposerClient::EX_UNSUPPORTED == modeStatus.getServiceSpecificError()))
+ << "failed to set color mode";
+ }
}
TEST_P(GraphicsComposerAidlTest, SetColorMode_BadDisplay) {
- const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
- ASSERT_TRUE(status.isOk());
+ for (const auto& display : mDisplays) {
+ const auto& [status, colorModes] = mComposerClient->getColorModes(display.getDisplayId());
+ ASSERT_TRUE(status.isOk());
- for (auto mode : colorModes) {
- const auto& [intentStatus, intents] =
- mComposerClient->getRenderIntents(getPrimaryDisplayId(), mode);
- ASSERT_TRUE(intentStatus.isOk()) << "failed to get render intents";
+ for (auto mode : colorModes) {
+ const auto& [intentStatus, intents] =
+ mComposerClient->getRenderIntents(display.getDisplayId(), mode);
+ ASSERT_TRUE(intentStatus.isOk()) << "failed to get render intents";
- for (auto intent : intents) {
- auto const modeStatus =
- mComposerClient->setColorMode(getInvalidDisplayId(), mode, intent);
+ for (auto intent : intents) {
+ auto const modeStatus =
+ mComposerClient->setColorMode(getInvalidDisplayId(), mode, intent);
- EXPECT_FALSE(modeStatus.isOk());
- EXPECT_NO_FATAL_FAILURE(
- assertServiceSpecificError(modeStatus, IComposerClient::EX_BAD_DISPLAY));
+ EXPECT_FALSE(modeStatus.isOk());
+ EXPECT_NO_FATAL_FAILURE(
+ assertServiceSpecificError(modeStatus, IComposerClient::EX_BAD_DISPLAY));
+ }
}
}
}
TEST_P(GraphicsComposerAidlTest, SetColorMode_BadParameter) {
- auto status = mComposerClient->setColorMode(getPrimaryDisplayId(), static_cast<ColorMode>(-1),
- RenderIntent::COLORIMETRIC);
+ for (const auto& display : mDisplays) {
+ auto status = mComposerClient->setColorMode(
+ display.getDisplayId(), static_cast<ColorMode>(-1), RenderIntent::COLORIMETRIC);
- EXPECT_FALSE(status.isOk());
- EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
+ EXPECT_FALSE(status.isOk());
+ EXPECT_NO_FATAL_FAILURE(
+ assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
- status = mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE,
- static_cast<RenderIntent>(-1));
+ status = mComposerClient->setColorMode(display.getDisplayId(), ColorMode::NATIVE,
+ static_cast<RenderIntent>(-1));
- EXPECT_FALSE(status.isOk());
- EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
+ EXPECT_FALSE(status.isOk());
+ EXPECT_NO_FATAL_FAILURE(
+ assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
+ }
}
TEST_P(GraphicsComposerAidlTest, GetDisplayedContentSamplingAttributes) {
int constexpr kInvalid = -1;
- const auto& [status, format] =
- mComposerClient->getDisplayedContentSamplingAttributes(getPrimaryDisplayId());
+ for (const auto& display : mDisplays) {
+ const auto& [status, format] =
+ mComposerClient->getDisplayedContentSamplingAttributes(display.getDisplayId());
- if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
- status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
- SUCCEED() << "Device does not support optional extension. Test skipped";
- return;
+ if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
+ status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
+ SUCCEED() << "Device does not support optional extension. Test skipped";
+ return;
+ }
+
+ ASSERT_TRUE(status.isOk());
+ EXPECT_NE(kInvalid, static_cast<int>(format.format));
+ EXPECT_NE(kInvalid, static_cast<int>(format.dataspace));
+ EXPECT_NE(kInvalid, static_cast<int>(format.componentMask));
}
-
- ASSERT_TRUE(status.isOk());
- EXPECT_NE(kInvalid, static_cast<int>(format.format));
- EXPECT_NE(kInvalid, static_cast<int>(format.dataspace));
- EXPECT_NE(kInvalid, static_cast<int>(format.componentMask));
-};
+}
TEST_P(GraphicsComposerAidlTest, SetDisplayedContentSamplingEnabled) {
int constexpr kMaxFrames = 10;
FormatColorComponent enableAllComponents = FormatColorComponent::FORMAT_COMPONENT_0;
- auto status = mComposerClient->setDisplayedContentSamplingEnabled(
- getPrimaryDisplayId(), /*isEnabled*/ true, enableAllComponents, kMaxFrames);
- if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
- status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
- SUCCEED() << "Device does not support optional extension. Test skipped";
- return;
- }
- EXPECT_TRUE(status.isOk());
- status = mComposerClient->setDisplayedContentSamplingEnabled(
- getPrimaryDisplayId(), /*isEnabled*/ false, enableAllComponents, kMaxFrames);
- EXPECT_TRUE(status.isOk());
+ for (const auto& display : mDisplays) {
+ auto status = mComposerClient->setDisplayedContentSamplingEnabled(
+ display.getDisplayId(), /*isEnabled*/ true, enableAllComponents, kMaxFrames);
+ if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
+ status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
+ SUCCEED() << "Device does not support optional extension. Test skipped";
+ return;
+ }
+ EXPECT_TRUE(status.isOk());
+
+ status = mComposerClient->setDisplayedContentSamplingEnabled(
+ display.getDisplayId(), /*isEnabled*/ false, enableAllComponents, kMaxFrames);
+ EXPECT_TRUE(status.isOk());
+ }
}
TEST_P(GraphicsComposerAidlTest, GetDisplayedContentSample) {
- const auto& [status, displayContentSamplingAttributes] =
- mComposerClient->getDisplayedContentSamplingAttributes(getPrimaryDisplayId());
- if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
- status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
- SUCCEED() << "Sampling attributes aren't supported on this device, test skipped";
- return;
- }
+ for (const auto& display : mDisplays) {
+ const auto& [status, displayContentSamplingAttributes] =
+ mComposerClient->getDisplayedContentSamplingAttributes(display.getDisplayId());
+ if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
+ status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
+ SUCCEED() << "Sampling attributes aren't supported on this device, test skipped";
+ return;
+ }
- int64_t constexpr kMaxFrames = 10;
- int64_t constexpr kTimestamp = 0;
- const auto& [sampleStatus, displayContentSample] = mComposerClient->getDisplayedContentSample(
- getPrimaryDisplayId(), kMaxFrames, kTimestamp);
- if (!sampleStatus.isOk() && sampleStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
- sampleStatus.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
- SUCCEED() << "Device does not support optional extension. Test skipped";
- return;
- }
+ int64_t constexpr kMaxFrames = 10;
+ int64_t constexpr kTimestamp = 0;
+ const auto& [sampleStatus, displayContentSample] =
+ mComposerClient->getDisplayedContentSample(display.getDisplayId(), kMaxFrames,
+ kTimestamp);
+ if (!sampleStatus.isOk() && sampleStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
+ sampleStatus.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
+ SUCCEED() << "Device does not support optional extension. Test skipped";
+ return;
+ }
- EXPECT_TRUE(sampleStatus.isOk());
- const std::vector<std::vector<int64_t>> histogram = {
- displayContentSample.sampleComponent0, displayContentSample.sampleComponent1,
- displayContentSample.sampleComponent2, displayContentSample.sampleComponent3};
+ EXPECT_TRUE(sampleStatus.isOk());
+ const std::vector<std::vector<int64_t>> histogram = {
+ displayContentSample.sampleComponent0, displayContentSample.sampleComponent1,
+ displayContentSample.sampleComponent2, displayContentSample.sampleComponent3};
- for (size_t i = 0; i < histogram.size(); i++) {
- const bool shouldHaveHistogram =
- static_cast<int>(displayContentSamplingAttributes.componentMask) & (1 << i);
- EXPECT_EQ(shouldHaveHistogram, !histogram[i].empty());
+ for (size_t i = 0; i < histogram.size(); i++) {
+ const bool shouldHaveHistogram =
+ static_cast<int>(displayContentSamplingAttributes.componentMask) & (1 << i);
+ EXPECT_EQ(shouldHaveHistogram, !histogram[i].empty());
+ }
}
}
@@ -567,10 +588,14 @@
GTEST_SUCCEED() << "Boot Display Config not supported";
return;
}
- const auto& [status, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
- EXPECT_TRUE(status.isOk());
- for (const auto& config : configs) {
- EXPECT_TRUE(mComposerClient->setBootDisplayConfig(getPrimaryDisplayId(), config).isOk());
+
+ for (const auto& display : mDisplays) {
+ const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
+ EXPECT_TRUE(status.isOk());
+ for (const auto& config : configs) {
+ EXPECT_TRUE(
+ mComposerClient->setBootDisplayConfig(display.getDisplayId(), config).isOk());
+ }
}
}
@@ -590,7 +615,10 @@
GTEST_SUCCEED() << "Boot Display Config not supported";
return;
}
- EXPECT_TRUE(mComposerClient->clearBootDisplayConfig(getPrimaryDisplayId()).isOk());
+
+ for (const auto& display : mDisplays) {
+ EXPECT_TRUE(mComposerClient->clearBootDisplayConfig(display.getDisplayId()).isOk());
+ }
}
TEST_P(GraphicsComposerAidlTest, GetPreferredBootDisplayConfig_BadDisplay) {
@@ -609,36 +637,42 @@
GTEST_SUCCEED() << "Boot Display Config not supported";
return;
}
- const auto& [status, preferredDisplayConfig] =
- mComposerClient->getPreferredBootDisplayConfig(getPrimaryDisplayId());
- EXPECT_TRUE(status.isOk());
- const auto& [configStatus, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
+ for (const auto& display : mDisplays) {
+ const auto& [status, preferredDisplayConfig] =
+ mComposerClient->getPreferredBootDisplayConfig(display.getDisplayId());
+ EXPECT_TRUE(status.isOk());
- EXPECT_TRUE(configStatus.isOk());
- EXPECT_NE(configs.end(), std::find(configs.begin(), configs.end(), preferredDisplayConfig));
+ const auto& [configStatus, configs] =
+ mComposerClient->getDisplayConfigs(display.getDisplayId());
+
+ EXPECT_TRUE(configStatus.isOk());
+ EXPECT_NE(configs.end(), std::find(configs.begin(), configs.end(), preferredDisplayConfig));
+ }
}
TEST_P(GraphicsComposerAidlTest, BootDisplayConfig_Unsupported) {
if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
- const auto& [configStatus, config] =
- mComposerClient->getActiveConfig(getPrimaryDisplayId());
- EXPECT_TRUE(configStatus.isOk());
+ for (const auto& display : mDisplays) {
+ const auto& [configStatus, config] =
+ mComposerClient->getActiveConfig(display.getDisplayId());
+ EXPECT_TRUE(configStatus.isOk());
- auto status = mComposerClient->setBootDisplayConfig(getPrimaryDisplayId(), config);
- EXPECT_FALSE(status.isOk());
- EXPECT_NO_FATAL_FAILURE(
- assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
+ auto status = mComposerClient->setBootDisplayConfig(display.getDisplayId(), config);
+ EXPECT_FALSE(status.isOk());
+ EXPECT_NO_FATAL_FAILURE(
+ assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
- status = mComposerClient->getPreferredBootDisplayConfig(getPrimaryDisplayId()).first;
- EXPECT_FALSE(status.isOk());
- EXPECT_NO_FATAL_FAILURE(
- assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
+ status = mComposerClient->getPreferredBootDisplayConfig(display.getDisplayId()).first;
+ EXPECT_FALSE(status.isOk());
+ EXPECT_NO_FATAL_FAILURE(
+ assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
- status = mComposerClient->clearBootDisplayConfig(getPrimaryDisplayId());
- EXPECT_FALSE(status.isOk());
- EXPECT_NO_FATAL_FAILURE(
- assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
+ status = mComposerClient->clearBootDisplayConfig(display.getDisplayId());
+ EXPECT_FALSE(status.isOk());
+ EXPECT_NO_FATAL_FAILURE(
+ assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
+ }
}
}
@@ -670,22 +704,25 @@
return;
}
const auto& [status, conversionCapabilities] = mComposerClient->getHdrConversionCapabilities();
- const auto& [status2, hdrCapabilities] =
- mComposerClient->getHdrCapabilities(getPrimaryDisplayId());
- const auto& hdrTypes = hdrCapabilities.types;
- for (auto conversionCapability : conversionCapabilities) {
- if (conversionCapability.outputType != common::Hdr::INVALID) {
- if (std::find(hdrTypes.begin(), hdrTypes.end(), conversionCapability.outputType) ==
- hdrTypes.end()) {
- continue;
+
+ for (const auto& display : mDisplays) {
+ const auto& [status2, hdrCapabilities] =
+ mComposerClient->getHdrCapabilities(display.getDisplayId());
+ const auto& hdrTypes = hdrCapabilities.types;
+ for (auto conversionCapability : conversionCapabilities) {
+ if (conversionCapability.outputType != common::Hdr::INVALID) {
+ if (std::find(hdrTypes.begin(), hdrTypes.end(), conversionCapability.outputType) ==
+ hdrTypes.end()) {
+ continue;
+ }
+ common::HdrConversionStrategy hdrConversionStrategy;
+ hdrConversionStrategy.set<common::HdrConversionStrategy::Tag::forceHdrConversion>(
+ conversionCapability.outputType);
+ const auto& [statusSet, preferredHdrOutputType] =
+ mComposerClient->setHdrConversionStrategy(hdrConversionStrategy);
+ EXPECT_TRUE(statusSet.isOk());
+ EXPECT_EQ(common::Hdr::INVALID, preferredHdrOutputType);
}
- common::HdrConversionStrategy hdrConversionStrategy;
- hdrConversionStrategy.set<common::HdrConversionStrategy::Tag::forceHdrConversion>(
- conversionCapability.outputType);
- const auto& [statusSet, preferredHdrOutputType] =
- mComposerClient->setHdrConversionStrategy(hdrConversionStrategy);
- EXPECT_TRUE(statusSet.isOk());
- EXPECT_EQ(common::Hdr::INVALID, preferredHdrOutputType);
}
}
}
@@ -696,24 +733,27 @@
return;
}
const auto& [status, conversionCapabilities] = mComposerClient->getHdrConversionCapabilities();
- const auto& [status2, hdrCapabilities] =
- mComposerClient->getHdrCapabilities(getPrimaryDisplayId());
- if (hdrCapabilities.types.size() <= 0) {
- return;
- }
- std::vector<aidl::android::hardware::graphics::common::Hdr> autoHdrTypes;
- for (auto conversionCapability : conversionCapabilities) {
- if (conversionCapability.outputType != common::Hdr::INVALID) {
- autoHdrTypes.push_back(conversionCapability.outputType);
+
+ for (const auto& display : mDisplays) {
+ const auto& [status2, hdrCapabilities] =
+ mComposerClient->getHdrCapabilities(display.getDisplayId());
+ if (hdrCapabilities.types.size() <= 0) {
+ return;
}
+ std::vector<aidl::android::hardware::graphics::common::Hdr> autoHdrTypes;
+ for (auto conversionCapability : conversionCapabilities) {
+ if (conversionCapability.outputType != common::Hdr::INVALID) {
+ autoHdrTypes.push_back(conversionCapability.outputType);
+ }
+ }
+ common::HdrConversionStrategy hdrConversionStrategy;
+ hdrConversionStrategy.set<common::HdrConversionStrategy::Tag::autoAllowedHdrTypes>(
+ autoHdrTypes);
+ const auto& [statusSet, preferredHdrOutputType] =
+ mComposerClient->setHdrConversionStrategy(hdrConversionStrategy);
+ EXPECT_TRUE(statusSet.isOk());
+ EXPECT_NE(common::Hdr::INVALID, preferredHdrOutputType);
}
- common::HdrConversionStrategy hdrConversionStrategy;
- hdrConversionStrategy.set<common::HdrConversionStrategy::Tag::autoAllowedHdrTypes>(
- autoHdrTypes);
- const auto& [statusSet, preferredHdrOutputType] =
- mComposerClient->setHdrConversionStrategy(hdrConversionStrategy);
- EXPECT_TRUE(statusSet.isOk());
- EXPECT_NE(common::Hdr::INVALID, preferredHdrOutputType);
}
TEST_P(GraphicsComposerAidlTest, SetAutoLowLatencyMode_BadDisplay) {
@@ -852,11 +892,12 @@
return;
}
- const auto& [status, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, nullptr);
-
- EXPECT_TRUE(status.isOk());
- EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer, nullptr).isOk());
+ for (const auto& display : mDisplays) {
+ const auto& [status, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, nullptr);
+ EXPECT_TRUE(status.isOk());
+ EXPECT_TRUE(mComposerClient->destroyLayer(display.getDisplayId(), layer, nullptr).isOk());
+ }
}
TEST_P(GraphicsComposerAidlTest, CreateLayer_BadDisplay) {
@@ -878,17 +919,19 @@
return;
}
- const auto& [status, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, nullptr);
- EXPECT_TRUE(status.isOk());
+ for (const auto& display : mDisplays) {
+ const auto& [status, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, nullptr);
+ EXPECT_TRUE(status.isOk());
- const auto& destroyStatus =
- mComposerClient->destroyLayer(getInvalidDisplayId(), layer, nullptr);
+ const auto& destroyStatus =
+ mComposerClient->destroyLayer(getInvalidDisplayId(), layer, nullptr);
- EXPECT_FALSE(destroyStatus.isOk());
- EXPECT_NO_FATAL_FAILURE(
- assertServiceSpecificError(destroyStatus, IComposerClient::EX_BAD_DISPLAY));
- ASSERT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer, nullptr).isOk());
+ EXPECT_FALSE(destroyStatus.isOk());
+ EXPECT_NO_FATAL_FAILURE(
+ assertServiceSpecificError(destroyStatus, IComposerClient::EX_BAD_DISPLAY));
+ ASSERT_TRUE(mComposerClient->destroyLayer(display.getDisplayId(), layer, nullptr).isOk());
+ }
}
TEST_P(GraphicsComposerAidlTest, DestroyLayer_BadLayerError) {
@@ -897,11 +940,14 @@
return;
}
- // We haven't created any layers yet, so any id should be invalid
- const auto& status = mComposerClient->destroyLayer(getPrimaryDisplayId(), /*layer*/ 1, nullptr);
+ for (const auto& display : mDisplays) {
+ // We haven't created any layers yet, so any id should be invalid
+ const auto& status =
+ mComposerClient->destroyLayer(display.getDisplayId(), /*layer*/ 1, nullptr);
- EXPECT_FALSE(status.isOk());
- EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_LAYER));
+ EXPECT_FALSE(status.isOk());
+ EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_LAYER));
+ }
}
TEST_P(GraphicsComposerAidlTest, GetActiveConfig_BadDisplay) {
@@ -912,8 +958,10 @@
}
TEST_P(GraphicsComposerAidlTest, GetDisplayConfig) {
- const auto& [status, _] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
- EXPECT_TRUE(status.isOk());
+ for (const auto& display : mDisplays) {
+ const auto& [status, _] = mComposerClient->getDisplayConfigs(display.getDisplayId());
+ EXPECT_TRUE(status.isOk());
+ }
}
TEST_P(GraphicsComposerAidlTest, GetDisplayConfig_BadDisplay) {
@@ -924,15 +972,10 @@
}
TEST_P(GraphicsComposerAidlTest, GetDisplayName) {
- const auto& [status, _] = mComposerClient->getDisplayName(getPrimaryDisplayId());
- EXPECT_TRUE(status.isOk());
-}
-
-TEST_P(GraphicsComposerAidlTest, GetDisplayPhysicalOrientation_BadDisplay) {
- const auto& [status, _] = mComposerClient->getDisplayPhysicalOrientation(getInvalidDisplayId());
-
- EXPECT_FALSE(status.isOk());
- EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
+ for (const auto& display : mDisplays) {
+ const auto& [status, _] = mComposerClient->getDisplayName(display.getDisplayId());
+ EXPECT_TRUE(status.isOk());
+ }
}
TEST_P(GraphicsComposerAidlTest, GetDisplayPhysicalOrientation) {
@@ -943,197 +986,214 @@
Transform::ROT_270,
};
- const auto& [status, displayOrientation] =
- mComposerClient->getDisplayPhysicalOrientation(getPrimaryDisplayId());
+ for (const auto& display : mDisplays) {
+ const auto& [status, displayOrientation] =
+ mComposerClient->getDisplayPhysicalOrientation(display.getDisplayId());
- EXPECT_TRUE(status.isOk());
- EXPECT_NE(std::find(allowedDisplayOrientations.begin(), allowedDisplayOrientations.end(),
- displayOrientation),
- allowedDisplayOrientations.end());
+ EXPECT_TRUE(status.isOk());
+ EXPECT_NE(std::find(allowedDisplayOrientations.begin(), allowedDisplayOrientations.end(),
+ displayOrientation),
+ allowedDisplayOrientations.end());
+ }
}
TEST_P(GraphicsComposerAidlTest, SetClientTargetSlotCount) {
- EXPECT_TRUE(mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kBufferSlotCount)
+ for (const auto& display : mDisplays) {
+ EXPECT_TRUE(
+ mComposerClient->setClientTargetSlotCount(display.getDisplayId(), kBufferSlotCount)
.isOk());
+ }
}
TEST_P(GraphicsComposerAidlTest, SetActiveConfig) {
- const auto& [status, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
- EXPECT_TRUE(status.isOk());
+ for (auto& display : mDisplays) {
+ const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
+ EXPECT_TRUE(status.isOk());
- for (const auto& config : configs) {
- auto display = getEditablePrimaryDisplay();
- EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config).isOk());
- const auto& [configStatus, config1] =
- mComposerClient->getActiveConfig(getPrimaryDisplayId());
- EXPECT_TRUE(configStatus.isOk());
- EXPECT_EQ(config, config1);
+ for (const auto& config : configs) {
+ EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config).isOk());
+ const auto& [configStatus, config1] =
+ mComposerClient->getActiveConfig(display.getDisplayId());
+ EXPECT_TRUE(configStatus.isOk());
+ EXPECT_EQ(config, config1);
+ }
}
}
TEST_P(GraphicsComposerAidlTest, SetActiveConfigPowerCycle) {
- EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
- EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
+ for (auto& display : mDisplays) {
+ EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::OFF).isOk());
+ EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::ON).isOk());
- const auto& [status, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
- EXPECT_TRUE(status.isOk());
+ const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
+ EXPECT_TRUE(status.isOk());
- for (const auto& config : configs) {
- auto display = getEditablePrimaryDisplay();
- EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config).isOk());
- const auto& [config1Status, config1] =
- mComposerClient->getActiveConfig(getPrimaryDisplayId());
- EXPECT_TRUE(config1Status.isOk());
- EXPECT_EQ(config, config1);
+ for (const auto& config : configs) {
+ EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config).isOk());
+ const auto& [config1Status, config1] =
+ mComposerClient->getActiveConfig(display.getDisplayId());
+ EXPECT_TRUE(config1Status.isOk());
+ EXPECT_EQ(config, config1);
- EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
- EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
- const auto& [config2Status, config2] =
- mComposerClient->getActiveConfig(getPrimaryDisplayId());
- EXPECT_TRUE(config2Status.isOk());
- EXPECT_EQ(config, config2);
+ EXPECT_TRUE(
+ mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::OFF).isOk());
+ EXPECT_TRUE(
+ mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::ON).isOk());
+ const auto& [config2Status, config2] =
+ mComposerClient->getActiveConfig(display.getDisplayId());
+ EXPECT_TRUE(config2Status.isOk());
+ EXPECT_EQ(config, config2);
+ }
}
}
TEST_P(GraphicsComposerAidlTest, SetPowerModeUnsupported) {
- const auto& [status, capabilities] =
- mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
- ASSERT_TRUE(status.isOk());
+ for (const auto& display : mDisplays) {
+ const auto& [status, capabilities] =
+ mComposerClient->getDisplayCapabilities(display.getDisplayId());
+ ASSERT_TRUE(status.isOk());
- const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
- DisplayCapability::DOZE) != capabilities.end();
- const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
- DisplayCapability::SUSPEND) != capabilities.end();
+ const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
+ DisplayCapability::DOZE) != capabilities.end();
+ const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
+ DisplayCapability::SUSPEND) != capabilities.end();
- if (!isDozeSupported) {
- const auto& powerModeDozeStatus =
- mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE);
- EXPECT_FALSE(powerModeDozeStatus.isOk());
- EXPECT_NO_FATAL_FAILURE(
- assertServiceSpecificError(powerModeDozeStatus, IComposerClient::EX_UNSUPPORTED));
+ if (!isDozeSupported) {
+ const auto& powerModeDozeStatus =
+ mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::DOZE);
+ EXPECT_FALSE(powerModeDozeStatus.isOk());
+ EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeDozeStatus,
+ IComposerClient::EX_UNSUPPORTED));
- const auto& powerModeDozeSuspendStatus =
- mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE_SUSPEND);
- EXPECT_FALSE(powerModeDozeSuspendStatus.isOk());
- EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeDozeSuspendStatus,
- IComposerClient::EX_UNSUPPORTED));
- }
+ const auto& powerModeDozeSuspendStatus =
+ mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::DOZE_SUSPEND);
+ EXPECT_FALSE(powerModeDozeSuspendStatus.isOk());
+ EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeDozeSuspendStatus,
+ IComposerClient::EX_UNSUPPORTED));
+ }
- if (!isSuspendSupported) {
- const auto& powerModeSuspendStatus =
- mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON_SUSPEND);
- EXPECT_FALSE(powerModeSuspendStatus.isOk());
- EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeSuspendStatus,
- IComposerClient::EX_UNSUPPORTED));
+ if (!isSuspendSupported) {
+ const auto& powerModeSuspendStatus =
+ mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::ON_SUSPEND);
+ EXPECT_FALSE(powerModeSuspendStatus.isOk());
+ EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeSuspendStatus,
+ IComposerClient::EX_UNSUPPORTED));
- const auto& powerModeDozeSuspendStatus =
- mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE_SUSPEND);
- EXPECT_FALSE(powerModeDozeSuspendStatus.isOk());
- EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeDozeSuspendStatus,
- IComposerClient::EX_UNSUPPORTED));
+ const auto& powerModeDozeSuspendStatus =
+ mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::DOZE_SUSPEND);
+ EXPECT_FALSE(powerModeDozeSuspendStatus.isOk());
+ EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeDozeSuspendStatus,
+ IComposerClient::EX_UNSUPPORTED));
+ }
}
}
TEST_P(GraphicsComposerAidlTest, SetVsyncEnabled) {
mComposerClient->setVsyncAllowed(true);
- EXPECT_TRUE(mComposerClient->setVsync(getPrimaryDisplayId(), true).isOk());
- usleep(60 * 1000);
- EXPECT_TRUE(mComposerClient->setVsync(getPrimaryDisplayId(), false).isOk());
+ for (const auto& display : mDisplays) {
+ EXPECT_TRUE(mComposerClient->setVsync(display.getDisplayId(), true).isOk());
+ usleep(60 * 1000);
+ EXPECT_TRUE(mComposerClient->setVsync(display.getDisplayId(), false).isOk());
+ }
mComposerClient->setVsyncAllowed(false);
}
TEST_P(GraphicsComposerAidlTest, SetPowerMode) {
- const auto& [status, capabilities] =
- mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
- ASSERT_TRUE(status.isOk());
+ for (const auto& display : mDisplays) {
+ const auto& [status, capabilities] =
+ mComposerClient->getDisplayCapabilities(display.getDisplayId());
+ ASSERT_TRUE(status.isOk());
- const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
- DisplayCapability::DOZE) != capabilities.end();
- const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
- DisplayCapability::SUSPEND) != capabilities.end();
+ const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
+ DisplayCapability::DOZE) != capabilities.end();
+ const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
+ DisplayCapability::SUSPEND) != capabilities.end();
- std::vector<PowerMode> modes;
- modes.push_back(PowerMode::OFF);
- modes.push_back(PowerMode::ON);
+ std::vector<PowerMode> modes;
+ modes.push_back(PowerMode::OFF);
+ modes.push_back(PowerMode::ON);
- if (isSuspendSupported) {
- modes.push_back(PowerMode::ON_SUSPEND);
- }
+ if (isSuspendSupported) {
+ modes.push_back(PowerMode::ON_SUSPEND);
+ }
- if (isDozeSupported) {
- modes.push_back(PowerMode::DOZE);
- }
+ if (isDozeSupported) {
+ modes.push_back(PowerMode::DOZE);
+ }
- if (isSuspendSupported && isDozeSupported) {
- modes.push_back(PowerMode::DOZE_SUSPEND);
- }
+ if (isSuspendSupported && isDozeSupported) {
+ modes.push_back(PowerMode::DOZE_SUSPEND);
+ }
- for (auto mode : modes) {
- EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
+ for (auto mode : modes) {
+ EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), mode).isOk());
+ }
}
}
TEST_P(GraphicsComposerAidlTest, SetPowerModeVariations) {
- const auto& [status, capabilities] =
- mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
- ASSERT_TRUE(status.isOk());
+ for (const auto& display : mDisplays) {
+ const auto& [status, capabilities] =
+ mComposerClient->getDisplayCapabilities(display.getDisplayId());
+ ASSERT_TRUE(status.isOk());
- const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
- DisplayCapability::DOZE) != capabilities.end();
- const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
- DisplayCapability::SUSPEND) != capabilities.end();
+ const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
+ DisplayCapability::DOZE) != capabilities.end();
+ const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
+ DisplayCapability::SUSPEND) != capabilities.end();
- std::vector<PowerMode> modes;
+ std::vector<PowerMode> modes;
- modes.push_back(PowerMode::OFF);
- modes.push_back(PowerMode::ON);
- modes.push_back(PowerMode::OFF);
- for (auto mode : modes) {
- EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
- }
- modes.clear();
-
- modes.push_back(PowerMode::OFF);
- modes.push_back(PowerMode::OFF);
- for (auto mode : modes) {
- EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
- }
- modes.clear();
-
- modes.push_back(PowerMode::ON);
- modes.push_back(PowerMode::ON);
- for (auto mode : modes) {
- EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
- }
- modes.clear();
-
- if (isSuspendSupported) {
- modes.push_back(PowerMode::ON_SUSPEND);
- modes.push_back(PowerMode::ON_SUSPEND);
+ modes.push_back(PowerMode::OFF);
+ modes.push_back(PowerMode::ON);
+ modes.push_back(PowerMode::OFF);
for (auto mode : modes) {
- EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
+ EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), mode).isOk());
}
modes.clear();
- }
- if (isDozeSupported) {
- modes.push_back(PowerMode::DOZE);
- modes.push_back(PowerMode::DOZE);
+ modes.push_back(PowerMode::OFF);
+ modes.push_back(PowerMode::OFF);
for (auto mode : modes) {
- EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
+ EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), mode).isOk());
}
modes.clear();
- }
- if (isSuspendSupported && isDozeSupported) {
- modes.push_back(PowerMode::DOZE_SUSPEND);
- modes.push_back(PowerMode::DOZE_SUSPEND);
+ modes.push_back(PowerMode::ON);
+ modes.push_back(PowerMode::ON);
for (auto mode : modes) {
- EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
+ EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), mode).isOk());
}
modes.clear();
+
+ if (isSuspendSupported) {
+ modes.push_back(PowerMode::ON_SUSPEND);
+ modes.push_back(PowerMode::ON_SUSPEND);
+ for (auto mode : modes) {
+ EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), mode).isOk());
+ }
+ modes.clear();
+ }
+
+ if (isDozeSupported) {
+ modes.push_back(PowerMode::DOZE);
+ modes.push_back(PowerMode::DOZE);
+ for (auto mode : modes) {
+ EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), mode).isOk());
+ }
+ modes.clear();
+ }
+
+ if (isSuspendSupported && isDozeSupported) {
+ modes.push_back(PowerMode::DOZE_SUSPEND);
+ modes.push_back(PowerMode::DOZE_SUSPEND);
+ for (auto mode : modes) {
+ EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), mode).isOk());
+ }
+ modes.clear();
+ }
}
}
@@ -1145,11 +1205,14 @@
}
TEST_P(GraphicsComposerAidlTest, SetPowerMode_BadParameter) {
- const auto& status =
- mComposerClient->setPowerMode(getPrimaryDisplayId(), static_cast<PowerMode>(-1));
+ for (const auto& display : mDisplays) {
+ const auto& status =
+ mComposerClient->setPowerMode(display.getDisplayId(), static_cast<PowerMode>(-1));
- EXPECT_FALSE(status.isOk());
- EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
+ EXPECT_FALSE(status.isOk());
+ EXPECT_NO_FATAL_FAILURE(
+ assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
+ }
}
TEST_P(GraphicsComposerAidlTest, GetDataspaceSaturationMatrix) {
@@ -1419,9 +1482,11 @@
void TearDown() override {
ASSERT_FALSE(mDisplays.empty());
ASSERT_TRUE(mReader.takeErrors().empty());
- ASSERT_TRUE(mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty());
- ASSERT_TRUE(mComposerClient->tearDown(&getWriter(getPrimaryDisplayId())));
+ for (const auto& display : mDisplays) {
+ ASSERT_TRUE(mReader.takeChangedCompositionTypes(display.getDisplayId()).empty());
+ ASSERT_TRUE(mComposerClient->tearDown(&getWriter(display.getDisplayId())));
+ }
ASSERT_NO_FATAL_FAILURE(GraphicsComposerAidlTest::TearDown());
}
@@ -1490,9 +1555,9 @@
"VtsHalGraphicsComposer3_TargetTest");
}
- sp<GraphicBuffer> allocate(::android::PixelFormat pixelFormat) {
- return allocate(static_cast<uint32_t>(getPrimaryDisplay().getDisplayWidth()),
- static_cast<uint32_t>(getPrimaryDisplay().getDisplayHeight()), pixelFormat);
+ sp<GraphicBuffer> allocate(::android::PixelFormat pixelFormat, const DisplayWrapper& display) {
+ return allocate(static_cast<uint32_t>(display.getDisplayWidth()),
+ static_cast<uint32_t>(display.getDisplayHeight()), pixelFormat);
}
void sendRefreshFrame(const DisplayWrapper& display,
@@ -1515,7 +1580,7 @@
mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
EXPECT_TRUE(status.isOk());
{
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
ASSERT_NE(nullptr, buffer);
ASSERT_EQ(::android::OK, buffer->initCheck());
ASSERT_NE(nullptr, buffer->handle);
@@ -1537,7 +1602,7 @@
}
{
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
ASSERT_NE(nullptr, buffer->handle);
writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, buffer->handle,
@@ -1557,10 +1622,8 @@
}
sp<::android::Fence> presentAndGetFence(
- std::optional<ClockMonotonicTimestamp> expectedPresentTime,
- std::optional<int> displayIdOpt = {},
+ std::optional<ClockMonotonicTimestamp> expectedPresentTime, int64_t displayId,
int32_t frameIntervalNs = ComposerClientWrapper::kNoFrameIntervalNs) {
- const auto displayId = displayIdOpt.value_or(getPrimaryDisplayId());
auto& writer = getWriter(displayId);
writer.validateDisplay(displayId, expectedPresentTime, frameIntervalNs);
execute();
@@ -1578,13 +1641,12 @@
return sp<::android::Fence>::make(fenceOwner);
}
- int32_t getVsyncPeriod() {
- const auto& [status, activeConfig] =
- mComposerClient->getActiveConfig(getPrimaryDisplayId());
+ int32_t getVsyncPeriod(int64_t displayId) {
+ const auto& [status, activeConfig] = mComposerClient->getActiveConfig(displayId);
EXPECT_TRUE(status.isOk());
const auto& [vsyncPeriodStatus, vsyncPeriod] = mComposerClient->getDisplayAttribute(
- getPrimaryDisplayId(), activeConfig, DisplayAttribute::VSYNC_PERIOD);
+ displayId, activeConfig, DisplayAttribute::VSYNC_PERIOD);
EXPECT_TRUE(vsyncPeriodStatus.isOk());
return vsyncPeriod;
}
@@ -1603,16 +1665,16 @@
return layer;
}
- void sendBufferUpdate(int64_t layer) {
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
+ void sendBufferUpdate(int64_t layer, int64_t displayId) {
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, displayId);
ASSERT_NE(nullptr, buffer->handle);
- auto& writer = getWriter(getPrimaryDisplayId());
- writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer->handle,
+ auto& writer = getWriter(displayId);
+ writer.setLayerBuffer(displayId, layer, /*slot*/ 0, buffer->handle,
/*acquireFence*/ -1);
const sp<::android::Fence> presentFence =
- presentAndGetFence(ComposerClientWriter::kNoTimestamp);
+ presentAndGetFence(ComposerClientWriter::kNoTimestamp, displayId);
presentFence->waitForever(LOG_TAG);
}
@@ -1708,46 +1770,51 @@
return;
}
- ASSERT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
+ for (const auto& display : mDisplays) {
+ ASSERT_TRUE(
+ mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::ON).isOk());
- const auto vsyncPeriod = getVsyncPeriod();
+ const auto vsyncPeriod = getVsyncPeriod(display.getDisplayId());
- const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
- const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
- ASSERT_NE(nullptr, buffer1);
- ASSERT_NE(nullptr, buffer2);
+ const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
+ const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
+ ASSERT_NE(nullptr, buffer1);
+ ASSERT_NE(nullptr, buffer2);
- const auto layer = createOnScreenLayer(getPrimaryDisplay());
- auto& writer = getWriter(getPrimaryDisplayId());
- writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer1->handle,
- /*acquireFence*/ -1);
- const sp<::android::Fence> presentFence1 =
- presentAndGetFence(ComposerClientWriter::kNoTimestamp);
- presentFence1->waitForever(LOG_TAG);
+ const auto layer = createOnScreenLayer(display);
+ auto& writer = getWriter(display.getDisplayId());
+ writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, buffer1->handle,
+ /*acquireFence*/ -1);
+ const sp<::android::Fence> presentFence1 =
+ presentAndGetFence(ComposerClientWriter::kNoTimestamp, display.getDisplayId());
+ presentFence1->waitForever(LOG_TAG);
- auto expectedPresentTime = presentFence1->getSignalTime() + vsyncPeriod;
- if (framesDelay.has_value()) {
- expectedPresentTime += *framesDelay * vsyncPeriod;
- }
-
- writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer2->handle,
- /*acquireFence*/ -1);
- const auto setExpectedPresentTime = [&]() -> std::optional<ClockMonotonicTimestamp> {
- if (!framesDelay.has_value()) {
- return ComposerClientWriter::kNoTimestamp;
- } else if (*framesDelay == 0) {
- return ClockMonotonicTimestamp{0};
+ auto expectedPresentTime = presentFence1->getSignalTime() + vsyncPeriod;
+ if (framesDelay.has_value()) {
+ expectedPresentTime += *framesDelay * vsyncPeriod;
}
- return ClockMonotonicTimestamp{expectedPresentTime};
- }();
- const sp<::android::Fence> presentFence2 = presentAndGetFence(setExpectedPresentTime);
- presentFence2->waitForever(LOG_TAG);
+ writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, buffer2->handle,
+ /*acquireFence*/ -1);
+ const auto setExpectedPresentTime = [&]() -> std::optional<ClockMonotonicTimestamp> {
+ if (!framesDelay.has_value()) {
+ return ComposerClientWriter::kNoTimestamp;
+ } else if (*framesDelay == 0) {
+ return ClockMonotonicTimestamp{0};
+ }
+ return ClockMonotonicTimestamp{expectedPresentTime};
+ }();
- const auto actualPresentTime = presentFence2->getSignalTime();
- EXPECT_GE(actualPresentTime, expectedPresentTime - vsyncPeriod / 2);
+ const sp<::android::Fence> presentFence2 =
+ presentAndGetFence(setExpectedPresentTime, display.getDisplayId());
+ presentFence2->waitForever(LOG_TAG);
- ASSERT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
+ const auto actualPresentTime = presentFence2->getSignalTime();
+ EXPECT_GE(actualPresentTime, expectedPresentTime - vsyncPeriod / 2);
+
+ ASSERT_TRUE(
+ mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::OFF).isOk());
+ }
}
void forEachNotifyExpectedPresentConfig(
@@ -1778,7 +1845,7 @@
}
}
EXPECT_TRUE(
- mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
+ mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::OFF).isOk());
}
}
@@ -1839,86 +1906,94 @@
};
TEST_P(GraphicsComposerAidlCommandTest, SetColorTransform) {
- auto& writer = getWriter(getPrimaryDisplayId());
- writer.setColorTransform(getPrimaryDisplayId(), kIdentity.data());
- execute();
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ writer.setColorTransform(display.getDisplayId(), kIdentity.data());
+ execute();
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerColorTransform) {
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [status, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(status.isOk());
- writer.setLayerColorTransform(getPrimaryDisplayId(), layer, kIdentity.data());
- execute();
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [status, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(status.isOk());
+ writer.setLayerColorTransform(display.getDisplayId(), layer, kIdentity.data());
+ execute();
- const auto errors = mReader.takeErrors();
- if (errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_UNSUPPORTED) {
- GTEST_SUCCEED() << "setLayerColorTransform is not supported";
- return;
+ const auto errors = mReader.takeErrors();
+ if (errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_UNSUPPORTED) {
+ GTEST_SUCCEED() << "setLayerColorTransform is not supported";
+ continue;
+ }
}
}
TEST_P(GraphicsComposerAidlCommandTest, SetDisplayBrightness) {
- EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
- const auto& [status, capabilities] =
- mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
- ASSERT_TRUE(status.isOk());
- bool brightnessSupport = std::find(capabilities.begin(), capabilities.end(),
- DisplayCapability::BRIGHTNESS) != capabilities.end();
- auto& writer = getWriter(getPrimaryDisplayId());
- if (!brightnessSupport) {
- writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.5f, -1.f);
+ for (const auto& display : mDisplays) {
+ const auto& [status, capabilities] =
+ mComposerClient->getDisplayCapabilities(display.getDisplayId());
+ ASSERT_TRUE(status.isOk());
+ bool brightnessSupport = std::find(capabilities.begin(), capabilities.end(),
+ DisplayCapability::BRIGHTNESS) != capabilities.end();
+ auto& writer = getWriter(display.getDisplayId());
+ if (!brightnessSupport) {
+ writer.setDisplayBrightness(display.getDisplayId(), /*brightness*/ 0.5f, -1.f);
+ execute();
+ const auto errors = mReader.takeErrors();
+ ASSERT_EQ(1, errors.size());
+ EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, errors[0].errorCode);
+ GTEST_SUCCEED() << "SetDisplayBrightness is not supported";
+ continue;
+ }
+
+ writer.setDisplayBrightness(display.getDisplayId(), /*brightness*/ 0.0f, -1.f);
execute();
- const auto errors = mReader.takeErrors();
- ASSERT_EQ(1, errors.size());
- EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, errors[0].errorCode);
- GTEST_SUCCEED() << "SetDisplayBrightness is not supported";
- return;
- }
+ EXPECT_TRUE(mReader.takeErrors().empty());
- writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.0f, -1.f);
- execute();
- EXPECT_TRUE(mReader.takeErrors().empty());
+ writer.setDisplayBrightness(display.getDisplayId(), /*brightness*/ 0.5f, -1.f);
+ execute();
+ EXPECT_TRUE(mReader.takeErrors().empty());
- writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.5f, -1.f);
- execute();
- EXPECT_TRUE(mReader.takeErrors().empty());
+ writer.setDisplayBrightness(display.getDisplayId(), /*brightness*/ 1.0f, -1.f);
+ execute();
+ EXPECT_TRUE(mReader.takeErrors().empty());
- writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 1.0f, -1.f);
- execute();
- EXPECT_TRUE(mReader.takeErrors().empty());
+ writer.setDisplayBrightness(display.getDisplayId(), /*brightness*/ -1.0f, -1.f);
+ execute();
+ EXPECT_TRUE(mReader.takeErrors().empty());
- writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ -1.0f, -1.f);
- execute();
- EXPECT_TRUE(mReader.takeErrors().empty());
+ writer.setDisplayBrightness(display.getDisplayId(), /*brightness*/ 2.0f, -1.f);
+ execute();
+ {
+ const auto errors = mReader.takeErrors();
+ ASSERT_EQ(1, errors.size());
+ EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
+ }
- writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 2.0f, -1.f);
- execute();
- {
- const auto errors = mReader.takeErrors();
- ASSERT_EQ(1, errors.size());
- EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
- }
-
- writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ -2.0f, -1.f);
- execute();
- {
- const auto errors = mReader.takeErrors();
- ASSERT_EQ(1, errors.size());
- EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
+ writer.setDisplayBrightness(display.getDisplayId(), /*brightness*/ 2.0f, -1.f);
+ execute();
+ {
+ const auto errors = mReader.takeErrors();
+ ASSERT_EQ(1, errors.size());
+ EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
+ }
}
}
TEST_P(GraphicsComposerAidlCommandTest, SetClientTarget) {
- EXPECT_TRUE(mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kBufferSlotCount)
+ for (const auto& display : mDisplays) {
+ EXPECT_TRUE(
+ mComposerClient->setClientTargetSlotCount(display.getDisplayId(), kBufferSlotCount)
.isOk());
- auto& writer = getWriter(getPrimaryDisplayId());
- writer.setClientTarget(getPrimaryDisplayId(), /*slot*/ 0, nullptr, /*acquireFence*/ -1,
- Dataspace::UNKNOWN, std::vector<Rect>(), 1.0f);
+ auto& writer = getWriter(display.getDisplayId());
+ writer.setClientTarget(display.getDisplayId(), /*slot*/ 0, nullptr, /*acquireFence*/ -1,
+ Dataspace::UNKNOWN, std::vector<Rect>(), 1.0f);
- execute();
+ execute();
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetOutputBuffer) {
@@ -1934,34 +2009,43 @@
kBufferSlotCount);
EXPECT_TRUE(displayStatus.isOk());
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
+ // Use dimensions from the primary display
+ const DisplayWrapper& primary = mDisplays[0];
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, primary);
const auto handle = buffer->handle;
auto& writer = getWriter(display.display);
- writer.setOutputBuffer(display.display, /*slot*/ 0, handle, /*releaseFence*/ -1);
+ writer.setOutputBuffer(display.display, /*slot*/ 0, handle,
+ /*releaseFence*/ -1);
execute();
}
TEST_P(GraphicsComposerAidlCommandTest, ValidDisplay) {
- auto& writer = getWriter(getPrimaryDisplayId());
- writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- ComposerClientWrapper::kNoFrameIntervalNs);
- execute();
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
+ execute();
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, AcceptDisplayChanges) {
- auto& writer = getWriter(getPrimaryDisplayId());
- writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- ComposerClientWrapper::kNoFrameIntervalNs);
- writer.acceptDisplayChanges(getPrimaryDisplayId());
- execute();
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
+ writer.acceptDisplayChanges(display.getDisplayId());
+ execute();
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, PresentDisplay) {
- auto& writer = getWriter(getPrimaryDisplayId());
- writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- ComposerClientWrapper::kNoFrameIntervalNs);
- writer.presentDisplay(getPrimaryDisplayId());
- execute();
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
+ writer.presentDisplay(display.getDisplayId());
+ execute();
+ }
}
/**
@@ -1972,260 +2056,278 @@
* surface damage have been set
*/
TEST_P(GraphicsComposerAidlCommandTest, PresentDisplayNoLayerStateChanges) {
- EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
+ for (const auto& display : mDisplays) {
+ EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::ON).isOk());
- const auto& [renderIntentsStatus, renderIntents] =
- mComposerClient->getRenderIntents(getPrimaryDisplayId(), ColorMode::NATIVE);
- EXPECT_TRUE(renderIntentsStatus.isOk());
- auto& writer = getWriter(getPrimaryDisplayId());
- for (auto intent : renderIntents) {
- EXPECT_TRUE(mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE, intent)
+ const auto& [renderIntentsStatus, renderIntents] =
+ mComposerClient->getRenderIntents(display.getDisplayId(), ColorMode::NATIVE);
+ EXPECT_TRUE(renderIntentsStatus.isOk());
+ auto& writer = getWriter(display.getDisplayId());
+ for (auto intent : renderIntents) {
+ EXPECT_TRUE(
+ mComposerClient->setColorMode(display.getDisplayId(), ColorMode::NATIVE, intent)
.isOk());
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
- const auto handle = buffer->handle;
- ASSERT_NE(nullptr, handle);
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
+ const auto handle = buffer->handle;
+ ASSERT_NE(nullptr, handle);
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
- Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
- getPrimaryDisplay().getDisplayHeight()};
- FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
- (float)getPrimaryDisplay().getDisplayHeight()};
- configureLayer(getPrimaryDisplay(), layer, Composition::CURSOR, displayFrame, cropRect);
- writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle,
- /*acquireFence*/ -1);
- writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
- writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- ComposerClientWrapper::kNoFrameIntervalNs);
- execute();
- if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
- GTEST_SUCCEED() << "Composition change requested, skipping test";
- return;
+ Rect displayFrame{0, 0, display.getDisplayWidth(), display.getDisplayHeight()};
+ FRect cropRect{0, 0, (float)display.getDisplayWidth(),
+ (float)display.getDisplayHeight()};
+ configureLayer(display, layer, Composition::CURSOR, displayFrame, cropRect);
+ writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, handle,
+ /*acquireFence*/ -1);
+ writer.setLayerDataspace(display.getDisplayId(), layer, Dataspace::UNKNOWN);
+ writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
+ execute();
+ if (!mReader.takeChangedCompositionTypes(display.getDisplayId()).empty()) {
+ GTEST_SUCCEED() << "Composition change requested, skipping test";
+ return;
+ }
+
+ ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.presentDisplay(display.getDisplayId());
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
+
+ const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
+ const auto handle2 = buffer2->handle;
+ ASSERT_NE(nullptr, handle2);
+ writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, handle2,
+ /*acquireFence*/ -1);
+ writer.setLayerSurfaceDamage(display.getDisplayId(), layer,
+ std::vector<Rect>(1, {0, 0, 10, 10}));
+ writer.presentDisplay(display.getDisplayId());
+ execute();
}
-
- ASSERT_TRUE(mReader.takeErrors().empty());
- writer.presentDisplay(getPrimaryDisplayId());
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
-
- const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
- const auto handle2 = buffer2->handle;
- ASSERT_NE(nullptr, handle2);
- writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle2,
- /*acquireFence*/ -1);
- writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer,
- std::vector<Rect>(1, {0, 0, 10, 10}));
- writer.presentDisplay(getPrimaryDisplayId());
- execute();
}
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerCursorPosition) {
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
- const auto handle = buffer->handle;
- ASSERT_NE(nullptr, handle);
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
+ const auto handle = buffer->handle;
+ ASSERT_NE(nullptr, handle);
- writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle, /*acquireFence*/ -1);
+ writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, handle,
+ /*acquireFence*/ -1);
- Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
- getPrimaryDisplay().getDisplayHeight()};
- FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
- (float)getPrimaryDisplay().getDisplayHeight()};
- configureLayer(getPrimaryDisplay(), layer, Composition::CURSOR, displayFrame, cropRect);
- writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
- writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- ComposerClientWrapper::kNoFrameIntervalNs);
+ Rect displayFrame{0, 0, display.getDisplayWidth(), display.getDisplayHeight()};
+ FRect cropRect{0, 0, (float)display.getDisplayWidth(), (float)display.getDisplayHeight()};
+ configureLayer(display, layer, Composition::CURSOR, displayFrame, cropRect);
+ writer.setLayerDataspace(display.getDisplayId(), layer, Dataspace::UNKNOWN);
+ writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
- execute();
+ execute();
- if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
- GTEST_SUCCEED() << "Composition change requested, skipping test";
- return;
+ if (!mReader.takeChangedCompositionTypes(display.getDisplayId()).empty()) {
+ continue; // Skip this display if composition change requested
+ }
+ writer.presentDisplay(display.getDisplayId());
+ ASSERT_TRUE(mReader.takeErrors().empty());
+
+ writer.setLayerCursorPosition(display.getDisplayId(), layer, /*x*/ 1, /*y*/ 1);
+ execute();
+
+ writer.setLayerCursorPosition(display.getDisplayId(), layer, /*x*/ 0, /*y*/ 0);
+ writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
+ execute();
}
- writer.presentDisplay(getPrimaryDisplayId());
- ASSERT_TRUE(mReader.takeErrors().empty());
-
- writer.setLayerCursorPosition(getPrimaryDisplayId(), layer, /*x*/ 1, /*y*/ 1);
- execute();
-
- writer.setLayerCursorPosition(getPrimaryDisplayId(), layer, /*x*/ 0, /*y*/ 0);
- writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- ComposerClientWrapper::kNoFrameIntervalNs);
- writer.presentDisplay(getPrimaryDisplayId());
- execute();
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerBuffer) {
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
- const auto handle = buffer->handle;
- ASSERT_NE(nullptr, handle);
+ for (const auto& display : mDisplays) {
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
+ const auto handle = buffer->handle;
+ ASSERT_NE(nullptr, handle);
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
- writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle, /*acquireFence*/ -1);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
+ writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, handle,
+ /*acquireFence*/ -1);
+ execute();
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerBufferMultipleTimes) {
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
- // Setup 3 buffers in the buffer cache, with the last buffer being active. Then, emulate the
- // Android platform code that clears all 3 buffer slots by setting all but the active buffer
- // slot to a placeholder buffer, and then restoring the active buffer.
+ // Setup 3 buffers in the buffer cache, with the last buffer being active. Then, emulate the
+ // Android platform code that clears all 3 buffer slots by setting all but the active buffer
+ // slot to a placeholder buffer, and then restoring the active buffer.
- // This is used on HALs that don't support setLayerBufferSlotsToClear (version <= 3.1).
+ // This is used on HALs that don't support setLayerBufferSlotsToClear (version <= 3.1).
- const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
- ASSERT_NE(nullptr, buffer1);
- const auto handle1 = buffer1->handle;
- writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle1, /*acquireFence*/ -1);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
+ ASSERT_NE(nullptr, buffer1);
+ const auto handle1 = buffer1->handle;
+ writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, handle1,
+ /*acquireFence*/ -1);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
- ASSERT_NE(nullptr, buffer2);
- const auto handle2 = buffer2->handle;
- writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 1, handle2, /*acquireFence*/ -1);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
+ ASSERT_NE(nullptr, buffer2);
+ const auto handle2 = buffer2->handle;
+ writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 1, handle2,
+ /*acquireFence*/ -1);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- const auto buffer3 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
- ASSERT_NE(nullptr, buffer3);
- const auto handle3 = buffer3->handle;
- writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 2, handle3, /*acquireFence*/ -1);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ const auto buffer3 = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
+ ASSERT_NE(nullptr, buffer3);
+ const auto handle3 = buffer3->handle;
+ writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 2, handle3,
+ /*acquireFence*/ -1);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- // Older versions of the HAL clear all but the active buffer slot with a placeholder buffer,
- // and then restoring the current active buffer at the end
- auto clearSlotBuffer = allocate(1u, 1u, ::android::PIXEL_FORMAT_RGB_888);
- ASSERT_NE(nullptr, clearSlotBuffer);
- auto clearSlotBufferHandle = clearSlotBuffer->handle;
+ // Older versions of the HAL clear all but the active buffer slot with a placeholder buffer,
+ // and then restoring the current active buffer at the end
+ auto clearSlotBuffer = allocate(1u, 1u, ::android::PIXEL_FORMAT_RGB_888);
+ ASSERT_NE(nullptr, clearSlotBuffer);
+ auto clearSlotBufferHandle = clearSlotBuffer->handle;
- // clear buffer slots 0 and 1 with new layer commands... and then...
- writer.setLayerBufferWithNewCommand(getPrimaryDisplayId(), layer, /* slot */ 0,
- clearSlotBufferHandle, /*acquireFence*/ -1);
- writer.setLayerBufferWithNewCommand(getPrimaryDisplayId(), layer, /* slot */ 1,
- clearSlotBufferHandle, /*acquireFence*/ -1);
- // ...reset the layer buffer to the current active buffer slot with a final new command
- writer.setLayerBufferWithNewCommand(getPrimaryDisplayId(), layer, /*slot*/ 2, nullptr,
- /*acquireFence*/ -1);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ // clear buffer slots 0 and 1 with new layer commands... and then...
+ writer.setLayerBufferWithNewCommand(display.getDisplayId(), layer, /* slot */ 0,
+ clearSlotBufferHandle, /*acquireFence*/ -1);
+ writer.setLayerBufferWithNewCommand(display.getDisplayId(), layer, /* slot */ 1,
+ clearSlotBufferHandle, /*acquireFence*/ -1);
+ // ...reset the layer buffer to the current active buffer slot with a final new command
+ writer.setLayerBufferWithNewCommand(display.getDisplayId(), layer, /*slot*/ 2, nullptr,
+ /*acquireFence*/ -1);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerSurfaceDamage) {
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
- Rect empty{0, 0, 0, 0};
- Rect unit{0, 0, 1, 1};
+ Rect empty{0, 0, 0, 0};
+ Rect unit{0, 0, 1, 1};
- writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerSurfaceDamage(display.getDisplayId(), layer, std::vector<Rect>(1, empty));
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerSurfaceDamage(display.getDisplayId(), layer, std::vector<Rect>(1, unit));
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>());
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerSurfaceDamage(display.getDisplayId(), layer, std::vector<Rect>());
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerBlockingRegion) {
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
- Rect empty{0, 0, 0, 0};
- Rect unit{0, 0, 1, 1};
+ Rect empty{0, 0, 0, 0};
+ Rect unit{0, 0, 1, 1};
- writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerBlockingRegion(display.getDisplayId(), layer, std::vector<Rect>(1, empty));
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerBlockingRegion(display.getDisplayId(), layer, std::vector<Rect>(1, unit));
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>());
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerBlockingRegion(display.getDisplayId(), layer, std::vector<Rect>());
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerBlendMode) {
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
- writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::NONE);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerBlendMode(display.getDisplayId(), layer, BlendMode::NONE);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::PREMULTIPLIED);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerBlendMode(display.getDisplayId(), layer, BlendMode::PREMULTIPLIED);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::COVERAGE);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerBlendMode(display.getDisplayId(), layer, BlendMode::COVERAGE);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerColor) {
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
- writer.setLayerColor(getPrimaryDisplayId(), layer, Color{1.0f, 1.0f, 1.0f, 1.0f});
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerColor(display.getDisplayId(), layer, Color{1.0f, 1.0f, 1.0f, 1.0f});
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerColor(getPrimaryDisplayId(), layer, Color{0.0f, 0.0f, 0.0f, 0.0f});
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerColor(display.getDisplayId(), layer, Color{0.0f, 0.0f, 0.0f, 0.0f});
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerCompositionType) {
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
- writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::CLIENT);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerCompositionType(display.getDisplayId(), layer, Composition::CLIENT);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::DEVICE);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerCompositionType(display.getDisplayId(), layer, Composition::DEVICE);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::SOLID_COLOR);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerCompositionType(display.getDisplayId(), layer, Composition::SOLID_COLOR);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::CURSOR);
- execute();
+ writer.setLayerCompositionType(display.getDisplayId(), layer, Composition::CURSOR);
+ execute();
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, DisplayDecoration) {
@@ -2240,7 +2342,7 @@
const auto format = (error.isOk() && support) ? support->format
: aidl::android::hardware::graphics::common::PixelFormat::RGBA_8888;
- const auto decorBuffer = allocate(static_cast<::android::PixelFormat>(format));
+ const auto decorBuffer = allocate(static_cast<::android::PixelFormat>(format), display);
ASSERT_NE(nullptr, decorBuffer);
if (::android::OK != decorBuffer->initCheck()) {
if (support) {
@@ -2273,38 +2375,42 @@
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerDataspace) {
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
-
- writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
- execute();
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
+ writer.setLayerDataspace(display.getDisplayId(), layer, Dataspace::UNKNOWN);
+ execute();
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerDisplayFrame) {
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
-
- writer.setLayerDisplayFrame(getPrimaryDisplayId(), layer, Rect{0, 0, 1, 1});
- execute();
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
+ writer.setLayerDisplayFrame(display.getDisplayId(), layer, Rect{0, 0, 1, 1});
+ execute();
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerPlaneAlpha) {
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
- writer.setLayerPlaneAlpha(getPrimaryDisplayId(), layer, /*alpha*/ 0.0f);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerPlaneAlpha(display.getDisplayId(), layer, /*alpha*/ 0.0f);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerPlaneAlpha(getPrimaryDisplayId(), layer, /*alpha*/ 1.0f);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerPlaneAlpha(display.getDisplayId(), layer, /*alpha*/ 1.0f);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerSidebandStream) {
@@ -2313,186 +2419,201 @@
return;
}
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
- const auto handle = buffer->handle;
- ASSERT_NE(nullptr, handle);
+ for (const auto& display : mDisplays) {
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
+ const auto handle = buffer->handle;
+ ASSERT_NE(nullptr, handle);
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
- writer.setLayerSidebandStream(getPrimaryDisplayId(), layer, handle);
- execute();
+ writer.setLayerSidebandStream(display.getDisplayId(), layer, handle);
+ execute();
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerSourceCrop) {
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
- writer.setLayerSourceCrop(getPrimaryDisplayId(), layer, FRect{0.0f, 0.0f, 1.0f, 1.0f});
- execute();
+ writer.setLayerSourceCrop(display.getDisplayId(), layer, FRect{0.0f, 0.0f, 1.0f, 1.0f});
+ execute();
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerTransform) {
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
- writer.setLayerTransform(getPrimaryDisplayId(), layer, static_cast<Transform>(0));
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerTransform(display.getDisplayId(), layer, static_cast<Transform>(0));
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::FLIP_H);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerTransform(display.getDisplayId(), layer, Transform::FLIP_H);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::FLIP_V);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerTransform(display.getDisplayId(), layer, Transform::FLIP_V);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_90);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerTransform(display.getDisplayId(), layer, Transform::ROT_90);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_180);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerTransform(display.getDisplayId(), layer, Transform::ROT_180);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_270);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerTransform(display.getDisplayId(), layer, Transform::ROT_270);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerTransform(getPrimaryDisplayId(), layer,
- static_cast<Transform>(static_cast<int>(Transform::FLIP_H) |
- static_cast<int>(Transform::ROT_90)));
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerTransform(display.getDisplayId(), layer,
+ static_cast<Transform>(static_cast<int>(Transform::FLIP_H) |
+ static_cast<int>(Transform::ROT_90)));
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerTransform(getPrimaryDisplayId(), layer,
- static_cast<Transform>(static_cast<int>(Transform::FLIP_V) |
- static_cast<int>(Transform::ROT_90)));
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerTransform(display.getDisplayId(), layer,
+ static_cast<Transform>(static_cast<int>(Transform::FLIP_V) |
+ static_cast<int>(Transform::ROT_90)));
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerVisibleRegion) {
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
- Rect empty{0, 0, 0, 0};
- Rect unit{0, 0, 1, 1};
+ Rect empty{0, 0, 0, 0};
+ Rect unit{0, 0, 1, 1};
- writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerVisibleRegion(display.getDisplayId(), layer, std::vector<Rect>(1, empty));
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerVisibleRegion(display.getDisplayId(), layer, std::vector<Rect>(1, unit));
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>());
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerVisibleRegion(display.getDisplayId(), layer, std::vector<Rect>());
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerZOrder) {
- auto& writer = getWriter(getPrimaryDisplayId());
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
- writer.setLayerZOrder(getPrimaryDisplayId(), layer, /*z*/ 10);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerZOrder(display.getDisplayId(), layer, /*z*/ 10);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerZOrder(getPrimaryDisplayId(), layer, /*z*/ 0);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerZOrder(display.getDisplayId(), layer, /*z*/ 0);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerPerFrameMetadata) {
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
- /**
- * DISPLAY_P3 is a color space that uses the DCI_P3 primaries,
- * the D65 white point and the SRGB transfer functions.
- * Rendering Intent: Colorimetric
- * Primaries:
- * x y
- * green 0.265 0.690
- * blue 0.150 0.060
- * red 0.680 0.320
- * white (D65) 0.3127 0.3290
- */
+ /**
+ * DISPLAY_P3 is a color space that uses the DCI_P3 primaries,
+ * the D65 white point and the SRGB transfer functions.
+ * Rendering Intent: Colorimetric
+ * Primaries:
+ * x y
+ * green 0.265 0.690
+ * blue 0.150 0.060
+ * red 0.680 0.320
+ * white (D65) 0.3127 0.3290
+ */
- std::vector<PerFrameMetadata> aidlMetadata;
- aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X, 0.680f});
- aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y, 0.320f});
- aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X, 0.265f});
- aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y, 0.690f});
- aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X, 0.150f});
- aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y, 0.060f});
- aidlMetadata.push_back({PerFrameMetadataKey::WHITE_POINT_X, 0.3127f});
- aidlMetadata.push_back({PerFrameMetadataKey::WHITE_POINT_Y, 0.3290f});
- aidlMetadata.push_back({PerFrameMetadataKey::MAX_LUMINANCE, 100.0f});
- aidlMetadata.push_back({PerFrameMetadataKey::MIN_LUMINANCE, 0.1f});
- aidlMetadata.push_back({PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL, 78.0});
- aidlMetadata.push_back({PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL, 62.0});
- writer.setLayerPerFrameMetadata(getPrimaryDisplayId(), layer, aidlMetadata);
- execute();
+ std::vector<PerFrameMetadata> aidlMetadata;
+ aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X, 0.680f});
+ aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y, 0.320f});
+ aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X, 0.265f});
+ aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y, 0.690f});
+ aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X, 0.150f});
+ aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y, 0.060f});
+ aidlMetadata.push_back({PerFrameMetadataKey::WHITE_POINT_X, 0.3127f});
+ aidlMetadata.push_back({PerFrameMetadataKey::WHITE_POINT_Y, 0.3290f});
+ aidlMetadata.push_back({PerFrameMetadataKey::MAX_LUMINANCE, 100.0f});
+ aidlMetadata.push_back({PerFrameMetadataKey::MIN_LUMINANCE, 0.1f});
+ aidlMetadata.push_back({PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL, 78.0});
+ aidlMetadata.push_back({PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL, 62.0});
+ writer.setLayerPerFrameMetadata(display.getDisplayId(), layer, aidlMetadata);
+ execute();
- const auto errors = mReader.takeErrors();
- if (errors.size() == 1 && errors[0].errorCode == EX_UNSUPPORTED_OPERATION) {
- GTEST_SUCCEED() << "SetLayerPerFrameMetadata is not supported";
- EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer, &writer).isOk());
- return;
+ const auto errors = mReader.takeErrors();
+ if (errors.size() == 1 && errors[0].errorCode == EX_UNSUPPORTED_OPERATION) {
+ GTEST_SUCCEED() << "SetLayerPerFrameMetadata is not supported";
+ EXPECT_TRUE(
+ mComposerClient->destroyLayer(display.getDisplayId(), layer, &writer).isOk());
+ return;
+ }
+
+ EXPECT_TRUE(mComposerClient->destroyLayer(display.getDisplayId(), layer, &writer).isOk());
}
-
- EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer, &writer).isOk());
}
TEST_P(GraphicsComposerAidlCommandTest, setLayerBrightness) {
- auto& writer = getWriter(getPrimaryDisplayId());
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
- writer.setLayerBrightness(getPrimaryDisplayId(), layer, 0.2f);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerBrightness(display.getDisplayId(), layer, 0.2f);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerBrightness(getPrimaryDisplayId(), layer, 1.f);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerBrightness(display.getDisplayId(), layer, 1.f);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerBrightness(getPrimaryDisplayId(), layer, 0.f);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerBrightness(display.getDisplayId(), layer, 0.f);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerBrightness(getPrimaryDisplayId(), layer, -1.f);
- execute();
- {
- const auto errors = mReader.takeErrors();
- ASSERT_EQ(1, errors.size());
- EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
- }
+ writer.setLayerBrightness(display.getDisplayId(), layer, -1.f);
+ execute();
+ {
+ const auto errors = mReader.takeErrors();
+ ASSERT_EQ(1, errors.size());
+ EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
+ }
- writer.setLayerBrightness(getPrimaryDisplayId(), layer, std::nanf(""));
- execute();
- {
- const auto errors = mReader.takeErrors();
- ASSERT_EQ(1, errors.size());
- EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
+ writer.setLayerBrightness(display.getDisplayId(), layer, std::nanf(""));
+ execute();
+ {
+ const auto errors = mReader.takeErrors();
+ ASSERT_EQ(1, errors.size());
+ EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
+ }
}
}
@@ -2599,77 +2720,86 @@
}
TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Unsupported) {
- const bool hasDisplayIdleTimerSupport =
- hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
- if (!hasDisplayIdleTimerSupport) {
- const auto& status =
- mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0);
- EXPECT_FALSE(status.isOk());
- EXPECT_NO_FATAL_FAILURE(
- assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
+ for (const DisplayWrapper& display : mDisplays) {
+ const bool hasDisplayIdleTimerSupport =
+ hasDisplayCapability(display.getDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
+ if (!hasDisplayIdleTimerSupport) {
+ const auto& status =
+ mComposerClient->setIdleTimerEnabled(display.getDisplayId(), /*timeout*/ 0);
+ EXPECT_FALSE(status.isOk());
+ EXPECT_NO_FATAL_FAILURE(
+ assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
+ }
}
}
TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_BadParameter) {
- const bool hasDisplayIdleTimerSupport =
- hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
- if (!hasDisplayIdleTimerSupport) {
- GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
- return;
- }
+ for (const DisplayWrapper& display : mDisplays) {
+ const bool hasDisplayIdleTimerSupport =
+ hasDisplayCapability(display.getDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
+ if (!hasDisplayIdleTimerSupport) {
+ continue; // DisplayCapability::DISPLAY_IDLE_TIMER is not supported
+ }
- const auto& status =
- mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ -1);
- EXPECT_FALSE(status.isOk());
- EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
+ const auto& status =
+ mComposerClient->setIdleTimerEnabled(display.getDisplayId(), /*timeout*/ -1);
+ EXPECT_FALSE(status.isOk());
+ EXPECT_NO_FATAL_FAILURE(
+ assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Disable) {
- const bool hasDisplayIdleTimerSupport =
- hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
- if (!hasDisplayIdleTimerSupport) {
- GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
- return;
- }
+ for (const DisplayWrapper& display : mDisplays) {
+ const bool hasDisplayIdleTimerSupport =
+ hasDisplayCapability(display.getDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
+ if (!hasDisplayIdleTimerSupport) {
+ continue; // DisplayCapability::DISPLAY_IDLE_TIMER is not supported
+ }
- EXPECT_TRUE(mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0).isOk());
- std::this_thread::sleep_for(1s);
- EXPECT_EQ(0, mComposerClient->getVsyncIdleCount());
+ EXPECT_TRUE(
+ mComposerClient->setIdleTimerEnabled(display.getDisplayId(), /*timeout*/ 0).isOk());
+ std::this_thread::sleep_for(1s);
+ EXPECT_EQ(0, mComposerClient->getVsyncIdleCount());
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Timeout_2) {
- const bool hasDisplayIdleTimerSupport =
- hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
- if (!hasDisplayIdleTimerSupport) {
- GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
- return;
+ for (const DisplayWrapper& display : mDisplays) {
+ const bool hasDisplayIdleTimerSupport =
+ hasDisplayCapability(display.getDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
+ if (!hasDisplayIdleTimerSupport) {
+ GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
+ return;
+ }
+
+ EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::ON).isOk());
+ EXPECT_TRUE(
+ mComposerClient->setIdleTimerEnabled(display.getDisplayId(), /*timeout*/ 0).isOk());
+
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
+ ASSERT_NE(nullptr, buffer->handle);
+
+ const auto layer = createOnScreenLayer(display);
+ auto& writer = getWriter(display.getDisplayId());
+ writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, buffer->handle,
+ /*acquireFence*/ -1);
+ int32_t vsyncIdleCount = mComposerClient->getVsyncIdleCount();
+ auto earlyVsyncIdleTime = systemTime() + std::chrono::nanoseconds(2s).count();
+ EXPECT_TRUE(mComposerClient->setIdleTimerEnabled(display.getDisplayId(), /*timeout*/ 2000)
+ .isOk());
+
+ const sp<::android::Fence> presentFence =
+ presentAndGetFence(ComposerClientWriter::kNoTimestamp, display.getDisplayId());
+ presentFence->waitForever(LOG_TAG);
+
+ std::this_thread::sleep_for(3s);
+ if (vsyncIdleCount < mComposerClient->getVsyncIdleCount()) {
+ EXPECT_GE(mComposerClient->getVsyncIdleTime(), earlyVsyncIdleTime);
+ }
+
+ EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::OFF).isOk());
}
-
- EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
- EXPECT_TRUE(mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0).isOk());
-
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
- ASSERT_NE(nullptr, buffer->handle);
-
- const auto layer = createOnScreenLayer(getPrimaryDisplay());
- auto& writer = getWriter(getPrimaryDisplayId());
- writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer->handle,
- /*acquireFence*/ -1);
- int32_t vsyncIdleCount = mComposerClient->getVsyncIdleCount();
- auto earlyVsyncIdleTime = systemTime() + std::chrono::nanoseconds(2s).count();
- EXPECT_TRUE(
- mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 2000).isOk());
-
- const sp<::android::Fence> presentFence =
- presentAndGetFence(ComposerClientWriter::kNoTimestamp);
- presentFence->waitForever(LOG_TAG);
-
- std::this_thread::sleep_for(3s);
- if (vsyncIdleCount < mComposerClient->getVsyncIdleCount()) {
- EXPECT_GE(mComposerClient->getVsyncIdleTime(), earlyVsyncIdleTime);
- }
-
- EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
}
class GraphicsComposerAidlCommandV2Test : public GraphicsComposerAidlCommandTest {
@@ -2681,6 +2811,7 @@
}
}
};
+
/**
* Test Capability::SKIP_VALIDATE
*
@@ -2695,58 +2826,66 @@
}
TEST_P(GraphicsComposerAidlCommandV2Test, SetLayerBufferSlotsToClear) {
- auto& writer = getWriter(getPrimaryDisplayId());
- // Older HAL versions use a backwards compatible way of clearing buffer slots
- // HAL at version 1 or lower does not have LayerCommand::bufferSlotsToClear
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
+ for (const DisplayWrapper& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ // Older HAL versions use a backwards compatible way of clearing buffer slots
+ // HAL at version 1 or lower does not have LayerCommand::bufferSlotsToClear
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
- // setup 3 buffers in the buffer cache, with the last buffer being active
- // then emulate the Android platform code that clears all 3 buffer slots
+ // setup 3 buffers in the buffer cache, with the last buffer being active
+ // then emulate the Android platform code that clears all 3 buffer slots
- const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
- ASSERT_NE(nullptr, buffer1);
- const auto handle1 = buffer1->handle;
- writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle1, /*acquireFence*/ -1);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888, display.getDisplayId());
+ ASSERT_NE(nullptr, buffer1);
+ const auto handle1 = buffer1->handle;
+ writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, handle1,
+ /*acquireFence*/ -1);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
- ASSERT_NE(nullptr, buffer2);
- const auto handle2 = buffer2->handle;
- writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 1, handle2, /*acquireFence*/ -1);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888, display.getDisplayId());
+ ASSERT_NE(nullptr, buffer2);
+ const auto handle2 = buffer2->handle;
+ writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 1, handle2,
+ /*acquireFence*/ -1);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- const auto buffer3 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
- ASSERT_NE(nullptr, buffer3);
- const auto handle3 = buffer3->handle;
- writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 2, handle3, /*acquireFence*/ -1);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ const auto buffer3 = allocate(::android::PIXEL_FORMAT_RGBA_8888, display.getDisplayId());
+ ASSERT_NE(nullptr, buffer3);
+ const auto handle3 = buffer3->handle;
+ writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 2, handle3,
+ /*acquireFence*/ -1);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- // Ensure we can clear all 3 buffer slots, even the active buffer - it is assumed the
- // current active buffer's slot will be cleared, but still remain the active buffer and no
- // errors will occur.
- writer.setLayerBufferSlotsToClear(getPrimaryDisplayId(), layer, {0, 1, 2});
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ // Ensure we can clear all 3 buffer slots, even the active buffer - it is assumed the
+ // current active buffer's slot will be cleared, but still remain the active buffer and no
+ // errors will occur.
+ writer.setLayerBufferSlotsToClear(display.getDisplayId(), layer, {0, 1, 2});
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
+ }
}
TEST_P(GraphicsComposerAidlCommandV2Test, SetRefreshRateChangedCallbackDebug_Unsupported) {
if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
- auto status = mComposerClient->setRefreshRateChangedCallbackDebugEnabled(
- getPrimaryDisplayId(), /*enabled*/ true);
- EXPECT_FALSE(status.isOk());
- EXPECT_NO_FATAL_FAILURE(
- assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
+ for (const DisplayWrapper& display : mDisplays) {
+ auto status = mComposerClient->setRefreshRateChangedCallbackDebugEnabled(
+ display.getDisplayId(), /*enabled*/ true);
+ EXPECT_FALSE(status.isOk());
+ EXPECT_NO_FATAL_FAILURE(
+ assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
- status = mComposerClient->setRefreshRateChangedCallbackDebugEnabled(getPrimaryDisplayId(),
- /*enabled*/ false);
- EXPECT_FALSE(status.isOk());
- EXPECT_NO_FATAL_FAILURE(
- assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
+ status = mComposerClient->setRefreshRateChangedCallbackDebugEnabled(
+ display.getDisplayId(),
+ /*enabled*/ false);
+ EXPECT_FALSE(status.isOk());
+ EXPECT_NO_FATAL_FAILURE(
+ assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
+ }
}
}
@@ -2799,54 +2938,55 @@
return;
}
- auto display = getEditablePrimaryDisplay();
- const auto displayId = display.getDisplayId();
+ for (DisplayWrapper& display : mDisplays) {
+ const auto displayId = display.getDisplayId();
- if (!hasDisplayCapability(displayId, DisplayCapability::DISPLAY_IDLE_TIMER)) {
- GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
- return;
- }
-
- EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
- EXPECT_TRUE(mComposerClient->setPeakRefreshRateConfig(&display).isOk());
-
- ASSERT_TRUE(mComposerClient->setIdleTimerEnabled(displayId, /*timeoutMs*/ 500).isOk());
- // Enable the callback
- ASSERT_TRUE(mComposerClient
- ->setRefreshRateChangedCallbackDebugEnabled(displayId,
- /*enabled*/ true)
- .isOk());
-
- const auto displayFilter = [displayId](auto refreshRateChangedDebugData) {
- return displayId == refreshRateChangedDebugData.display;
- };
-
- int retryCount = 3;
- do {
- // Wait for 1s so that we enter the idle state
- std::this_thread::sleep_for(1s);
- if (!checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter)) {
- // DID NOT receive a callback, we are in the idle state.
- break;
+ if (!hasDisplayCapability(displayId, DisplayCapability::DISPLAY_IDLE_TIMER)) {
+ GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
+ return;
}
- } while (--retryCount > 0);
- if (retryCount == 0) {
- GTEST_SUCCEED() << "Unable to enter the idle mode";
- return;
+ EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
+ EXPECT_TRUE(mComposerClient->setPeakRefreshRateConfig(&display).isOk());
+
+ ASSERT_TRUE(mComposerClient->setIdleTimerEnabled(displayId, /*timeoutMs*/ 500).isOk());
+ // Enable the callback
+ ASSERT_TRUE(mComposerClient
+ ->setRefreshRateChangedCallbackDebugEnabled(displayId,
+ /*enabled*/ true)
+ .isOk());
+
+ const auto displayFilter = [displayId](auto refreshRateChangedDebugData) {
+ return displayId == refreshRateChangedDebugData.display;
+ };
+
+ int retryCount = 3;
+ do {
+ // Wait for 1s so that we enter the idle state
+ std::this_thread::sleep_for(1s);
+ if (!checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter)) {
+ // DID NOT receive a callback, we are in the idle state.
+ break;
+ }
+ } while (--retryCount > 0);
+
+ if (retryCount == 0) {
+ GTEST_SUCCEED() << "Unable to enter the idle mode";
+ return;
+ }
+
+ // Send the REFRESH_RATE_INDICATOR update
+ ASSERT_NO_FATAL_FAILURE(sendBufferUpdate(
+ createOnScreenLayer(display, Composition::REFRESH_RATE_INDICATOR), displayId));
+ std::this_thread::sleep_for(1s);
+ EXPECT_FALSE(checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter))
+ << "A callback should not be received for REFRESH_RATE_INDICATOR";
+
+ EXPECT_TRUE(mComposerClient
+ ->setRefreshRateChangedCallbackDebugEnabled(displayId,
+ /*enabled*/ false)
+ .isOk());
}
-
- // Send the REFRESH_RATE_INDICATOR update
- ASSERT_NO_FATAL_FAILURE(sendBufferUpdate(
- createOnScreenLayer(getPrimaryDisplay(), Composition::REFRESH_RATE_INDICATOR)));
- std::this_thread::sleep_for(1s);
- EXPECT_FALSE(checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter))
- << "A callback should not be received for REFRESH_RATE_INDICATOR";
-
- EXPECT_TRUE(mComposerClient
- ->setRefreshRateChangedCallbackDebugEnabled(displayId,
- /*enabled*/ false)
- .isOk());
}
TEST_P(GraphicsComposerAidlCommandV2Test,
@@ -2960,7 +3100,7 @@
const auto& [status, layer] =
mComposerClient->createLayer(displayId, kBufferSlotCount, &writer);
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, displayId);
ASSERT_NE(nullptr, buffer);
ASSERT_EQ(::android::OK, buffer->initCheck());
ASSERT_NE(nullptr, buffer->handle);
@@ -3035,12 +3175,14 @@
GTEST_SKIP() << "LAYER_LIFECYCLE_BATCH_COMMAND not supported by the implementation";
return;
}
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [status, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(status.isOk());
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ for (const DisplayWrapper& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [status, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(status.isOk());
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
+ }
}
TEST_P(GraphicsComposerAidlCommandV3Test, CreateBatchedCommand_BadDisplay) {
@@ -3064,15 +3206,18 @@
GTEST_SKIP() << "LAYER_LIFECYCLE_BATCH_COMMAND not supported by the implementation";
return;
}
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [status, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(status.isOk());
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
- EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer, &writer).isOk());
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+
+ for (const DisplayWrapper& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [status, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(status.isOk());
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
+ EXPECT_TRUE(mComposerClient->destroyLayer(display.getDisplayId(), layer, &writer).isOk());
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
+ }
}
TEST_P(GraphicsComposerAidlCommandV3Test, DestroyBatchedCommand_BadDisplay) {
@@ -3080,20 +3225,23 @@
GTEST_SKIP() << "LAYER_LIFECYCLE_BATCH_COMMAND not supported by the implementation";
return;
}
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [status, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(status.isOk());
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ for (const DisplayWrapper& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [status, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
- auto& invalid_writer = getWriter(getInvalidDisplayId());
- invalid_writer.setLayerLifecycleBatchCommandType(getInvalidDisplayId(), layer,
- LayerLifecycleBatchCommandType::DESTROY);
- execute();
- const auto errors = mReader.takeErrors();
- ASSERT_TRUE(errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_BAD_DISPLAY);
+ EXPECT_TRUE(status.isOk());
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
+
+ auto& invalid_writer = getWriter(getInvalidDisplayId());
+ invalid_writer.setLayerLifecycleBatchCommandType(getInvalidDisplayId(), layer,
+ LayerLifecycleBatchCommandType::DESTROY);
+ execute();
+ const auto errors = mReader.takeErrors();
+ ASSERT_TRUE(errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_BAD_DISPLAY);
+ }
}
TEST_P(GraphicsComposerAidlCommandV3Test, NoCreateDestroyBatchedCommandIncorrectLayer) {
@@ -3102,13 +3250,15 @@
return;
}
- auto& writer = getWriter(getPrimaryDisplayId());
- int64_t layer = 5;
- writer.setLayerLifecycleBatchCommandType(getPrimaryDisplayId(), layer,
- LayerLifecycleBatchCommandType::DESTROY);
- execute();
- const auto errors = mReader.takeErrors();
- ASSERT_TRUE(errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_BAD_LAYER);
+ for (const DisplayWrapper& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ int64_t layer = 5;
+ writer.setLayerLifecycleBatchCommandType(display.getDisplayId(), layer,
+ LayerLifecycleBatchCommandType::DESTROY);
+ execute();
+ const auto errors = mReader.takeErrors();
+ ASSERT_TRUE(errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_BAD_LAYER);
+ }
}
TEST_P(GraphicsComposerAidlCommandV3Test, notifyExpectedPresentTimeout) {
@@ -3122,7 +3272,7 @@
auto minFrameIntervalNs = config.vrrConfig->minFrameIntervalNs;
const auto timeoutNs = config.vrrConfig->notifyExpectedPresentConfig->timeoutNs;
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, displayId);
ASSERT_NE(nullptr, buffer);
const auto layer = createOnScreenLayer(display);
auto& writer = getWriter(displayId);
@@ -3159,7 +3309,7 @@
forEachNotifyExpectedPresentConfig([&](DisplayWrapper& display,
const DisplayConfiguration& config) {
const auto displayId = display.getDisplayId();
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, displayId);
ASSERT_NE(nullptr, buffer);
const auto layer = createOnScreenLayer(display);
auto& writer = getWriter(displayId);
@@ -3206,7 +3356,7 @@
forEachNotifyExpectedPresentConfig([&](DisplayWrapper& display,
const DisplayConfiguration& config) {
const auto displayId = display.getDisplayId();
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, displayId);
ASSERT_NE(nullptr, buffer);
const auto layer = createOnScreenLayer(display);
auto& writer = getWriter(displayId);
@@ -3292,7 +3442,7 @@
auto& writer = getWriter(displayId);
const auto layer = createOnScreenLayer(display);
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, displayId);
ASSERT_NE(nullptr, buffer->handle);
// TODO(b/337330263): Lookup profile IDs from MediaQualityManager
writer.setDisplayPictureProfileId(displayId, PictureProfileId(1));
@@ -3317,7 +3467,7 @@
auto& writer = getWriter(displayId);
const auto layer = createOnScreenLayer(display);
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, displayId);
ASSERT_NE(nullptr, buffer->handle);
writer.setLayerBuffer(displayId, layer, /*slot*/ 0, buffer->handle,
/*acquireFence*/ -1);
@@ -3343,7 +3493,7 @@
auto& writer = getWriter(displayId);
for (int profileId = 1; profileId <= maxProfiles + 1; ++profileId) {
const auto layer = createOnScreenLayer(display);
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, displayId);
ASSERT_NE(nullptr, buffer->handle);
writer.setLayerBuffer(displayId, layer, /*slot*/ 0, buffer->handle,
/*acquireFence*/ -1);
@@ -3363,7 +3513,7 @@
int64_t displayId = display.getDisplayId();
auto& writer = getWriter(displayId);
const auto layer = createOnScreenLayer(display);
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, displayId);
ASSERT_NE(nullptr, buffer->handle);
writer.setLayerBuffer(displayId, layer, /*slot*/ 0, buffer->handle,
/*acquireFence*/ -1);
@@ -3382,45 +3532,47 @@
}
TEST_P(GraphicsComposerAidlCommandV4Test, SetUnsupportedLayerLuts) {
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
- const auto& [status, properties] = mComposerClient->getOverlaySupport();
+ for (const DisplayWrapper& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
+ const auto& [status, properties] = mComposerClient->getOverlaySupport();
- // TODO (b/362319189): add Lut VTS enforcement
- if ((!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
- status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) ||
- (status.isOk() && !properties.lutProperties)) {
- int32_t size = 7;
- size_t bufferSize = static_cast<size_t>(size) * sizeof(float);
- int32_t fd = ashmem_create_region("lut_shared_mem", bufferSize);
- void* ptr = mmap(nullptr, bufferSize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
- std::vector<float> buffers = {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f};
- memcpy(ptr, buffers.data(), bufferSize);
- munmap(ptr, bufferSize);
- Luts luts;
- luts.offsets = {0};
- luts.lutProperties = {
- {LutProperties::Dimension::ONE_D, size, {LutProperties::SamplingKey::RGB}}};
- luts.pfd = ndk::ScopedFileDescriptor(fd);
+ // TODO (b/362319189): add Lut VTS enforcement
+ if ((!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
+ status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) ||
+ (status.isOk() && !properties.lutProperties)) {
+ int32_t size = 7;
+ size_t bufferSize = static_cast<size_t>(size) * sizeof(float);
+ int32_t fd = ashmem_create_region("lut_shared_mem", bufferSize);
+ void* ptr = mmap(nullptr, bufferSize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+ std::vector<float> buffers = {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f};
+ memcpy(ptr, buffers.data(), bufferSize);
+ munmap(ptr, bufferSize);
+ Luts luts;
+ luts.offsets = {0};
+ luts.lutProperties = {
+ {LutProperties::Dimension::ONE_D, size, {LutProperties::SamplingKey::RGB}}};
+ luts.pfd = ndk::ScopedFileDescriptor(fd);
- const auto layer = createOnScreenLayer(getPrimaryDisplayId());
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
- ASSERT_NE(nullptr, buffer->handle);
- writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer->handle,
- /*acquireFence*/ -1);
- writer.setLayerLuts(getPrimaryDisplayId(), layer, luts);
- writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- ComposerClientWrapper::kNoFrameIntervalNs);
- execute();
- const auto errors = mReader.takeErrors();
- if (errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_UNSUPPORTED) {
- GTEST_SUCCEED() << "setLayerLuts is not supported";
- return;
+ const auto layer = createOnScreenLayer(display.getDisplayId());
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, display.getDisplayId());
+ ASSERT_NE(nullptr, buffer->handle);
+ writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, buffer->handle,
+ /*acquireFence*/ -1);
+ writer.setLayerLuts(display.getDisplayId(), layer, luts);
+ writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
+ execute();
+ const auto errors = mReader.takeErrors();
+ if (errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_UNSUPPORTED) {
+ GTEST_SUCCEED() << "setLayerLuts is not supported";
+ return;
+ }
+ // change to client composition
+ ASSERT_FALSE(mReader.takeChangedCompositionTypes(display.getDisplayId()).empty());
}
- // change to client composition
- ASSERT_FALSE(mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty());
}
}