Extend VTS to support multiple display if available.
[Why]
In efforts to extend support for connected displays (or even devices
with multiple displays such as foldable devices), extend the same VTS
tests we have but make them run on all discoverable displays.
[How]
Nothing fancy is going on here. Instead of running the tests on
mDisplay[0] and use the primary display ID and dimensions, simply loop
over all available displays and run the tests against each of them
independently of each other.
To make the review easy, only *_TargetTest.cpp is changed.
Bug: b/391347760, b/355482219
Test: atest VtsHalGraphicsComposer3_TargetTest
Flag: TEST_ONLY
Change-Id: I65d7fae47d486121b047a7c888db11c4842b4640
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());
}
}