Evolution-x/hardware_interfaces
1
0
Fork 0
mirror of https://github.com/Evolution-X/hardware_interfaces synced 2026-02-01 05:49:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge "composer: vts: add support for batched create/destroy layers" into main

Browse Source
This commit is contained in:
Manali Bhutiyani
2024-01-01 19:37:25 +00:00
committed by Android (Google) Code Review
parent 2b4c06b10e a00d246f27
commit 01a1cb884f
6 changed files with 253 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
graphics/composer/aidl/vts/ReadbackVts.cpp
View File

@@ -293,8 +293,8 @@ LayerSettings TestColorLayer::toRenderEngineLayerSettings() {
TestBufferLayer::TestBufferLayer(const std::shared_ptr<VtsComposerClient>& client,
TestRenderEngine& renderEngine, int64_t display, uint32_t width,
uint32_t height, common::PixelFormat format,
Composition composition)
: TestLayer{client, display}, mRenderEngine(renderEngine) {
ComposerClientWriter& writer, Composition composition)
: TestLayer{client, display, writer}, mRenderEngine(renderEngine) {
mComposition = composition;
mWidth = width;
mHeight = height;

12
graphics/composer/aidl/vts/ReadbackVts.h
View File

@@ -50,9 +50,10 @@ class TestRenderEngine;
class TestLayer {
public:
TestLayer(const std::shared_ptr<VtsComposerClient>& client, int64_t display)
TestLayer(const std::shared_ptr<VtsComposerClient>& client, int64_t display,
ComposerClientWriter& writer)
: mDisplay(display) {
const auto& [status, layer] = client->createLayer(display, kBufferSlotCount);
const auto& [status, layer] = client->createLayer(display, kBufferSlotCount, &writer);
EXPECT_TRUE(status.isOk());
mLayer = layer;
}
@@ -108,8 +109,9 @@ class TestLayer {
class TestColorLayer : public TestLayer {
public:
TestColorLayer(const std::shared_ptr<VtsComposerClient>& client, int64_t display)
: TestLayer{client, display} {}
TestColorLayer(const std::shared_ptr<VtsComposerClient>& client, int64_t display,
ComposerClientWriter& writer)
: TestLayer{client, display, writer} {}
void write(ComposerClientWriter& writer) override;
@@ -125,7 +127,7 @@ class TestBufferLayer : public TestLayer {
public:
TestBufferLayer(const std::shared_ptr<VtsComposerClient>& client,
TestRenderEngine& renderEngine, int64_t display, uint32_t width,
uint32_t height, common::PixelFormat format,
uint32_t height, common::PixelFormat format, ComposerClientWriter& writer,
Composition composition = Composition::DEVICE);
void write(ComposerClientWriter& writer) override;

45
graphics/composer/aidl/vts/VtsComposerClient.cpp
View File

@@ -33,6 +33,14 @@ VtsComposerClient::VtsComposerClient(const std::string& name) {
mComposer = IComposer::fromBinder(binder);
ALOGE_IF(mComposer == nullptr, "Failed to acquire the composer from the binder");
}
const auto& [status, capabilities] = getCapabilities();
EXPECT_TRUE(status.isOk());
if (std::any_of(capabilities.begin(), capabilities.end(), [&](const Capability& cap) {
return cap == Capability::LAYER_LIFECYCLE_BATCH_COMMAND;
})) {
mSupportsBatchedCreateLayer = true;
}
}
ScopedAStatus VtsComposerClient::createClient() {
@@ -54,8 +62,8 @@ ScopedAStatus VtsComposerClient::createClient() {
return mComposerClient->registerCallback(mComposerCallback);
}
bool VtsComposerClient::tearDown() {
return verifyComposerCallbackParams() && destroyAllLayers();
bool VtsComposerClient::tearDown(ComposerClientWriter* writer) {
return verifyComposerCallbackParams() && destroyAllLayers(writer);
}
std::pair<ScopedAStatus, int32_t> VtsComposerClient::getInterfaceVersion() const {
@@ -86,7 +94,16 @@ ScopedAStatus VtsComposerClient::destroyVirtualDisplay(int64_t display) {
}
std::pair<ScopedAStatus, int64_t> VtsComposerClient::createLayer(int64_t display,
int32_t bufferSlotCount) {
int32_t bufferSlotCount,
ComposerClientWriter* writer) {
if (mSupportsBatchedCreateLayer) {
int64_t layer = mNextLayerHandle++;
writer->setLayerLifecycleBatchCommandType(display, layer,
LayerLifecycleBatchCommandType::CREATE);
writer->setNewBufferSlotCount(display, layer, bufferSlotCount);
return {addLayerToDisplayResources(display, layer), layer};
}
int64_t outLayer;
auto status = mComposerClient->createLayer(display, bufferSlotCount, &outLayer);
@@ -96,14 +113,20 @@ std::pair<ScopedAStatus, int64_t> VtsComposerClient::createLayer(int64_t display
return {addLayerToDisplayResources(display, outLayer), outLayer};
}
ScopedAStatus VtsComposerClient::destroyLayer(int64_t display, int64_t layer) {
auto status = mComposerClient->destroyLayer(display, layer);
if (!status.isOk()) {
return status;
ScopedAStatus VtsComposerClient::destroyLayer(int64_t display, int64_t layer,
ComposerClientWriter* writer) {
if (mSupportsBatchedCreateLayer) {
writer->setLayerLifecycleBatchCommandType(display, layer,
LayerLifecycleBatchCommandType::DESTROY);
} else {
auto status = mComposerClient->destroyLayer(display, layer);
if (!status.isOk()) {
return status;
}
}
removeLayerFromDisplayResources(display, layer);
return status;
return ScopedAStatus::ok();
}
std::pair<ScopedAStatus, int32_t> VtsComposerClient::getActiveConfig(int64_t display) {
@@ -632,7 +655,7 @@ bool VtsComposerClient::getDisplayConfigurationSupported() const {
return interfaceVersion >= 3;
}
bool VtsComposerClient::destroyAllLayers() {
bool VtsComposerClient::destroyAllLayers(ComposerClientWriter* writer) {
std::unordered_map<int64_t, DisplayResource> physicalDisplays;
while (!mDisplayResources.empty()) {
const auto& it = mDisplayResources.begin();
@@ -640,7 +663,7 @@ bool VtsComposerClient::destroyAllLayers() {
while (!resource.layers.empty()) {
auto layer = *resource.layers.begin();
const auto status = destroyLayer(display, layer);
const auto status = destroyLayer(display, layer, writer);
if (!status.isOk()) {
ALOGE("Unable to destroy all the layers, failed at layer %" PRId64 " with error %s",
layer, status.getDescription().c_str());

12
graphics/composer/aidl/vts/VtsComposerClient.h
View File

@@ -25,6 +25,7 @@
#include <android/binder_manager.h>
#include <android/binder_process.h>
#include <android/hardware/graphics/composer3/ComposerClientReader.h>
#include <android/hardware/graphics/composer3/ComposerClientWriter.h>
#include <binder/ProcessState.h>
#include <gtest/gtest.h>
#include <ui/Fence.h>
@@ -59,7 +60,7 @@ class VtsComposerClient {
ScopedAStatus createClient();
bool tearDown();
bool tearDown(ComposerClientWriter*);
std::pair<ScopedAStatus, int32_t> getInterfaceVersion() const;
@@ -69,9 +70,10 @@ class VtsComposerClient {
ScopedAStatus destroyVirtualDisplay(int64_t display);
std::pair<ScopedAStatus, int64_t> createLayer(int64_t display, int32_t bufferSlotCount);
std::pair<ScopedAStatus, int64_t> createLayer(int64_t display, int32_t bufferSlotCount,
ComposerClientWriter*);
ScopedAStatus destroyLayer(int64_t display, int64_t layer);
ScopedAStatus destroyLayer(int64_t display, int64_t layer, ComposerClientWriter*);
std::pair<ScopedAStatus, int32_t> getActiveConfig(int64_t display);
@@ -211,7 +213,7 @@ class VtsComposerClient {
void removeLayerFromDisplayResources(int64_t display, int64_t layer);
bool destroyAllLayers();
bool destroyAllLayers(ComposerClientWriter*);
bool verifyComposerCallbackParams();
@@ -229,6 +231,8 @@ class VtsComposerClient {
std::shared_ptr<IComposerClient> mComposerClient;
std::shared_ptr<GraphicsComposerCallback> mComposerCallback;
std::unordered_map<int64_t, DisplayResource> mDisplayResources;
bool mSupportsBatchedCreateLayer = false;
std::atomic<int64_t> mNextLayerHandle = 1;
};
class VtsDisplay {

59
graphics/composer/aidl/vts/VtsHalGraphicsComposer3_ReadbackTest.cpp
View File

@@ -86,7 +86,7 @@ class GraphicsCompositionTestBase : public ::testing::Test {
void TearDown() override {
ASSERT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
ASSERT_TRUE(mComposerClient->tearDown());
ASSERT_TRUE(mComposerClient->tearDown(mWriter.get()));
mComposerClient.reset();
const auto errors = mReader.takeErrors();
ASSERT_TRUE(mReader.takeErrors().empty());
@@ -201,7 +201,8 @@ TEST_P(GraphicsCompositionTest, SingleSolidColorLayer) {
return;
}
auto layer = std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId());
auto layer =
std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId(), *mWriter);
common::Rect coloredSquare({0, 0, getDisplayWidth(), getDisplayHeight()});
layer->setColor(BLUE);
layer->setDisplayFrame(coloredSquare);
@@ -270,7 +271,7 @@ TEST_P(GraphicsCompositionTest, SetLayerBuffer) {
auto layer = std::make_shared<TestBufferLayer>(
mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), getDisplayWidth(),
getDisplayHeight(), common::PixelFormat::RGBA_8888);
getDisplayHeight(), common::PixelFormat::RGBA_8888, *mWriter);
layer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
layer->setZOrder(10);
layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode));
@@ -315,7 +316,8 @@ TEST_P(GraphicsCompositionTest, SetLayerBufferNoEffect) {
return;
}
auto layer = std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId());
auto layer =
std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId(), *mWriter);
common::Rect coloredSquare({0, 0, getDisplayWidth(), getDisplayHeight()});
layer->setColor(BLUE);
layer->setDisplayFrame(coloredSquare);
@@ -454,9 +456,9 @@ TEST_P(GraphicsCompositionTest, ClientComposition) {
expectedColors, getDisplayWidth(),
{0, getDisplayHeight() / 2, getDisplayWidth(), getDisplayHeight()}, BLUE);
auto layer = std::make_shared<TestBufferLayer>(mComposerClient, *mTestRenderEngine,
getPrimaryDisplayId(), getDisplayWidth(),
getDisplayHeight(), PixelFormat::RGBA_FP16);
auto layer = std::make_shared<TestBufferLayer>(
mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), getDisplayWidth(),
getDisplayHeight(), PixelFormat::RGBA_FP16, *mWriter);
layer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
layer->setZOrder(10);
layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode));
@@ -550,7 +552,7 @@ TEST_P(GraphicsCompositionTest, DeviceAndClientComposition) {
auto deviceLayer = std::make_shared<TestBufferLayer>(
mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), getDisplayWidth(),
getDisplayHeight() / 2, PixelFormat::RGBA_8888);
getDisplayHeight() / 2, PixelFormat::RGBA_8888, *mWriter);
std::vector<Color> deviceColors(deviceLayer->getWidth() * deviceLayer->getHeight());
ReadbackHelper::fillColorsArea(deviceColors, static_cast<int32_t>(deviceLayer->getWidth()),
{0, 0, static_cast<int32_t>(deviceLayer->getWidth()),
@@ -574,7 +576,7 @@ TEST_P(GraphicsCompositionTest, DeviceAndClientComposition) {
auto clientLayer = std::make_shared<TestBufferLayer>(
mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), clientWidth,
clientHeight, PixelFormat::RGBA_FP16, Composition::DEVICE);
clientHeight, PixelFormat::RGBA_FP16, *mWriter, Composition::DEVICE);
common::Rect clientFrame = {0, getDisplayHeight() / 2, getDisplayWidth(),
getDisplayHeight()};
clientLayer->setDisplayFrame(clientFrame);
@@ -643,9 +645,9 @@ TEST_P(GraphicsCompositionTest, SetLayerDamage) {
static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), redRect, RED);
auto layer = std::make_shared<TestBufferLayer>(mComposerClient, *mTestRenderEngine,
getPrimaryDisplayId(), getDisplayWidth(),
getDisplayHeight(), PixelFormat::RGBA_8888);
auto layer = std::make_shared<TestBufferLayer>(
mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), getDisplayWidth(),
getDisplayHeight(), PixelFormat::RGBA_8888, *mWriter);
layer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
layer->setZOrder(10);
layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode));
@@ -714,7 +716,8 @@ TEST_P(GraphicsCompositionTest, SetLayerPlaneAlpha) {
return;
}
auto layer = std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId());
auto layer =
std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId(), *mWriter);
layer->setColor(RED);
layer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
layer->setZOrder(10);
@@ -774,9 +777,9 @@ TEST_P(GraphicsCompositionTest, SetLayerSourceCrop) {
expectedColors, getDisplayWidth(),
{0, getDisplayHeight() / 2, getDisplayWidth(), getDisplayHeight()}, BLUE);
auto layer = std::make_shared<TestBufferLayer>(mComposerClient, *mTestRenderEngine,
getPrimaryDisplayId(), getDisplayWidth(),
getDisplayHeight(), PixelFormat::RGBA_8888);
auto layer = std::make_shared<TestBufferLayer>(
mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), getDisplayWidth(),
getDisplayHeight(), PixelFormat::RGBA_8888, *mWriter);
layer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
layer->setZOrder(10);
layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode));
@@ -828,11 +831,13 @@ TEST_P(GraphicsCompositionTest, SetLayerZOrder) {
common::Rect redRect = {0, 0, getDisplayWidth(), getDisplayHeight() / 2};
common::Rect blueRect = {0, getDisplayHeight() / 4, getDisplayWidth(), getDisplayHeight()};
auto redLayer = std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId());
auto redLayer =
std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId(), *mWriter);
redLayer->setColor(RED);
redLayer->setDisplayFrame(redRect);
auto blueLayer = std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId());
auto blueLayer =
std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId(), *mWriter);
blueLayer->setColor(BLUE);
blueLayer->setDisplayFrame(blueRect);
blueLayer->setZOrder(5);
@@ -914,14 +919,14 @@ TEST_P(GraphicsCompositionTest, SetLayerBrightnessDims) {
static constexpr float kMaxBrightnessNits = 300.f;
const auto redLayer =
std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId());
std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId(), *mWriter);
redLayer->setColor(RED);
redLayer->setDisplayFrame(redRect);
redLayer->setWhitePointNits(kMaxBrightnessNits);
redLayer->setBrightness(1.f);
const auto dimmerRedLayer =
std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId());
std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId(), *mWriter);
dimmerRedLayer->setColor(RED);
dimmerRedLayer->setDisplayFrame(dimmerRedRect);
// Intentionally use a small dimming ratio as some implementations may be more likely to
@@ -992,14 +997,14 @@ class GraphicsBlendModeCompositionTest
mTopLayerColor);
auto backgroundLayer =
std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId());
std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId(), *mWriter);
backgroundLayer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
backgroundLayer->setZOrder(0);
backgroundLayer->setColor(mBackgroundColor);
auto layer = std::make_shared<TestBufferLayer>(mComposerClient, *mTestRenderEngine,
getPrimaryDisplayId(), getDisplayWidth(),
getDisplayHeight(), PixelFormat::RGBA_8888);
auto layer = std::make_shared<TestBufferLayer>(
mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), getDisplayWidth(),
getDisplayHeight(), PixelFormat::RGBA_8888, *mWriter);
layer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
layer->setZOrder(10);
layer->setDataspace(Dataspace::UNKNOWN);
@@ -1190,7 +1195,7 @@ class GraphicsTransformCompositionTest : public GraphicsCompositionTest {
GraphicsCompositionTest::SetUp();
auto backgroundLayer =
std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId());
std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId(), *mWriter);
backgroundLayer->setColor({0.0f, 0.0f, 0.0f, 0.0f});
backgroundLayer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
backgroundLayer->setZOrder(0);
@@ -1202,7 +1207,7 @@ class GraphicsTransformCompositionTest : public GraphicsCompositionTest {
mLayer = std::make_shared<TestBufferLayer>(mComposerClient, *mTestRenderEngine,
getPrimaryDisplayId(), mSideLength, mSideLength,
PixelFormat::RGBA_8888);
PixelFormat::RGBA_8888, *mWriter);
mLayer->setDisplayFrame({0, 0, mSideLength, mSideLength});
mLayer->setZOrder(10);
@@ -1388,7 +1393,7 @@ class GraphicsColorManagementCompositionTest
void makeLayer() {
mLayer = std::make_shared<TestBufferLayer>(
mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), getDisplayWidth(),
getDisplayHeight(), common::PixelFormat::RGBA_8888);
getDisplayHeight(), common::PixelFormat::RGBA_8888, *mWriter);
mLayer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
mLayer->setZOrder(10);
mLayer->setAlpha(1.f);

