diff --git a/graphics/composer/aidl/vts/ReadbackVts.cpp b/graphics/composer/aidl/vts/ReadbackVts.cpp index 8605628098..c72ec6974f 100644 --- a/graphics/composer/aidl/vts/ReadbackVts.cpp +++ b/graphics/composer/aidl/vts/ReadbackVts.cpp @@ -293,8 +293,8 @@ LayerSettings TestColorLayer::toRenderEngineLayerSettings() { TestBufferLayer::TestBufferLayer(const std::shared_ptr& 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; diff --git a/graphics/composer/aidl/vts/ReadbackVts.h b/graphics/composer/aidl/vts/ReadbackVts.h index ee205735f1..8ac0f4bb99 100644 --- a/graphics/composer/aidl/vts/ReadbackVts.h +++ b/graphics/composer/aidl/vts/ReadbackVts.h @@ -50,9 +50,10 @@ class TestRenderEngine; class TestLayer { public: - TestLayer(const std::shared_ptr& client, int64_t display) + TestLayer(const std::shared_ptr& 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& client, int64_t display) - : TestLayer{client, display} {} + TestColorLayer(const std::shared_ptr& 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& 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; diff --git a/graphics/composer/aidl/vts/VtsComposerClient.cpp b/graphics/composer/aidl/vts/VtsComposerClient.cpp index ac08cd151f..2c24bfb8f5 100644 --- a/graphics/composer/aidl/vts/VtsComposerClient.cpp +++ b/graphics/composer/aidl/vts/VtsComposerClient.cpp @@ -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 VtsComposerClient::getInterfaceVersion() const { @@ -86,7 +94,16 @@ ScopedAStatus VtsComposerClient::destroyVirtualDisplay(int64_t display) { } std::pair 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 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 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 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()); diff --git a/graphics/composer/aidl/vts/VtsComposerClient.h b/graphics/composer/aidl/vts/VtsComposerClient.h index 292bc407f8..fabc82a7a6 100644 --- a/graphics/composer/aidl/vts/VtsComposerClient.h +++ b/graphics/composer/aidl/vts/VtsComposerClient.h @@ -25,6 +25,7 @@ #include #include #include +#include #include #include #include @@ -59,7 +60,7 @@ class VtsComposerClient { ScopedAStatus createClient(); - bool tearDown(); + bool tearDown(ComposerClientWriter*); std::pair getInterfaceVersion() const; @@ -69,9 +70,10 @@ class VtsComposerClient { ScopedAStatus destroyVirtualDisplay(int64_t display); - std::pair createLayer(int64_t display, int32_t bufferSlotCount); + std::pair 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 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 mComposerClient; std::shared_ptr mComposerCallback; std::unordered_map mDisplayResources; + bool mSupportsBatchedCreateLayer = false; + std::atomic mNextLayerHandle = 1; }; class VtsDisplay { diff --git a/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_ReadbackTest.cpp b/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_ReadbackTest.cpp index 2e3f4df015..164e6d5cab 100644 --- a/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_ReadbackTest.cpp +++ b/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_ReadbackTest.cpp @@ -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(mComposerClient, getPrimaryDisplayId()); + auto layer = + std::make_shared(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( 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(mComposerClient, getPrimaryDisplayId()); + auto layer = + std::make_shared(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(mComposerClient, *mTestRenderEngine, - getPrimaryDisplayId(), getDisplayWidth(), - getDisplayHeight(), PixelFormat::RGBA_FP16); + auto layer = std::make_shared( + 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( mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), getDisplayWidth(), - getDisplayHeight() / 2, PixelFormat::RGBA_8888); + getDisplayHeight() / 2, PixelFormat::RGBA_8888, *mWriter); std::vector deviceColors(deviceLayer->getWidth() * deviceLayer->getHeight()); ReadbackHelper::fillColorsArea(deviceColors, static_cast(deviceLayer->getWidth()), {0, 0, static_cast(deviceLayer->getWidth()), @@ -574,7 +576,7 @@ TEST_P(GraphicsCompositionTest, DeviceAndClientComposition) { auto clientLayer = std::make_shared( 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(getDisplayWidth() * getDisplayHeight())); ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), redRect, RED); - auto layer = std::make_shared(mComposerClient, *mTestRenderEngine, - getPrimaryDisplayId(), getDisplayWidth(), - getDisplayHeight(), PixelFormat::RGBA_8888); + auto layer = std::make_shared( + 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(mComposerClient, getPrimaryDisplayId()); + auto layer = + std::make_shared(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(mComposerClient, *mTestRenderEngine, - getPrimaryDisplayId(), getDisplayWidth(), - getDisplayHeight(), PixelFormat::RGBA_8888); + auto layer = std::make_shared( + 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(mComposerClient, getPrimaryDisplayId()); + auto redLayer = + std::make_shared(mComposerClient, getPrimaryDisplayId(), *mWriter); redLayer->setColor(RED); redLayer->setDisplayFrame(redRect); - auto blueLayer = std::make_shared(mComposerClient, getPrimaryDisplayId()); + auto blueLayer = + std::make_shared(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(mComposerClient, getPrimaryDisplayId()); + std::make_shared(mComposerClient, getPrimaryDisplayId(), *mWriter); redLayer->setColor(RED); redLayer->setDisplayFrame(redRect); redLayer->setWhitePointNits(kMaxBrightnessNits); redLayer->setBrightness(1.f); const auto dimmerRedLayer = - std::make_shared(mComposerClient, getPrimaryDisplayId()); + std::make_shared(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(mComposerClient, getPrimaryDisplayId()); + std::make_shared(mComposerClient, getPrimaryDisplayId(), *mWriter); backgroundLayer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()}); backgroundLayer->setZOrder(0); backgroundLayer->setColor(mBackgroundColor); - auto layer = std::make_shared(mComposerClient, *mTestRenderEngine, - getPrimaryDisplayId(), getDisplayWidth(), - getDisplayHeight(), PixelFormat::RGBA_8888); + auto layer = std::make_shared( + 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(mComposerClient, getPrimaryDisplayId()); + std::make_shared(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(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( 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); diff --git a/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_TargetTest.cpp b/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_TargetTest.cpp index 2b755c2c42..5ff420a05b 100644 --- a/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_TargetTest.cpp +++ b/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_TargetTest.cpp @@ -70,7 +70,7 @@ class GraphicsComposerAidlTest : public ::testing::TestWithParam { } 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(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(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(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(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 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) {