251
graphics/composer/aidl/vts/VtsHalGraphicsComposer3_TargetTest.cpp
View File

@@ -70,7 +70,7 @@ class GraphicsComposerAidlTest : public ::testing::TestWithParam<std::string> {
}
void TearDown() override {
ASSERT_TRUE(mComposerClient->tearDown());
ASSERT_TRUE(mComposerClient->tearDown(nullptr));
mComposerClient.reset();
}
@@ -832,36 +832,58 @@ TEST_P(GraphicsComposerAidlTest, DestroyVirtualDisplay_BadDisplay) {
}
TEST_P(GraphicsComposerAidlTest, CreateLayer) {
if (hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
GTEST_SKIP() << "Create layer will be tested in GraphicsComposerAidlBatchedCommandTest";
return;
}
const auto& [status, layer] =
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, nullptr);
EXPECT_TRUE(status.isOk());
EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer, nullptr).isOk());
}
TEST_P(GraphicsComposerAidlTest, CreateLayer_BadDisplay) {
const auto& [status, _] = mComposerClient->createLayer(getInvalidDisplayId(), kBufferSlotCount);
if (hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
GTEST_SKIP() << "Create layer will be tested in GraphicsComposerAidlBatchedCommandTest";
return;
}
const auto& [status, _] =
mComposerClient->createLayer(getInvalidDisplayId(), kBufferSlotCount, nullptr);
EXPECT_FALSE(status.isOk());
EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
}
TEST_P(GraphicsComposerAidlTest, DestroyLayer_BadDisplay) {
if (hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
GTEST_SKIP() << "Destroy layer will be tested in GraphicsComposerAidlBatchedCommandTest";
return;
}
const auto& [status, layer] =
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, nullptr);
EXPECT_TRUE(status.isOk());
const auto& destroyStatus = mComposerClient->destroyLayer(getInvalidDisplayId(), layer);
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).isOk());
ASSERT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer, nullptr).isOk());
}
TEST_P(GraphicsComposerAidlTest, DestroyLayer_BadLayerError) {
if (hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
GTEST_SKIP() << "Destroy layer will be tested in GraphicsComposerAidlBatchedCommandTest";
return;
}
// We haven't created any layers yet, so any id should be invalid
const auto& status = mComposerClient->destroyLayer(getPrimaryDisplayId(), /*layer*/ 1);
const auto& status = mComposerClient->destroyLayer(getPrimaryDisplayId(), /*layer*/ 1, nullptr);
EXPECT_FALSE(status.isOk());
EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_LAYER));
@@ -1171,6 +1193,12 @@ TEST_P(GraphicsComposerAidlTest, GetDisplayConfigNoRepetitions) {
}
}
TEST_P(GraphicsComposerAidlTest, LayerLifecycleCapabilityNotSupportedOnOldVersions) {
if (hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
EXPECT_GE(getInterfaceVersion(), 3);
}
}
class GraphicsComposerAidlV2Test : public GraphicsComposerAidlTest {
protected:
void SetUp() override {
@@ -1376,6 +1404,7 @@ class GraphicsComposerAidlCommandTest : public GraphicsComposerAidlTest {
ASSERT_TRUE(mReader.takeErrors().empty());
ASSERT_TRUE(mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty());
ASSERT_TRUE(mComposerClient->tearDown(&getWriter(getPrimaryDisplayId())));
ASSERT_NO_FATAL_FAILURE(GraphicsComposerAidlTest::TearDown());
}
@@ -1463,10 +1492,10 @@ class GraphicsComposerAidlCommandTest : public GraphicsComposerAidlTest {
RenderIntent::COLORIMETRIC)
.isOk());
const auto& [status, layer] =
mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount);
EXPECT_TRUE(status.isOk());
auto& writer = getWriter(display.getDisplayId());
const auto& [status, layer] =
mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
EXPECT_TRUE(status.isOk());
{
const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ASSERT_NE(nullptr, buffer);
@@ -1506,7 +1535,7 @@ class GraphicsComposerAidlCommandTest : public GraphicsComposerAidlTest {
execute();
}
EXPECT_TRUE(mComposerClient->destroyLayer(display.getDisplayId(), layer).isOk());
EXPECT_TRUE(mComposerClient->destroyLayer(display.getDisplayId(), layer, &writer).isOk());
}
sp<::android::Fence> presentAndGetFence(
@@ -1541,15 +1570,16 @@ class GraphicsComposerAidlCommandTest : public GraphicsComposerAidlTest {
}
int64_t createOnScreenLayer(Composition composition = Composition::DEVICE) {
auto& writer = getWriter(getPrimaryDisplayId());
const auto& [status, layer] =
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
EXPECT_TRUE(status.isOk());
Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
getPrimaryDisplay().getDisplayHeight()};
FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
(float)getPrimaryDisplay().getDisplayHeight()};
configureLayer(getPrimaryDisplay(), layer, composition, displayFrame, cropRect);
auto& writer = getWriter(getPrimaryDisplayId());
writer.setLayerDataspace(getPrimaryDisplayId(), layer, common::Dataspace::UNKNOWN);
return layer;
}
@@ -1758,10 +1788,10 @@ TEST_P(GraphicsComposerAidlCommandTest, SetColorTransform) {
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerColorTransform) {
const auto& [status, layer] =
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
EXPECT_TRUE(status.isOk());
auto& writer = getWriter(getPrimaryDisplayId());
const auto& [status, layer] =
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
EXPECT_TRUE(status.isOk());
writer.setLayerColorTransform(getPrimaryDisplayId(), layer, kIdentity.data());
execute();
@@ -1900,7 +1930,7 @@ TEST_P(GraphicsComposerAidlCommandTest, PresentDisplayNoLayerStateChanges) {
ASSERT_NE(nullptr, handle);
const auto& [layerStatus, layer] =
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
EXPECT_TRUE(layerStatus.isOk());
Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
@@ -1937,15 +1967,15 @@ TEST_P(GraphicsComposerAidlCommandTest, PresentDisplayNoLayerStateChanges) {
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerCursorPosition) {
auto& writer = getWriter(getPrimaryDisplayId());
const auto& [layerStatus, layer] =
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
EXPECT_TRUE(layerStatus.isOk());
const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
const auto handle = buffer->handle;
ASSERT_NE(nullptr, handle);
auto& writer = getWriter(getPrimaryDisplayId());
writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle, /*acquireFence*/ -1);
Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
@@ -1981,19 +2011,19 @@ TEST_P(GraphicsComposerAidlCommandTest, SetLayerBuffer) {
const auto handle = buffer->handle;
ASSERT_NE(nullptr, handle);
const auto& [layerStatus, layer] =
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
EXPECT_TRUE(layerStatus.isOk());
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();
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerBufferMultipleTimes) {
const auto& [layerStatus, layer] =
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
EXPECT_TRUE(layerStatus.isOk());
auto& writer = getWriter(getPrimaryDisplayId());
const auto& [layerStatus, layer] =
mComposerClient->createLayer(getPrimaryDisplayId(), 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
@@ -2041,14 +2071,14 @@ TEST_P(GraphicsComposerAidlCommandTest, SetLayerBufferMultipleTimes) {
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerSurfaceDamage) {
auto& writer = getWriter(getPrimaryDisplayId());
const auto& [layerStatus, layer] =
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
EXPECT_TRUE(layerStatus.isOk());
Rect empty{0, 0, 0, 0};
Rect unit{0, 0, 1, 1};
auto& writer = getWriter(getPrimaryDisplayId());
writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
@@ -2063,14 +2093,14 @@ TEST_P(GraphicsComposerAidlCommandTest, SetLayerSurfaceDamage) {
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerBlockingRegion) {
auto& writer = getWriter(getPrimaryDisplayId());
const auto& [layerStatus, layer] =
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
EXPECT_TRUE(layerStatus.isOk());
Rect empty{0, 0, 0, 0};
Rect unit{0, 0, 1, 1};
auto& writer = getWriter(getPrimaryDisplayId());
writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
@@ -2085,11 +2115,11 @@ TEST_P(GraphicsComposerAidlCommandTest, SetLayerBlockingRegion) {
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerBlendMode) {
auto& writer = getWriter(getPrimaryDisplayId());
const auto& [layerStatus, layer] =
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
EXPECT_TRUE(layerStatus.isOk());
auto& writer = getWriter(getPrimaryDisplayId());
writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::NONE);
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
@@ -2104,11 +2134,11 @@ TEST_P(GraphicsComposerAidlCommandTest, SetLayerBlendMode) {
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerColor) {
auto& writer = getWriter(getPrimaryDisplayId());
const auto& [layerStatus, layer] =
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
EXPECT_TRUE(layerStatus.isOk());
auto& writer = getWriter(getPrimaryDisplayId());
writer.setLayerColor(getPrimaryDisplayId(), layer, Color{1.0f, 1.0f, 1.0f, 1.0f});
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
@@ -2119,11 +2149,11 @@ TEST_P(GraphicsComposerAidlCommandTest, SetLayerColor) {
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerCompositionType) {
auto& writer = getWriter(getPrimaryDisplayId());
const auto& [layerStatus, layer] =
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
EXPECT_TRUE(layerStatus.isOk());
auto& writer = getWriter(getPrimaryDisplayId());
writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::CLIENT);
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
@@ -2142,8 +2172,9 @@ TEST_P(GraphicsComposerAidlCommandTest, SetLayerCompositionType) {
TEST_P(GraphicsComposerAidlCommandTest, DisplayDecoration) {
for (VtsDisplay& display : mDisplays) {
auto& writer = getWriter(display.getDisplayId());
const auto [layerStatus, layer] =
mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount);
mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
EXPECT_TRUE(layerStatus.isOk());
const auto [error, support] =
@@ -2166,8 +2197,7 @@ TEST_P(GraphicsComposerAidlCommandTest, DisplayDecoration) {
}
configureLayer(display, layer, Composition::DISPLAY_DECORATION, display.getFrameRect(),
display.getCrop());
auto& writer = getWriter(display.getDisplayId());
display.getCrop());
writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, decorBuffer->handle,
/*acquireFence*/ -1);
writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp,
@@ -2184,31 +2214,31 @@ TEST_P(GraphicsComposerAidlCommandTest, DisplayDecoration) {
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerDataspace) {
auto& writer = getWriter(getPrimaryDisplayId());
const auto& [layerStatus, layer] =
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
EXPECT_TRUE(layerStatus.isOk());
auto& writer = getWriter(getPrimaryDisplayId());
writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
execute();
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerDisplayFrame) {
auto& writer = getWriter(getPrimaryDisplayId());
const auto& [layerStatus, layer] =
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
EXPECT_TRUE(layerStatus.isOk());
auto& writer = getWriter(getPrimaryDisplayId());
writer.setLayerDisplayFrame(getPrimaryDisplayId(), layer, Rect{0, 0, 1, 1});
execute();
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerPlaneAlpha) {
auto& writer = getWriter(getPrimaryDisplayId());
const auto& [layerStatus, layer] =
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
EXPECT_TRUE(layerStatus.isOk());
auto& writer = getWriter(getPrimaryDisplayId());
writer.setLayerPlaneAlpha(getPrimaryDisplayId(), layer, /*alpha*/ 0.0f);
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
@@ -2228,31 +2258,31 @@ TEST_P(GraphicsComposerAidlCommandTest, SetLayerSidebandStream) {
const auto handle = buffer->handle;
ASSERT_NE(nullptr, handle);
auto& writer = getWriter(getPrimaryDisplayId());
const auto& [layerStatus, layer] =
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
EXPECT_TRUE(layerStatus.isOk());
auto& writer = getWriter(getPrimaryDisplayId());
writer.setLayerSidebandStream(getPrimaryDisplayId(), layer, handle);
execute();
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerSourceCrop) {
auto& writer = getWriter(getPrimaryDisplayId());
const auto& [layerStatus, layer] =
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
EXPECT_TRUE(layerStatus.isOk());
auto& writer = getWriter(getPrimaryDisplayId());
writer.setLayerSourceCrop(getPrimaryDisplayId(), 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);
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
EXPECT_TRUE(layerStatus.isOk());
auto& writer = getWriter(getPrimaryDisplayId());
writer.setLayerTransform(getPrimaryDisplayId(), layer, static_cast<Transform>(0));
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
@@ -2291,14 +2321,14 @@ TEST_P(GraphicsComposerAidlCommandTest, SetLayerTransform) {
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerVisibleRegion) {
auto& writer = getWriter(getPrimaryDisplayId());
const auto& [layerStatus, layer] =
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
EXPECT_TRUE(layerStatus.isOk());
Rect empty{0, 0, 0, 0};
Rect unit{0, 0, 1, 1};
auto& writer = getWriter(getPrimaryDisplayId());
writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
@@ -2313,11 +2343,12 @@ TEST_P(GraphicsComposerAidlCommandTest, SetLayerVisibleRegion) {
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerZOrder) {
auto& writer = getWriter(getPrimaryDisplayId());
const auto& [layerStatus, layer] =
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
EXPECT_TRUE(layerStatus.isOk());
auto& writer = getWriter(getPrimaryDisplayId());
writer.setLayerZOrder(getPrimaryDisplayId(), layer, /*z*/ 10);
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
@@ -2328,8 +2359,9 @@ TEST_P(GraphicsComposerAidlCommandTest, SetLayerZOrder) {
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerPerFrameMetadata) {
auto& writer = getWriter(getPrimaryDisplayId());
const auto& [layerStatus, layer] =
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
EXPECT_TRUE(layerStatus.isOk());
/**
@@ -2344,7 +2376,6 @@ TEST_P(GraphicsComposerAidlCommandTest, SetLayerPerFrameMetadata) {
* white (D65) 0.3127 0.3290
*/
auto& writer = getWriter(getPrimaryDisplayId());
std::vector<PerFrameMetadata> aidlMetadata;
aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X, 0.680f});
aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y, 0.320f});
@@ -2364,18 +2395,19 @@ TEST_P(GraphicsComposerAidlCommandTest, SetLayerPerFrameMetadata) {
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).isOk());
EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer, &writer).isOk());
return;
}
EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer, &writer).isOk());
}
TEST_P(GraphicsComposerAidlCommandTest, setLayerBrightness) {
const auto& [layerStatus, layer] =
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
auto& writer = getWriter(getPrimaryDisplayId());
const auto& [layerStatus, layer] =
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
writer.setLayerBrightness(getPrimaryDisplayId(), layer, 0.2f);
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
@@ -2604,12 +2636,12 @@ TEST_P(GraphicsComposerAidlCommandV2Test, SkipValidateDeprecatedTest) {
}
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);
mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
EXPECT_TRUE(layerStatus.isOk());
auto& writer = getWriter(getPrimaryDisplayId());
// 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
@@ -2868,7 +2900,8 @@ TEST_P(GraphicsComposerAidlCommandTest, MultiThreadedPresent) {
EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
const auto& [status, layer] = mComposerClient->createLayer(displayId, kBufferSlotCount);
const auto& [status, layer] =
mComposerClient->createLayer(displayId, kBufferSlotCount, &writer);
const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ASSERT_NE(nullptr, buffer);
ASSERT_EQ(::android::OK, buffer->initCheck());
@@ -2918,7 +2951,8 @@ TEST_P(GraphicsComposerAidlCommandTest, MultiThreadedPresent) {
}
for (auto& [displayId, layer] : layers) {
EXPECT_TRUE(mComposerClient->destroyLayer(displayId, layer).isOk());
auto& writer = getWriter(displayId);
EXPECT_TRUE(mComposerClient->destroyLayer(displayId, layer, &writer).isOk());
}
std::lock_guard guard{readersMutex};
@@ -2928,22 +2962,22 @@ TEST_P(GraphicsComposerAidlCommandTest, MultiThreadedPresent) {
}
}
class GraphicsComposerAidlBatchedCommandTest : public GraphicsComposerAidlCommandTest {
class GraphicsComposerAidlCommandV3Test : public GraphicsComposerAidlCommandTest {
protected:
void SetUp() override {
GraphicsComposerAidlCommandTest::SetUp();
GraphicsComposerAidlTest::SetUp();
if (getInterfaceVersion() <= 2) {
GTEST_SKIP() << "Device interface version is expected to be >= 3";
}
}
void TearDown() override {
const auto errors = mReader.takeErrors();
ASSERT_TRUE(mReader.takeErrors().empty());
ASSERT_NO_FATAL_FAILURE(GraphicsComposerAidlTest::TearDown());
}
};
TEST_P(GraphicsComposerAidlBatchedCommandTest, CreateBatchedCommand) {
TEST_P(GraphicsComposerAidlCommandV3Test, CreateBatchedCommand) {
if (!hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
GTEST_SKIP() << "LAYER_LIFECYCLE_BATCH_COMMAND not supported by the implementation";
return;
}
auto& writer = getWriter(getPrimaryDisplayId());
int64_t layer = 5;
writer.setLayerLifecycleBatchCommandType(getPrimaryDisplayId(), layer,
@@ -2955,7 +2989,30 @@ TEST_P(GraphicsComposerAidlBatchedCommandTest, CreateBatchedCommand) {
ASSERT_TRUE(mReader.takeErrors().empty());
}
TEST_P(GraphicsComposerAidlBatchedCommandTest, DestroyBatchedCommand) {
TEST_P(GraphicsComposerAidlCommandV3Test, CreateBatchedCommand_BadDisplay) {
if (!hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
GTEST_SKIP() << "LAYER_LIFECYCLE_BATCH_COMMAND not supported by the implementation";
return;
}
auto& writer = getWriter(getPrimaryDisplayId());
int64_t layer = 5;
writer.setLayerLifecycleBatchCommandType(getInvalidDisplayId(), layer,
LayerLifecycleBatchCommandType::CREATE);
writer.setNewBufferSlotCount(getPrimaryDisplayId(), layer, 1);
writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
VtsComposerClient::kNoFrameIntervalNs);
execute();
const auto errors = mReader.takeErrors();
ASSERT_TRUE(errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_BAD_DISPLAY);
}
TEST_P(GraphicsComposerAidlCommandV3Test, DestroyBatchedCommand) {
if (!hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
GTEST_SKIP() << "LAYER_LIFECYCLE_BATCH_COMMAND not supported by the implementation";
return;
}
auto& writer = getWriter(getPrimaryDisplayId());
int64_t layer = 5;
writer.setLayerLifecycleBatchCommandType(getPrimaryDisplayId(), layer,
@@ -2972,11 +3029,43 @@ TEST_P(GraphicsComposerAidlBatchedCommandTest, DestroyBatchedCommand) {
LayerLifecycleBatchCommandType::CREATE);
writer.setNewBufferSlotCount(getPrimaryDisplayId(), layer, 1);
execute();
const auto errors = mReader.takeErrors();
ASSERT_TRUE(errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_BAD_DISPLAY);
}
TEST_P(GraphicsComposerAidlCommandV3Test, DestroyBatchedCommand_BadDisplay) {
if (!hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
GTEST_SKIP() << "LAYER_LIFECYCLE_BATCH_COMMAND not supported by the implementation";
return;
}
auto& writer = getWriter(getPrimaryDisplayId());
int64_t layer = 5;
writer.setLayerLifecycleBatchCommandType(getPrimaryDisplayId(), layer,
LayerLifecycleBatchCommandType::CREATE);
writer.setNewBufferSlotCount(getPrimaryDisplayId(), layer, 1);
writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
VtsComposerClient::kNoFrameIntervalNs);
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
writer.setLayerLifecycleBatchCommandType(getInvalidDisplayId(), layer,
LayerLifecycleBatchCommandType::DESTROY);
layer++;
writer.setLayerLifecycleBatchCommandType(getInvalidDisplayId(), layer,
LayerLifecycleBatchCommandType::CREATE);
writer.setNewBufferSlotCount(getPrimaryDisplayId(), layer, 1);
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
}
TEST_P(GraphicsComposerAidlBatchedCommandTest, NoCreateDestroyBatchedCommandIncorrectLayer) {
TEST_P(GraphicsComposerAidlCommandV3Test, NoCreateDestroyBatchedCommandIncorrectLayer) {
if (!hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
GTEST_SKIP() << "LAYER_LIFECYCLE_BATCH_COMMAND not supported by the implementation";
return;
}
auto& writer = getWriter(getPrimaryDisplayId());
int64_t layer = 5;
writer.setLayerLifecycleBatchCommandType(getPrimaryDisplayId(), layer,
@@ -2986,11 +3075,6 @@ TEST_P(GraphicsComposerAidlBatchedCommandTest, NoCreateDestroyBatchedCommandInco
ASSERT_TRUE(errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_BAD_LAYER);
}
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlBatchedCommandTest);
INSTANTIATE_TEST_SUITE_P(
PerInstance, GraphicsComposerAidlBatchedCommandTest,
testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
::android::PrintInstanceNameToString);
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlCommandTest);
INSTANTIATE_TEST_SUITE_P(
PerInstance, GraphicsComposerAidlCommandTest,
@@ -3016,6 +3100,11 @@ INSTANTIATE_TEST_SUITE_P(
PerInstance, GraphicsComposerAidlCommandV2Test,
testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
::android::PrintInstanceNameToString);
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlCommandV3Test);
INSTANTIATE_TEST_SUITE_P(
PerInstance, GraphicsComposerAidlCommandV3Test,
testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
::android::PrintInstanceNameToString);
} // namespace aidl::android::hardware::graphics::composer3::vts
int main(int argc, char** argv) {