blob: 5ff420a05bf4d5bac04cf2f21576a9efe9995022 [file] [log] [blame]
ramindani431aad42022-02-01 21:44:29 +00001/**
2 * Copyright (c) 2022, The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
Sally Qi2600d342022-08-16 12:46:17 -070016
ramindanid32ae8e2021-10-01 18:48:39 +000017#include <aidl/Gtest.h>
18#include <aidl/Vintf.h>
Ady Abraham3192f3d2021-12-03 16:08:56 -080019#include <aidl/android/hardware/graphics/common/BlendMode.h>
ramindani3335f7a2021-10-25 17:22:35 +000020#include <aidl/android/hardware/graphics/common/BufferUsage.h>
21#include <aidl/android/hardware/graphics/common/FRect.h>
Leon Scroggins IIIde057582022-01-13 12:26:00 -050022#include <aidl/android/hardware/graphics/common/PixelFormat.h>
ramindani3335f7a2021-10-25 17:22:35 +000023#include <aidl/android/hardware/graphics/common/Rect.h>
ramindani3335f7a2021-10-25 17:22:35 +000024#include <aidl/android/hardware/graphics/composer3/Composition.h>
ramindanid32ae8e2021-10-01 18:48:39 +000025#include <aidl/android/hardware/graphics/composer3/IComposer.h>
26#include <android-base/properties.h>
ramindania9780262021-10-01 18:48:39 +000027#include <android/binder_process.h>
Ady Abraham91c9d1a2021-12-15 18:14:45 -080028#include <android/hardware/graphics/composer3/ComposerClientReader.h>
29#include <android/hardware/graphics/composer3/ComposerClientWriter.h>
ramindanid32ae8e2021-10-01 18:48:39 +000030#include <binder/ProcessState.h>
31#include <gtest/gtest.h>
Ady Abraham72c5b502021-12-10 17:23:39 -080032#include <ui/Fence.h>
ramindani3335f7a2021-10-25 17:22:35 +000033#include <ui/GraphicBuffer.h>
34#include <ui/PixelFormat.h>
ramindani0291f112021-11-04 03:45:46 +000035#include <algorithm>
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -040036#include <iterator>
Joen Chene0a962c2023-08-28 09:49:11 +000037#include <mutex>
ramindani592b6512021-10-08 21:15:19 +000038#include <numeric>
ramindanid32ae8e2021-10-01 18:48:39 +000039#include <string>
ramindani1cb794e2021-10-13 20:45:23 +000040#include <thread>
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -040041#include <unordered_map>
ramindani458e53e2022-02-23 17:30:16 +000042#include "GraphicsComposerCallback.h"
43#include "VtsComposerClient.h"
ramindani3335f7a2021-10-25 17:22:35 +000044
ramindanid32ae8e2021-10-01 18:48:39 +000045#undef LOG_TAG
46#define LOG_TAG "VtsHalGraphicsComposer3_TargetTest"
47
48namespace aidl::android::hardware::graphics::composer3::vts {
ramindanid32ae8e2021-10-01 18:48:39 +000049
ramindani1cb794e2021-10-13 20:45:23 +000050using namespace std::chrono_literals;
51
ramindanidcfe3a82021-11-29 17:00:31 +000052using ::android::GraphicBuffer;
53using ::android::sp;
54
ramindanid32ae8e2021-10-01 18:48:39 +000055class GraphicsComposerAidlTest : public ::testing::TestWithParam<std::string> {
ramindania9780262021-10-01 18:48:39 +000056 protected:
57 void SetUp() override {
ramindani431aad42022-02-01 21:44:29 +000058 mComposerClient = std::make_unique<VtsComposerClient>(GetParam());
59 ASSERT_TRUE(mComposerClient->createClient().isOk());
Jason Macnake531a092022-01-20 08:49:09 -080060
ramindani431aad42022-02-01 21:44:29 +000061 const auto& [status, displays] = mComposerClient->getDisplays();
Jason Macnake531a092022-01-20 08:49:09 -080062 ASSERT_TRUE(status.isOk());
ramindani431aad42022-02-01 21:44:29 +000063 mDisplays = displays;
ramindanidcfe3a82021-11-29 17:00:31 +000064
ramindani3335f7a2021-10-25 17:22:35 +000065 // explicitly disable vsync
66 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +000067 EXPECT_TRUE(mComposerClient->setVsync(display.getDisplayId(), false).isOk());
ramindani3335f7a2021-10-25 17:22:35 +000068 }
ramindani431aad42022-02-01 21:44:29 +000069 mComposerClient->setVsyncAllowed(false);
ramindania9780262021-10-01 18:48:39 +000070 }
71
ramindani3335f7a2021-10-25 17:22:35 +000072 void TearDown() override {
Ady Abrahama00d2462023-12-26 14:21:20 -080073 ASSERT_TRUE(mComposerClient->tearDown(nullptr));
ramindani431aad42022-02-01 21:44:29 +000074 mComposerClient.reset();
ramindani3335f7a2021-10-25 17:22:35 +000075 }
ramindanic2b8d082021-11-06 02:03:50 +000076
ramindanid5751092022-04-22 22:30:20 +000077 void assertServiceSpecificError(const ScopedAStatus& status, int32_t serviceSpecificError) {
78 ASSERT_EQ(status.getExceptionCode(), EX_SERVICE_SPECIFIC);
79 ASSERT_EQ(status.getServiceSpecificError(), serviceSpecificError);
80 }
81
ramindani431aad42022-02-01 21:44:29 +000082 void Test_setContentTypeForDisplay(int64_t display,
83 const std::vector<ContentType>& supportedContentTypes,
84 ContentType contentType, const char* contentTypeStr) {
85 const bool contentTypeSupport =
86 std::find(supportedContentTypes.begin(), supportedContentTypes.end(),
87 contentType) != supportedContentTypes.end();
ramindanidcfe3a82021-11-29 17:00:31 +000088
89 if (!contentTypeSupport) {
ramindani431aad42022-02-01 21:44:29 +000090 const auto& status = mComposerClient->setContentType(display, contentType);
91 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +000092 EXPECT_NO_FATAL_FAILURE(
93 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
ramindanidcfe3a82021-11-29 17:00:31 +000094 GTEST_SUCCEED() << contentTypeStr << " content type is not supported on display "
95 << std::to_string(display) << ", skipping test";
96 return;
97 }
98
99 EXPECT_TRUE(mComposerClient->setContentType(display, contentType).isOk());
100 EXPECT_TRUE(mComposerClient->setContentType(display, ContentType::NONE).isOk());
101 }
102
ramindani431aad42022-02-01 21:44:29 +0000103 void Test_setContentType(ContentType contentType, const char* contentTypeStr) {
ramindanidcfe3a82021-11-29 17:00:31 +0000104 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000105 const auto& [status, supportedContentTypes] =
106 mComposerClient->getSupportedContentTypes(display.getDisplayId());
107 EXPECT_TRUE(status.isOk());
108 Test_setContentTypeForDisplay(display.getDisplayId(), supportedContentTypes,
109 contentType, contentTypeStr);
ramindanidcfe3a82021-11-29 17:00:31 +0000110 }
111 }
112
Jason Macnak325e8232022-01-24 14:48:55 -0800113 bool hasCapability(Capability capability) {
ramindani431aad42022-02-01 21:44:29 +0000114 const auto& [status, capabilities] = mComposerClient->getCapabilities();
115 EXPECT_TRUE(status.isOk());
Jason Macnak325e8232022-01-24 14:48:55 -0800116 return std::any_of(
117 capabilities.begin(), capabilities.end(),
118 [&](const Capability& activeCapability) { return activeCapability == capability; });
119 }
120
ramindani17c71102023-03-20 10:51:14 -0700121 int getInterfaceVersion() {
122 const auto& [versionStatus, version] = mComposerClient->getInterfaceVersion();
123 EXPECT_TRUE(versionStatus.isOk());
124 return version;
125 }
126
ramindani431aad42022-02-01 21:44:29 +0000127 const VtsDisplay& getPrimaryDisplay() const { return mDisplays[0]; }
ramindania9780262021-10-01 18:48:39 +0000128
ramindani431aad42022-02-01 21:44:29 +0000129 int64_t getPrimaryDisplayId() const { return getPrimaryDisplay().getDisplayId(); }
ramindania9780262021-10-01 18:48:39 +0000130
ramindani431aad42022-02-01 21:44:29 +0000131 int64_t getInvalidDisplayId() const { return mComposerClient->getInvalidDisplayId(); }
ramindani1cb794e2021-10-13 20:45:23 +0000132
ramindani431aad42022-02-01 21:44:29 +0000133 VtsDisplay& getEditablePrimaryDisplay() { return mDisplays[0]; }
ramindani0291f112021-11-04 03:45:46 +0000134
ramindani3335f7a2021-10-25 17:22:35 +0000135 struct TestParameters {
136 nsecs_t delayForChange;
137 bool refreshMiss;
138 };
139
ramindani431aad42022-02-01 21:44:29 +0000140 std::unique_ptr<VtsComposerClient> mComposerClient;
ramindani1cb794e2021-10-13 20:45:23 +0000141 std::vector<VtsDisplay> mDisplays;
ramindani3335f7a2021-10-25 17:22:35 +0000142 // use the slot count usually set by SF
143 static constexpr uint32_t kBufferSlotCount = 64;
ramindanid32ae8e2021-10-01 18:48:39 +0000144};
145
ramindani431aad42022-02-01 21:44:29 +0000146TEST_P(GraphicsComposerAidlTest, GetDisplayCapabilities_BadDisplay) {
147 const auto& [status, _] = mComposerClient->getDisplayCapabilities(getInvalidDisplayId());
ramindani5f696942021-10-14 16:24:18 +0000148
ramindani431aad42022-02-01 21:44:29 +0000149 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000150 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindania9780262021-10-01 18:48:39 +0000151}
152
ramindani431aad42022-02-01 21:44:29 +0000153TEST_P(GraphicsComposerAidlTest, GetDisplayCapabilities) {
ramindania9780262021-10-01 18:48:39 +0000154 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000155 const auto& [status, capabilities] =
156 mComposerClient->getDisplayCapabilities(display.getDisplayId());
ramindania9780262021-10-01 18:48:39 +0000157
ramindani431aad42022-02-01 21:44:29 +0000158 EXPECT_TRUE(status.isOk());
ramindania9780262021-10-01 18:48:39 +0000159 }
ramindanid32ae8e2021-10-01 18:48:39 +0000160}
161
ramindani2740bac2021-11-24 22:58:32 +0000162TEST_P(GraphicsComposerAidlTest, DumpDebugInfo) {
ramindani431aad42022-02-01 21:44:29 +0000163 ASSERT_TRUE(mComposerClient->dumpDebugInfo().isOk());
ramindani2740bac2021-11-24 22:58:32 +0000164}
165
166TEST_P(GraphicsComposerAidlTest, CreateClientSingleton) {
167 std::shared_ptr<IComposerClient> composerClient;
ramindani431aad42022-02-01 21:44:29 +0000168 const auto& status = mComposerClient->createClient();
ramindani2740bac2021-11-24 22:58:32 +0000169
ramindani431aad42022-02-01 21:44:29 +0000170 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000171 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_NO_RESOURCES));
ramindani2740bac2021-11-24 22:58:32 +0000172}
173
ramindani592b6512021-10-08 21:15:19 +0000174TEST_P(GraphicsComposerAidlTest, GetDisplayIdentificationData) {
ramindani431aad42022-02-01 21:44:29 +0000175 const auto& [status0, displayIdentification0] =
176 mComposerClient->getDisplayIdentificationData(getPrimaryDisplayId());
ramindanid5751092022-04-22 22:30:20 +0000177 if (!status0.isOk() && status0.getExceptionCode() == EX_SERVICE_SPECIFIC &&
178 status0.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindani431aad42022-02-01 21:44:29 +0000179 GTEST_SUCCEED() << "Display identification data not supported, skipping test";
ramindani592b6512021-10-08 21:15:19 +0000180 return;
181 }
ramindani431aad42022-02-01 21:44:29 +0000182 ASSERT_TRUE(status0.isOk()) << "failed to get display identification data";
ramindani592b6512021-10-08 21:15:19 +0000183 ASSERT_FALSE(displayIdentification0.data.empty());
184
185 constexpr size_t kEdidBlockSize = 128;
186 ASSERT_TRUE(displayIdentification0.data.size() % kEdidBlockSize == 0)
187 << "EDID blob length is not a multiple of " << kEdidBlockSize;
188
189 const uint8_t kEdidHeader[] = {0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00};
190 ASSERT_TRUE(std::equal(std::begin(kEdidHeader), std::end(kEdidHeader),
191 displayIdentification0.data.begin()))
192 << "EDID blob doesn't start with the fixed EDID header";
193 ASSERT_EQ(0, std::accumulate(displayIdentification0.data.begin(),
194 displayIdentification0.data.begin() + kEdidBlockSize,
195 static_cast<uint8_t>(0)))
196 << "EDID base block doesn't checksum";
197
ramindani431aad42022-02-01 21:44:29 +0000198 const auto& [status1, displayIdentification1] =
199 mComposerClient->getDisplayIdentificationData(getPrimaryDisplayId());
200 ASSERT_TRUE(status1.isOk());
ramindani592b6512021-10-08 21:15:19 +0000201
202 ASSERT_EQ(displayIdentification0.port, displayIdentification1.port) << "ports are not stable";
203 ASSERT_TRUE(displayIdentification0.data.size() == displayIdentification1.data.size() &&
204 std::equal(displayIdentification0.data.begin(), displayIdentification0.data.end(),
205 displayIdentification1.data.begin()))
206 << "data is not stable";
207}
208
209TEST_P(GraphicsComposerAidlTest, GetHdrCapabilities) {
ramindani431aad42022-02-01 21:44:29 +0000210 const auto& [status, hdrCapabilities] =
211 mComposerClient->getHdrCapabilities(getPrimaryDisplayId());
ramindani592b6512021-10-08 21:15:19 +0000212
ramindani431aad42022-02-01 21:44:29 +0000213 ASSERT_TRUE(status.isOk());
214 EXPECT_TRUE(hdrCapabilities.maxLuminance >= hdrCapabilities.minLuminance);
ramindani592b6512021-10-08 21:15:19 +0000215}
216
217TEST_P(GraphicsComposerAidlTest, GetPerFrameMetadataKeys) {
ramindani431aad42022-02-01 21:44:29 +0000218 const auto& [status, keys] = mComposerClient->getPerFrameMetadataKeys(getPrimaryDisplayId());
ramindanid5751092022-04-22 22:30:20 +0000219 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
220 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindanic2b8d082021-11-06 02:03:50 +0000221 GTEST_SUCCEED() << "getPerFrameMetadataKeys is not supported";
222 return;
ramindani592b6512021-10-08 21:15:19 +0000223 }
ramindani431aad42022-02-01 21:44:29 +0000224
225 ASSERT_TRUE(status.isOk());
226 EXPECT_TRUE(keys.size() >= 0);
ramindani592b6512021-10-08 21:15:19 +0000227}
228
229TEST_P(GraphicsComposerAidlTest, GetReadbackBufferAttributes) {
ramindani431aad42022-02-01 21:44:29 +0000230 const auto& [status, _] = mComposerClient->getReadbackBufferAttributes(getPrimaryDisplayId());
ramindanid5751092022-04-22 22:30:20 +0000231 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
232 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindani431aad42022-02-01 21:44:29 +0000233 GTEST_SUCCEED() << "getReadbackBufferAttributes is not supported";
234 return;
ramindani592b6512021-10-08 21:15:19 +0000235 }
ramindani431aad42022-02-01 21:44:29 +0000236
237 ASSERT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000238}
239
240TEST_P(GraphicsComposerAidlTest, GetRenderIntents) {
ramindani431aad42022-02-01 21:44:29 +0000241 const auto& [status, modes] = mComposerClient->getColorModes(getPrimaryDisplayId());
242 EXPECT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000243
ramindani431aad42022-02-01 21:44:29 +0000244 for (auto mode : modes) {
245 const auto& [intentStatus, intents] =
246 mComposerClient->getRenderIntents(getPrimaryDisplayId(), mode);
247 EXPECT_TRUE(intentStatus.isOk());
ramindani592b6512021-10-08 21:15:19 +0000248 bool isHdr;
249 switch (mode) {
250 case ColorMode::BT2100_PQ:
251 case ColorMode::BT2100_HLG:
252 isHdr = true;
253 break;
254 default:
255 isHdr = false;
256 break;
257 }
258 RenderIntent requiredIntent =
259 isHdr ? RenderIntent::TONE_MAP_COLORIMETRIC : RenderIntent::COLORIMETRIC;
260
ramindani431aad42022-02-01 21:44:29 +0000261 const auto iter = std::find(intents.cbegin(), intents.cend(), requiredIntent);
ramindani592b6512021-10-08 21:15:19 +0000262 EXPECT_NE(intents.cend(), iter);
263 }
264}
265
ramindani431aad42022-02-01 21:44:29 +0000266TEST_P(GraphicsComposerAidlTest, GetRenderIntents_BadDisplay) {
267 const auto& [status, modes] = mComposerClient->getColorModes(getPrimaryDisplayId());
268 ASSERT_TRUE(status.isOk());
269
ramindani592b6512021-10-08 21:15:19 +0000270 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +0000271 const auto& [intentStatus, _] =
272 mComposerClient->getRenderIntents(getInvalidDisplayId(), mode);
273
274 EXPECT_FALSE(intentStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000275 EXPECT_NO_FATAL_FAILURE(
276 assertServiceSpecificError(intentStatus, IComposerClient::EX_BAD_DISPLAY));
ramindani592b6512021-10-08 21:15:19 +0000277 }
278}
279
ramindani431aad42022-02-01 21:44:29 +0000280TEST_P(GraphicsComposerAidlTest, GetRenderIntents_BadParameter) {
281 const auto& [status, _] =
282 mComposerClient->getRenderIntents(getPrimaryDisplayId(), static_cast<ColorMode>(-1));
283
284 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000285 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
ramindani592b6512021-10-08 21:15:19 +0000286}
287
288TEST_P(GraphicsComposerAidlTest, GetColorModes) {
ramindani431aad42022-02-01 21:44:29 +0000289 const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
290 ASSERT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000291
ramindani431aad42022-02-01 21:44:29 +0000292 const auto native = std::find(colorModes.cbegin(), colorModes.cend(), ColorMode::NATIVE);
293 EXPECT_NE(colorModes.cend(), native);
ramindani592b6512021-10-08 21:15:19 +0000294}
295
ramindani431aad42022-02-01 21:44:29 +0000296TEST_P(GraphicsComposerAidlTest, GetColorMode_BadDisplay) {
297 const auto& [status, _] = mComposerClient->getColorModes(getInvalidDisplayId());
ramindani592b6512021-10-08 21:15:19 +0000298
ramindani431aad42022-02-01 21:44:29 +0000299 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000300 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani592b6512021-10-08 21:15:19 +0000301}
302
303TEST_P(GraphicsComposerAidlTest, SetColorMode) {
ramindani431aad42022-02-01 21:44:29 +0000304 const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
305 EXPECT_TRUE(status.isOk());
306
ramindani592b6512021-10-08 21:15:19 +0000307 for (auto mode : colorModes) {
ramindani431aad42022-02-01 21:44:29 +0000308 const auto& [intentStatus, intents] =
309 mComposerClient->getRenderIntents(getPrimaryDisplayId(), mode);
310 EXPECT_TRUE(intentStatus.isOk()) << "failed to get render intents";
311
ramindani592b6512021-10-08 21:15:19 +0000312 for (auto intent : intents) {
ramindani431aad42022-02-01 21:44:29 +0000313 const auto modeStatus =
314 mComposerClient->setColorMode(getPrimaryDisplayId(), mode, intent);
315 EXPECT_TRUE(modeStatus.isOk() ||
ramindanid5751092022-04-22 22:30:20 +0000316 (modeStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
317 IComposerClient::EX_UNSUPPORTED == modeStatus.getServiceSpecificError()))
ramindani592b6512021-10-08 21:15:19 +0000318 << "failed to set color mode";
319 }
320 }
321
ramindani431aad42022-02-01 21:44:29 +0000322 const auto modeStatus = mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE,
323 RenderIntent::COLORIMETRIC);
324 EXPECT_TRUE(modeStatus.isOk() ||
ramindanid5751092022-04-22 22:30:20 +0000325 (modeStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
326 IComposerClient::EX_UNSUPPORTED == modeStatus.getServiceSpecificError()))
ramindani592b6512021-10-08 21:15:19 +0000327 << "failed to set color mode";
328}
329
ramindani431aad42022-02-01 21:44:29 +0000330TEST_P(GraphicsComposerAidlTest, SetColorMode_BadDisplay) {
331 const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
332 ASSERT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000333
ramindani431aad42022-02-01 21:44:29 +0000334 for (auto mode : colorModes) {
335 const auto& [intentStatus, intents] =
336 mComposerClient->getRenderIntents(getPrimaryDisplayId(), mode);
337 ASSERT_TRUE(intentStatus.isOk()) << "failed to get render intents";
338
339 for (auto intent : intents) {
340 auto const modeStatus =
341 mComposerClient->setColorMode(getInvalidDisplayId(), mode, intent);
342
343 EXPECT_FALSE(modeStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000344 EXPECT_NO_FATAL_FAILURE(
345 assertServiceSpecificError(modeStatus, IComposerClient::EX_BAD_DISPLAY));
ramindani770d7082021-11-30 00:36:42 +0000346 }
347 }
ramindani592b6512021-10-08 21:15:19 +0000348}
349
ramindani431aad42022-02-01 21:44:29 +0000350TEST_P(GraphicsComposerAidlTest, SetColorMode_BadParameter) {
351 auto status = mComposerClient->setColorMode(getPrimaryDisplayId(), static_cast<ColorMode>(-1),
352 RenderIntent::COLORIMETRIC);
ramindani592b6512021-10-08 21:15:19 +0000353
ramindani431aad42022-02-01 21:44:29 +0000354 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000355 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
ramindani592b6512021-10-08 21:15:19 +0000356
ramindani431aad42022-02-01 21:44:29 +0000357 status = mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE,
358 static_cast<RenderIntent>(-1));
ramindani592b6512021-10-08 21:15:19 +0000359
ramindani431aad42022-02-01 21:44:29 +0000360 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000361 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
ramindani592b6512021-10-08 21:15:19 +0000362}
363
364TEST_P(GraphicsComposerAidlTest, GetDisplayedContentSamplingAttributes) {
ramindani431aad42022-02-01 21:44:29 +0000365 int constexpr kInvalid = -1;
366 const auto& [status, format] =
367 mComposerClient->getDisplayedContentSamplingAttributes(getPrimaryDisplayId());
ramindani592b6512021-10-08 21:15:19 +0000368
ramindanid5751092022-04-22 22:30:20 +0000369 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
370 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindani592b6512021-10-08 21:15:19 +0000371 SUCCEED() << "Device does not support optional extension. Test skipped";
372 return;
373 }
374
ramindani431aad42022-02-01 21:44:29 +0000375 ASSERT_TRUE(status.isOk());
376 EXPECT_NE(kInvalid, static_cast<int>(format.format));
377 EXPECT_NE(kInvalid, static_cast<int>(format.dataspace));
378 EXPECT_NE(kInvalid, static_cast<int>(format.componentMask));
ramindani592b6512021-10-08 21:15:19 +0000379};
380
381TEST_P(GraphicsComposerAidlTest, SetDisplayedContentSamplingEnabled) {
ramindani431aad42022-02-01 21:44:29 +0000382 int constexpr kMaxFrames = 10;
ramindani592b6512021-10-08 21:15:19 +0000383 FormatColorComponent enableAllComponents = FormatColorComponent::FORMAT_COMPONENT_0;
ramindani431aad42022-02-01 21:44:29 +0000384 auto status = mComposerClient->setDisplayedContentSamplingEnabled(
385 getPrimaryDisplayId(), /*isEnabled*/ true, enableAllComponents, kMaxFrames);
ramindanid5751092022-04-22 22:30:20 +0000386 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
387 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindani592b6512021-10-08 21:15:19 +0000388 SUCCEED() << "Device does not support optional extension. Test skipped";
389 return;
390 }
ramindani431aad42022-02-01 21:44:29 +0000391 EXPECT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000392
ramindani431aad42022-02-01 21:44:29 +0000393 status = mComposerClient->setDisplayedContentSamplingEnabled(
394 getPrimaryDisplayId(), /*isEnabled*/ false, enableAllComponents, kMaxFrames);
395 EXPECT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000396}
397
398TEST_P(GraphicsComposerAidlTest, GetDisplayedContentSample) {
ramindani431aad42022-02-01 21:44:29 +0000399 const auto& [status, displayContentSamplingAttributes] =
400 mComposerClient->getDisplayedContentSamplingAttributes(getPrimaryDisplayId());
ramindanid5751092022-04-22 22:30:20 +0000401 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
402 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindanideb059e2021-11-18 01:57:25 +0000403 SUCCEED() << "Sampling attributes aren't supported on this device, test skipped";
404 return;
405 }
ramindani592b6512021-10-08 21:15:19 +0000406
ramindani431aad42022-02-01 21:44:29 +0000407 int64_t constexpr kMaxFrames = 10;
408 int64_t constexpr kTimestamp = 0;
409 const auto& [sampleStatus, displayContentSample] = mComposerClient->getDisplayedContentSample(
410 getPrimaryDisplayId(), kMaxFrames, kTimestamp);
ramindanid5751092022-04-22 22:30:20 +0000411 if (!sampleStatus.isOk() && sampleStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
ramindani431aad42022-02-01 21:44:29 +0000412 sampleStatus.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindani592b6512021-10-08 21:15:19 +0000413 SUCCEED() << "Device does not support optional extension. Test skipped";
414 return;
415 }
416
ramindani431aad42022-02-01 21:44:29 +0000417 EXPECT_TRUE(sampleStatus.isOk());
418 const std::vector<std::vector<int64_t>> histogram = {
ramindani592b6512021-10-08 21:15:19 +0000419 displayContentSample.sampleComponent0, displayContentSample.sampleComponent1,
420 displayContentSample.sampleComponent2, displayContentSample.sampleComponent3};
421
ramindani3335f7a2021-10-25 17:22:35 +0000422 for (size_t i = 0; i < histogram.size(); i++) {
423 const bool shouldHaveHistogram =
424 static_cast<int>(displayContentSamplingAttributes.componentMask) & (1 << i);
425 EXPECT_EQ(shouldHaveHistogram, !histogram[i].empty());
ramindani592b6512021-10-08 21:15:19 +0000426 }
427}
428
ramindani431aad42022-02-01 21:44:29 +0000429TEST_P(GraphicsComposerAidlTest, GetDisplayConnectionType) {
430 const auto& [status, type] = mComposerClient->getDisplayConnectionType(getInvalidDisplayId());
431
432 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000433 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani431aad42022-02-01 21:44:29 +0000434
ramindani0291f112021-11-04 03:45:46 +0000435 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000436 const auto& [connectionTypeStatus, _] =
437 mComposerClient->getDisplayConnectionType(display.getDisplayId());
438 EXPECT_TRUE(connectionTypeStatus.isOk());
ramindani0291f112021-11-04 03:45:46 +0000439 }
440}
441
ramindani431aad42022-02-01 21:44:29 +0000442TEST_P(GraphicsComposerAidlTest, GetDisplayAttribute) {
ramindani0291f112021-11-04 03:45:46 +0000443 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000444 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
445 EXPECT_TRUE(status.isOk());
446
ramindani0291f112021-11-04 03:45:46 +0000447 for (const auto& config : configs) {
448 const std::array<DisplayAttribute, 4> requiredAttributes = {{
449 DisplayAttribute::WIDTH,
450 DisplayAttribute::HEIGHT,
451 DisplayAttribute::VSYNC_PERIOD,
452 DisplayAttribute::CONFIG_GROUP,
453 }};
ramindani0291f112021-11-04 03:45:46 +0000454 for (const auto& attribute : requiredAttributes) {
ramindani431aad42022-02-01 21:44:29 +0000455 const auto& [attribStatus, value] = mComposerClient->getDisplayAttribute(
456 display.getDisplayId(), config, attribute);
457 EXPECT_TRUE(attribStatus.isOk());
ramindani0291f112021-11-04 03:45:46 +0000458 EXPECT_NE(-1, value);
459 }
460
461 const std::array<DisplayAttribute, 2> optionalAttributes = {{
462 DisplayAttribute::DPI_X,
463 DisplayAttribute::DPI_Y,
464 }};
465 for (const auto& attribute : optionalAttributes) {
ramindani431aad42022-02-01 21:44:29 +0000466 const auto& [attribStatus, value] = mComposerClient->getDisplayAttribute(
467 display.getDisplayId(), config, attribute);
ramindanid5751092022-04-22 22:30:20 +0000468 EXPECT_TRUE(attribStatus.isOk() ||
469 (attribStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
470 IComposerClient::EX_UNSUPPORTED ==
471 attribStatus.getServiceSpecificError()));
ramindani0291f112021-11-04 03:45:46 +0000472 }
473 }
474 }
475}
476
ramindani431aad42022-02-01 21:44:29 +0000477TEST_P(GraphicsComposerAidlTest, CheckConfigsAreValid) {
ramindani0291f112021-11-04 03:45:46 +0000478 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000479 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
480 EXPECT_TRUE(status.isOk());
ramindani0291f112021-11-04 03:45:46 +0000481
482 EXPECT_FALSE(std::any_of(configs.begin(), configs.end(), [](auto config) {
483 return config == IComposerClient::INVALID_CONFIGURATION;
484 }));
485 }
486}
487
ramindani431aad42022-02-01 21:44:29 +0000488TEST_P(GraphicsComposerAidlTest, GetDisplayVsyncPeriod_BadDisplay) {
489 const auto& [status, vsyncPeriodNanos] =
490 mComposerClient->getDisplayVsyncPeriod(getInvalidDisplayId());
491
492 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000493 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani0291f112021-11-04 03:45:46 +0000494}
495
ramindani431aad42022-02-01 21:44:29 +0000496TEST_P(GraphicsComposerAidlTest, SetActiveConfigWithConstraints_BadDisplay) {
ramindani0291f112021-11-04 03:45:46 +0000497 VsyncPeriodChangeConstraints constraints;
ramindani0291f112021-11-04 03:45:46 +0000498 constraints.seamlessRequired = false;
499 constraints.desiredTimeNanos = systemTime();
ramindani431aad42022-02-01 21:44:29 +0000500 auto invalidDisplay = VtsDisplay(getInvalidDisplayId());
ramindani0291f112021-11-04 03:45:46 +0000501
ramindani431aad42022-02-01 21:44:29 +0000502 const auto& [status, timeline] = mComposerClient->setActiveConfigWithConstraints(
503 &invalidDisplay, /*config*/ 0, constraints);
504
505 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000506 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani0291f112021-11-04 03:45:46 +0000507}
508
ramindani431aad42022-02-01 21:44:29 +0000509TEST_P(GraphicsComposerAidlTest, SetActiveConfigWithConstraints_BadConfig) {
ramindani0291f112021-11-04 03:45:46 +0000510 VsyncPeriodChangeConstraints constraints;
ramindani0291f112021-11-04 03:45:46 +0000511 constraints.seamlessRequired = false;
512 constraints.desiredTimeNanos = systemTime();
513
514 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000515 int32_t constexpr kInvalidConfigId = IComposerClient::INVALID_CONFIGURATION;
516 const auto& [status, _] = mComposerClient->setActiveConfigWithConstraints(
517 &display, kInvalidConfigId, constraints);
518
519 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000520 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_CONFIG));
ramindani0291f112021-11-04 03:45:46 +0000521 }
522}
523
ramindani431aad42022-02-01 21:44:29 +0000524TEST_P(GraphicsComposerAidlTest, SetBootDisplayConfig_BadDisplay) {
ramindani476314c2022-03-16 00:17:08 +0000525 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
526 GTEST_SUCCEED() << "Boot Display Config not supported";
527 return;
528 }
ramindani431aad42022-02-01 21:44:29 +0000529 const auto& status = mComposerClient->setBootDisplayConfig(getInvalidDisplayId(), /*config*/ 0);
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100530
ramindani431aad42022-02-01 21:44:29 +0000531 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000532 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100533}
534
ramindani431aad42022-02-01 21:44:29 +0000535TEST_P(GraphicsComposerAidlTest, SetBootDisplayConfig_BadConfig) {
ramindani476314c2022-03-16 00:17:08 +0000536 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
537 GTEST_SUCCEED() << "Boot Display Config not supported";
538 return;
539 }
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100540 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000541 int32_t constexpr kInvalidConfigId = IComposerClient::INVALID_CONFIGURATION;
542 const auto& status =
543 mComposerClient->setBootDisplayConfig(display.getDisplayId(), kInvalidConfigId);
544
545 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000546 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_CONFIG));
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100547 }
548}
549
ramindani431aad42022-02-01 21:44:29 +0000550TEST_P(GraphicsComposerAidlTest, SetBootDisplayConfig) {
ramindani476314c2022-03-16 00:17:08 +0000551 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
552 GTEST_SUCCEED() << "Boot Display Config not supported";
553 return;
554 }
ramindani431aad42022-02-01 21:44:29 +0000555 const auto& [status, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
556 EXPECT_TRUE(status.isOk());
557 for (const auto& config : configs) {
558 EXPECT_TRUE(mComposerClient->setBootDisplayConfig(getPrimaryDisplayId(), config).isOk());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100559 }
560}
561
ramindani431aad42022-02-01 21:44:29 +0000562TEST_P(GraphicsComposerAidlTest, ClearBootDisplayConfig_BadDisplay) {
ramindani476314c2022-03-16 00:17:08 +0000563 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
564 GTEST_SUCCEED() << "Boot Display Config not supported";
565 return;
566 }
ramindani431aad42022-02-01 21:44:29 +0000567 const auto& status = mComposerClient->clearBootDisplayConfig(getInvalidDisplayId());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100568
ramindani431aad42022-02-01 21:44:29 +0000569 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000570 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100571}
572
ramindani431aad42022-02-01 21:44:29 +0000573TEST_P(GraphicsComposerAidlTest, ClearBootDisplayConfig) {
ramindani476314c2022-03-16 00:17:08 +0000574 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
575 GTEST_SUCCEED() << "Boot Display Config not supported";
576 return;
577 }
ramindani431aad42022-02-01 21:44:29 +0000578 EXPECT_TRUE(mComposerClient->clearBootDisplayConfig(getPrimaryDisplayId()).isOk());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100579}
580
ramindani431aad42022-02-01 21:44:29 +0000581TEST_P(GraphicsComposerAidlTest, GetPreferredBootDisplayConfig_BadDisplay) {
ramindani476314c2022-03-16 00:17:08 +0000582 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
583 GTEST_SUCCEED() << "Boot Display Config not supported";
584 return;
585 }
ramindani431aad42022-02-01 21:44:29 +0000586 const auto& [status, _] = mComposerClient->getPreferredBootDisplayConfig(getInvalidDisplayId());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100587
ramindani431aad42022-02-01 21:44:29 +0000588 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000589 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100590}
591
ramindani431aad42022-02-01 21:44:29 +0000592TEST_P(GraphicsComposerAidlTest, GetPreferredBootDisplayConfig) {
ramindani476314c2022-03-16 00:17:08 +0000593 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
594 GTEST_SUCCEED() << "Boot Display Config not supported";
595 return;
596 }
ramindani431aad42022-02-01 21:44:29 +0000597 const auto& [status, preferredDisplayConfig] =
598 mComposerClient->getPreferredBootDisplayConfig(getPrimaryDisplayId());
599 EXPECT_TRUE(status.isOk());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100600
ramindani431aad42022-02-01 21:44:29 +0000601 const auto& [configStatus, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
602
603 EXPECT_TRUE(configStatus.isOk());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100604 EXPECT_NE(configs.end(), std::find(configs.begin(), configs.end(), preferredDisplayConfig));
605}
606
ramindani476314c2022-03-16 00:17:08 +0000607TEST_P(GraphicsComposerAidlTest, BootDisplayConfig_Unsupported) {
608 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
609 const auto& [configStatus, config] =
610 mComposerClient->getActiveConfig(getPrimaryDisplayId());
611 EXPECT_TRUE(configStatus.isOk());
612
613 auto status = mComposerClient->setBootDisplayConfig(getPrimaryDisplayId(), config);
614 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000615 EXPECT_NO_FATAL_FAILURE(
616 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
ramindani476314c2022-03-16 00:17:08 +0000617
618 status = mComposerClient->getPreferredBootDisplayConfig(getPrimaryDisplayId()).first;
619 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000620 EXPECT_NO_FATAL_FAILURE(
621 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
ramindani476314c2022-03-16 00:17:08 +0000622
623 status = mComposerClient->clearBootDisplayConfig(getPrimaryDisplayId());
624 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000625 EXPECT_NO_FATAL_FAILURE(
626 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
ramindani476314c2022-03-16 00:17:08 +0000627 }
628}
629
Kriti Dang3793ebd2022-12-05 13:03:49 +0100630TEST_P(GraphicsComposerAidlTest, GetHdrConversionCapabilities) {
631 if (!hasCapability(Capability::HDR_OUTPUT_CONVERSION_CONFIG)) {
632 GTEST_SUCCEED() << "HDR output conversion not supported";
633 return;
634 }
635 const auto& [status, conversionCapabilities] = mComposerClient->getHdrConversionCapabilities();
636 EXPECT_TRUE(status.isOk());
637}
638
639TEST_P(GraphicsComposerAidlTest, SetHdrConversionStrategy_Passthrough) {
640 if (!hasCapability(Capability::HDR_OUTPUT_CONVERSION_CONFIG)) {
641 GTEST_SUCCEED() << "HDR output conversion not supported";
642 return;
643 }
644 common::HdrConversionStrategy hdrConversionStrategy;
645 hdrConversionStrategy.set<common::HdrConversionStrategy::Tag::passthrough>(true);
Kriti Dang37622762023-02-09 18:15:37 +0100646 const auto& [status, preferredHdrOutputType] =
647 mComposerClient->setHdrConversionStrategy(hdrConversionStrategy);
Kriti Dang3793ebd2022-12-05 13:03:49 +0100648 EXPECT_TRUE(status.isOk());
Kriti Dang37622762023-02-09 18:15:37 +0100649 EXPECT_EQ(common::Hdr::INVALID, preferredHdrOutputType);
Kriti Dang3793ebd2022-12-05 13:03:49 +0100650}
651
652TEST_P(GraphicsComposerAidlTest, SetHdrConversionStrategy_Force) {
653 if (!hasCapability(Capability::HDR_OUTPUT_CONVERSION_CONFIG)) {
654 GTEST_SUCCEED() << "HDR output conversion not supported";
655 return;
656 }
657 const auto& [status, conversionCapabilities] = mComposerClient->getHdrConversionCapabilities();
Kriti Dang79bbec92023-05-04 17:54:26 +0200658 const auto& [status2, hdrCapabilities] =
659 mComposerClient->getHdrCapabilities(getPrimaryDisplayId());
660 const auto& hdrTypes = hdrCapabilities.types;
Kriti Dang3793ebd2022-12-05 13:03:49 +0100661 for (auto conversionCapability : conversionCapabilities) {
Kriti Dang5fcddd72023-03-07 14:55:51 +0100662 if (conversionCapability.outputType != common::Hdr::INVALID) {
Kriti Dang79bbec92023-05-04 17:54:26 +0200663 if (std::find(hdrTypes.begin(), hdrTypes.end(), conversionCapability.outputType) ==
664 hdrTypes.end()) {
665 continue;
666 }
Kriti Dang3793ebd2022-12-05 13:03:49 +0100667 common::HdrConversionStrategy hdrConversionStrategy;
668 hdrConversionStrategy.set<common::HdrConversionStrategy::Tag::forceHdrConversion>(
Kriti Dang5fcddd72023-03-07 14:55:51 +0100669 conversionCapability.outputType);
Kriti Dang37622762023-02-09 18:15:37 +0100670 const auto& [statusSet, preferredHdrOutputType] =
Kriti Dang3793ebd2022-12-05 13:03:49 +0100671 mComposerClient->setHdrConversionStrategy(hdrConversionStrategy);
Kriti Dang37622762023-02-09 18:15:37 +0100672 EXPECT_TRUE(statusSet.isOk());
673 EXPECT_EQ(common::Hdr::INVALID, preferredHdrOutputType);
Kriti Dang3793ebd2022-12-05 13:03:49 +0100674 }
675 }
676}
677
678TEST_P(GraphicsComposerAidlTest, SetHdrConversionStrategy_Auto) {
679 if (!hasCapability(Capability::HDR_OUTPUT_CONVERSION_CONFIG)) {
680 GTEST_SUCCEED() << "HDR output conversion not supported";
681 return;
682 }
683 const auto& [status, conversionCapabilities] = mComposerClient->getHdrConversionCapabilities();
Kriti Dang79bbec92023-05-04 17:54:26 +0200684 const auto& [status2, hdrCapabilities] =
685 mComposerClient->getHdrCapabilities(getPrimaryDisplayId());
686 if (hdrCapabilities.types.size() <= 0) {
687 return;
688 }
Kriti Dang3793ebd2022-12-05 13:03:49 +0100689 std::vector<aidl::android::hardware::graphics::common::Hdr> autoHdrTypes;
690 for (auto conversionCapability : conversionCapabilities) {
Kriti Dang5fcddd72023-03-07 14:55:51 +0100691 if (conversionCapability.outputType != common::Hdr::INVALID) {
692 autoHdrTypes.push_back(conversionCapability.outputType);
Kriti Dang3793ebd2022-12-05 13:03:49 +0100693 }
694 }
695 common::HdrConversionStrategy hdrConversionStrategy;
696 hdrConversionStrategy.set<common::HdrConversionStrategy::Tag::autoAllowedHdrTypes>(
697 autoHdrTypes);
Kriti Dang37622762023-02-09 18:15:37 +0100698 const auto& [statusSet, preferredHdrOutputType] =
699 mComposerClient->setHdrConversionStrategy(hdrConversionStrategy);
700 EXPECT_TRUE(statusSet.isOk());
701 EXPECT_NE(common::Hdr::INVALID, preferredHdrOutputType);
Kriti Dang3793ebd2022-12-05 13:03:49 +0100702}
703
ramindani431aad42022-02-01 21:44:29 +0000704TEST_P(GraphicsComposerAidlTest, SetAutoLowLatencyMode_BadDisplay) {
705 auto status = mComposerClient->setAutoLowLatencyMode(getInvalidDisplayId(), /*isEnabled*/ true);
706 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000707 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani431aad42022-02-01 21:44:29 +0000708
709 status = mComposerClient->setAutoLowLatencyMode(getInvalidDisplayId(), /*isEnabled*/ false);
710 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000711 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani0291f112021-11-04 03:45:46 +0000712}
713
ramindani431aad42022-02-01 21:44:29 +0000714TEST_P(GraphicsComposerAidlTest, SetAutoLowLatencyMode) {
ramindani0291f112021-11-04 03:45:46 +0000715 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000716 const auto& [status, capabilities] =
717 mComposerClient->getDisplayCapabilities(display.getDisplayId());
718 ASSERT_TRUE(status.isOk());
ramindani0291f112021-11-04 03:45:46 +0000719
720 const bool allmSupport =
721 std::find(capabilities.begin(), capabilities.end(),
722 DisplayCapability::AUTO_LOW_LATENCY_MODE) != capabilities.end();
723
724 if (!allmSupport) {
ramindani431aad42022-02-01 21:44:29 +0000725 const auto& statusIsOn = mComposerClient->setAutoLowLatencyMode(display.getDisplayId(),
726 /*isEnabled*/ true);
727 EXPECT_FALSE(statusIsOn.isOk());
ramindanid5751092022-04-22 22:30:20 +0000728 EXPECT_NO_FATAL_FAILURE(
729 assertServiceSpecificError(statusIsOn, IComposerClient::EX_UNSUPPORTED));
ramindani431aad42022-02-01 21:44:29 +0000730 const auto& statusIsOff = mComposerClient->setAutoLowLatencyMode(display.getDisplayId(),
731 /*isEnabled*/ false);
732 EXPECT_FALSE(statusIsOff.isOk());
ramindanid5751092022-04-22 22:30:20 +0000733 EXPECT_NO_FATAL_FAILURE(
734 assertServiceSpecificError(statusIsOff, IComposerClient::EX_UNSUPPORTED));
ramindani0291f112021-11-04 03:45:46 +0000735 GTEST_SUCCEED() << "Auto Low Latency Mode is not supported on display "
ramindani431aad42022-02-01 21:44:29 +0000736 << std::to_string(display.getDisplayId()) << ", skipping test";
ramindani0291f112021-11-04 03:45:46 +0000737 return;
738 }
739
ramindani431aad42022-02-01 21:44:29 +0000740 EXPECT_TRUE(mComposerClient->setAutoLowLatencyMode(display.getDisplayId(), true).isOk());
741 EXPECT_TRUE(mComposerClient->setAutoLowLatencyMode(display.getDisplayId(), false).isOk());
ramindani0291f112021-11-04 03:45:46 +0000742 }
743}
744
ramindani431aad42022-02-01 21:44:29 +0000745TEST_P(GraphicsComposerAidlTest, GetSupportedContentTypes_BadDisplay) {
746 const auto& [status, _] = mComposerClient->getSupportedContentTypes(getInvalidDisplayId());
747
748 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000749 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani0291f112021-11-04 03:45:46 +0000750}
751
ramindani431aad42022-02-01 21:44:29 +0000752TEST_P(GraphicsComposerAidlTest, GetSupportedContentTypes) {
ramindani0291f112021-11-04 03:45:46 +0000753 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000754 const auto& [status, supportedContentTypes] =
755 mComposerClient->getSupportedContentTypes(display.getDisplayId());
756 ASSERT_TRUE(status.isOk());
ramindani0291f112021-11-04 03:45:46 +0000757
758 const bool noneSupported =
759 std::find(supportedContentTypes.begin(), supportedContentTypes.end(),
760 ContentType::NONE) != supportedContentTypes.end();
ramindani431aad42022-02-01 21:44:29 +0000761
ramindani0291f112021-11-04 03:45:46 +0000762 EXPECT_FALSE(noneSupported);
763 }
764}
765
ramindani431aad42022-02-01 21:44:29 +0000766TEST_P(GraphicsComposerAidlTest, SetContentTypeNoneAlwaysAccepted) {
ramindani0291f112021-11-04 03:45:46 +0000767 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000768 EXPECT_TRUE(
769 mComposerClient->setContentType(display.getDisplayId(), ContentType::NONE).isOk());
ramindani0291f112021-11-04 03:45:46 +0000770 }
771}
772
ramindani431aad42022-02-01 21:44:29 +0000773TEST_P(GraphicsComposerAidlTest, SetContentType_BadDisplay) {
ramindani0291f112021-11-04 03:45:46 +0000774 constexpr ContentType types[] = {ContentType::NONE, ContentType::GRAPHICS, ContentType::PHOTO,
775 ContentType::CINEMA, ContentType::GAME};
776 for (const auto& type : types) {
ramindani431aad42022-02-01 21:44:29 +0000777 const auto& status = mComposerClient->setContentType(getInvalidDisplayId(), type);
ramindani0291f112021-11-04 03:45:46 +0000778
ramindani431aad42022-02-01 21:44:29 +0000779 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000780 EXPECT_NO_FATAL_FAILURE(
781 assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani0291f112021-11-04 03:45:46 +0000782 }
783}
784
ramindani431aad42022-02-01 21:44:29 +0000785TEST_P(GraphicsComposerAidlTest, SetGraphicsContentType) {
ramindani0291f112021-11-04 03:45:46 +0000786 Test_setContentType(ContentType::GRAPHICS, "GRAPHICS");
787}
788
ramindani431aad42022-02-01 21:44:29 +0000789TEST_P(GraphicsComposerAidlTest, SetPhotoContentType) {
ramindani0291f112021-11-04 03:45:46 +0000790 Test_setContentType(ContentType::PHOTO, "PHOTO");
791}
792
ramindani431aad42022-02-01 21:44:29 +0000793TEST_P(GraphicsComposerAidlTest, SetCinemaContentType) {
ramindani0291f112021-11-04 03:45:46 +0000794 Test_setContentType(ContentType::CINEMA, "CINEMA");
795}
796
ramindani431aad42022-02-01 21:44:29 +0000797TEST_P(GraphicsComposerAidlTest, SetGameContentType) {
ramindani0291f112021-11-04 03:45:46 +0000798 Test_setContentType(ContentType::GAME, "GAME");
799}
800
ramindanic2b8d082021-11-06 02:03:50 +0000801TEST_P(GraphicsComposerAidlTest, CreateVirtualDisplay) {
ramindani431aad42022-02-01 21:44:29 +0000802 const auto& [status, maxVirtualDisplayCount] = mComposerClient->getMaxVirtualDisplayCount();
803 EXPECT_TRUE(status.isOk());
804
ramindanic2b8d082021-11-06 02:03:50 +0000805 if (maxVirtualDisplayCount == 0) {
806 GTEST_SUCCEED() << "no virtual display support";
807 return;
808 }
809
ramindani431aad42022-02-01 21:44:29 +0000810 const auto& [virtualDisplayStatus, virtualDisplay] = mComposerClient->createVirtualDisplay(
811 /*width*/ 64, /*height*/ 64, common::PixelFormat::IMPLEMENTATION_DEFINED,
812 kBufferSlotCount);
ramindanic2b8d082021-11-06 02:03:50 +0000813
ramindani431aad42022-02-01 21:44:29 +0000814 ASSERT_TRUE(virtualDisplayStatus.isOk());
ramindanic2b8d082021-11-06 02:03:50 +0000815 EXPECT_TRUE(mComposerClient->destroyVirtualDisplay(virtualDisplay.display).isOk());
816}
817
ramindani431aad42022-02-01 21:44:29 +0000818TEST_P(GraphicsComposerAidlTest, DestroyVirtualDisplay_BadDisplay) {
819 const auto& [status, maxDisplayCount] = mComposerClient->getMaxVirtualDisplayCount();
820 EXPECT_TRUE(status.isOk());
821
ramindani2740bac2021-11-24 22:58:32 +0000822 if (maxDisplayCount == 0) {
823 GTEST_SUCCEED() << "no virtual display support";
824 return;
825 }
ramindani2740bac2021-11-24 22:58:32 +0000826
ramindani431aad42022-02-01 21:44:29 +0000827 const auto& destroyStatus = mComposerClient->destroyVirtualDisplay(getInvalidDisplayId());
828
829 EXPECT_FALSE(destroyStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000830 EXPECT_NO_FATAL_FAILURE(
831 assertServiceSpecificError(destroyStatus, IComposerClient::EX_BAD_DISPLAY));
ramindani2740bac2021-11-24 22:58:32 +0000832}
833
834TEST_P(GraphicsComposerAidlTest, CreateLayer) {
Ady Abrahama00d2462023-12-26 14:21:20 -0800835 if (hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
836 GTEST_SKIP() << "Create layer will be tested in GraphicsComposerAidlBatchedCommandTest";
837 return;
838 }
839
ramindani431aad42022-02-01 21:44:29 +0000840 const auto& [status, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -0800841 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, nullptr);
ramindani2740bac2021-11-24 22:58:32 +0000842
ramindani431aad42022-02-01 21:44:29 +0000843 EXPECT_TRUE(status.isOk());
Ady Abrahama00d2462023-12-26 14:21:20 -0800844 EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer, nullptr).isOk());
ramindani2740bac2021-11-24 22:58:32 +0000845}
846
ramindani431aad42022-02-01 21:44:29 +0000847TEST_P(GraphicsComposerAidlTest, CreateLayer_BadDisplay) {
Ady Abrahama00d2462023-12-26 14:21:20 -0800848 if (hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
849 GTEST_SKIP() << "Create layer will be tested in GraphicsComposerAidlBatchedCommandTest";
850 return;
851 }
852
853 const auto& [status, _] =
854 mComposerClient->createLayer(getInvalidDisplayId(), kBufferSlotCount, nullptr);
ramindani2740bac2021-11-24 22:58:32 +0000855
ramindani431aad42022-02-01 21:44:29 +0000856 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000857 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani2740bac2021-11-24 22:58:32 +0000858}
859
ramindani431aad42022-02-01 21:44:29 +0000860TEST_P(GraphicsComposerAidlTest, DestroyLayer_BadDisplay) {
Ady Abrahama00d2462023-12-26 14:21:20 -0800861 if (hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
862 GTEST_SKIP() << "Destroy layer will be tested in GraphicsComposerAidlBatchedCommandTest";
863 return;
864 }
865
ramindani431aad42022-02-01 21:44:29 +0000866 const auto& [status, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -0800867 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, nullptr);
ramindani431aad42022-02-01 21:44:29 +0000868 EXPECT_TRUE(status.isOk());
ramindani2740bac2021-11-24 22:58:32 +0000869
Ady Abrahama00d2462023-12-26 14:21:20 -0800870 const auto& destroyStatus =
871 mComposerClient->destroyLayer(getInvalidDisplayId(), layer, nullptr);
ramindani2740bac2021-11-24 22:58:32 +0000872
ramindani431aad42022-02-01 21:44:29 +0000873 EXPECT_FALSE(destroyStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000874 EXPECT_NO_FATAL_FAILURE(
875 assertServiceSpecificError(destroyStatus, IComposerClient::EX_BAD_DISPLAY));
Ady Abrahama00d2462023-12-26 14:21:20 -0800876 ASSERT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer, nullptr).isOk());
ramindani2740bac2021-11-24 22:58:32 +0000877}
878
ramindani431aad42022-02-01 21:44:29 +0000879TEST_P(GraphicsComposerAidlTest, DestroyLayer_BadLayerError) {
Ady Abrahama00d2462023-12-26 14:21:20 -0800880 if (hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
881 GTEST_SKIP() << "Destroy layer will be tested in GraphicsComposerAidlBatchedCommandTest";
882 return;
883 }
884
ramindani2740bac2021-11-24 22:58:32 +0000885 // We haven't created any layers yet, so any id should be invalid
Ady Abrahama00d2462023-12-26 14:21:20 -0800886 const auto& status = mComposerClient->destroyLayer(getPrimaryDisplayId(), /*layer*/ 1, nullptr);
ramindani2740bac2021-11-24 22:58:32 +0000887
ramindani431aad42022-02-01 21:44:29 +0000888 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000889 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_LAYER));
ramindani2740bac2021-11-24 22:58:32 +0000890}
891
ramindani431aad42022-02-01 21:44:29 +0000892TEST_P(GraphicsComposerAidlTest, GetActiveConfig_BadDisplay) {
893 const auto& [status, _] = mComposerClient->getActiveConfig(getInvalidDisplayId());
ramindani2740bac2021-11-24 22:58:32 +0000894
ramindani431aad42022-02-01 21:44:29 +0000895 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000896 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani2740bac2021-11-24 22:58:32 +0000897}
898
899TEST_P(GraphicsComposerAidlTest, GetDisplayConfig) {
ramindani431aad42022-02-01 21:44:29 +0000900 const auto& [status, _] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
901 EXPECT_TRUE(status.isOk());
ramindani2740bac2021-11-24 22:58:32 +0000902}
903
ramindani431aad42022-02-01 21:44:29 +0000904TEST_P(GraphicsComposerAidlTest, GetDisplayConfig_BadDisplay) {
905 const auto& [status, _] = mComposerClient->getDisplayConfigs(getInvalidDisplayId());
ramindani2740bac2021-11-24 22:58:32 +0000906
ramindani431aad42022-02-01 21:44:29 +0000907 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000908 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani2740bac2021-11-24 22:58:32 +0000909}
910
911TEST_P(GraphicsComposerAidlTest, GetDisplayName) {
ramindani431aad42022-02-01 21:44:29 +0000912 const auto& [status, _] = mComposerClient->getDisplayName(getPrimaryDisplayId());
913 EXPECT_TRUE(status.isOk());
ramindani2740bac2021-11-24 22:58:32 +0000914}
915
ramindani431aad42022-02-01 21:44:29 +0000916TEST_P(GraphicsComposerAidlTest, GetDisplayPhysicalOrientation_BadDisplay) {
917 const auto& [status, _] = mComposerClient->getDisplayPhysicalOrientation(getInvalidDisplayId());
Ady Abrahamae12e382022-01-13 18:06:21 -0800918
ramindani431aad42022-02-01 21:44:29 +0000919 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000920 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
Ady Abrahamae12e382022-01-13 18:06:21 -0800921}
922
923TEST_P(GraphicsComposerAidlTest, GetDisplayPhysicalOrientation) {
924 const auto allowedDisplayOrientations = std::array<Transform, 4>{
925 Transform::NONE,
926 Transform::ROT_90,
927 Transform::ROT_180,
928 Transform::ROT_270,
929 };
930
ramindani431aad42022-02-01 21:44:29 +0000931 const auto& [status, displayOrientation] =
932 mComposerClient->getDisplayPhysicalOrientation(getPrimaryDisplayId());
Ady Abrahamae12e382022-01-13 18:06:21 -0800933
ramindani431aad42022-02-01 21:44:29 +0000934 EXPECT_TRUE(status.isOk());
Ady Abrahamae12e382022-01-13 18:06:21 -0800935 EXPECT_NE(std::find(allowedDisplayOrientations.begin(), allowedDisplayOrientations.end(),
936 displayOrientation),
937 allowedDisplayOrientations.end());
938}
939
ramindani2740bac2021-11-24 22:58:32 +0000940TEST_P(GraphicsComposerAidlTest, SetClientTargetSlotCount) {
ramindani431aad42022-02-01 21:44:29 +0000941 EXPECT_TRUE(mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kBufferSlotCount)
942 .isOk());
ramindani2740bac2021-11-24 22:58:32 +0000943}
944
945TEST_P(GraphicsComposerAidlTest, SetActiveConfig) {
ramindani431aad42022-02-01 21:44:29 +0000946 const auto& [status, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
947 EXPECT_TRUE(status.isOk());
948
949 for (const auto& config : configs) {
950 auto display = getEditablePrimaryDisplay();
951 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config).isOk());
952 const auto& [configStatus, config1] =
953 mComposerClient->getActiveConfig(getPrimaryDisplayId());
954 EXPECT_TRUE(configStatus.isOk());
ramindani2740bac2021-11-24 22:58:32 +0000955 EXPECT_EQ(config, config1);
956 }
957}
958
959TEST_P(GraphicsComposerAidlTest, SetActiveConfigPowerCycle) {
ramindani431aad42022-02-01 21:44:29 +0000960 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
961 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
ramindani2740bac2021-11-24 22:58:32 +0000962
ramindani431aad42022-02-01 21:44:29 +0000963 const auto& [status, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
964 EXPECT_TRUE(status.isOk());
965
966 for (const auto& config : configs) {
967 auto display = getEditablePrimaryDisplay();
968 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config).isOk());
969 const auto& [config1Status, config1] =
970 mComposerClient->getActiveConfig(getPrimaryDisplayId());
971 EXPECT_TRUE(config1Status.isOk());
ramindani2740bac2021-11-24 22:58:32 +0000972 EXPECT_EQ(config, config1);
973
ramindani431aad42022-02-01 21:44:29 +0000974 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
975 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
976 const auto& [config2Status, config2] =
977 mComposerClient->getActiveConfig(getPrimaryDisplayId());
978 EXPECT_TRUE(config2Status.isOk());
979 EXPECT_EQ(config, config2);
ramindani2740bac2021-11-24 22:58:32 +0000980 }
981}
982
ramindani2740bac2021-11-24 22:58:32 +0000983TEST_P(GraphicsComposerAidlTest, SetPowerModeUnsupported) {
ramindani431aad42022-02-01 21:44:29 +0000984 const auto& [status, capabilities] =
985 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
986 ASSERT_TRUE(status.isOk());
987
Ady Abraham6679baf2021-12-08 18:28:27 -0800988 const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
989 DisplayCapability::DOZE) != capabilities.end();
990 const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
991 DisplayCapability::SUSPEND) != capabilities.end();
ramindani2740bac2021-11-24 22:58:32 +0000992
ramindani431aad42022-02-01 21:44:29 +0000993 if (!isDozeSupported) {
994 const auto& powerModeDozeStatus =
995 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE);
996 EXPECT_FALSE(powerModeDozeStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000997 EXPECT_NO_FATAL_FAILURE(
998 assertServiceSpecificError(powerModeDozeStatus, IComposerClient::EX_UNSUPPORTED));
ramindani431aad42022-02-01 21:44:29 +0000999
1000 const auto& powerModeDozeSuspendStatus =
1001 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE_SUSPEND);
1002 EXPECT_FALSE(powerModeDozeSuspendStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +00001003 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeDozeSuspendStatus,
1004 IComposerClient::EX_UNSUPPORTED));
ramindani2740bac2021-11-24 22:58:32 +00001005 }
Ady Abraham6679baf2021-12-08 18:28:27 -08001006
1007 if (!isSuspendSupported) {
ramindani431aad42022-02-01 21:44:29 +00001008 const auto& powerModeSuspendStatus =
1009 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON_SUSPEND);
1010 EXPECT_FALSE(powerModeSuspendStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +00001011 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeSuspendStatus,
1012 IComposerClient::EX_UNSUPPORTED));
Ady Abraham6679baf2021-12-08 18:28:27 -08001013
ramindani431aad42022-02-01 21:44:29 +00001014 const auto& powerModeDozeSuspendStatus =
1015 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE_SUSPEND);
1016 EXPECT_FALSE(powerModeDozeSuspendStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +00001017 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeDozeSuspendStatus,
1018 IComposerClient::EX_UNSUPPORTED));
Ady Abraham6679baf2021-12-08 18:28:27 -08001019 }
ramindani2740bac2021-11-24 22:58:32 +00001020}
1021
1022TEST_P(GraphicsComposerAidlTest, SetVsyncEnabled) {
ramindani431aad42022-02-01 21:44:29 +00001023 mComposerClient->setVsyncAllowed(true);
ramindani2740bac2021-11-24 22:58:32 +00001024
ramindani431aad42022-02-01 21:44:29 +00001025 EXPECT_TRUE(mComposerClient->setVsync(getPrimaryDisplayId(), true).isOk());
ramindani2740bac2021-11-24 22:58:32 +00001026 usleep(60 * 1000);
ramindani431aad42022-02-01 21:44:29 +00001027 EXPECT_TRUE(mComposerClient->setVsync(getPrimaryDisplayId(), false).isOk());
ramindani2740bac2021-11-24 22:58:32 +00001028
ramindani431aad42022-02-01 21:44:29 +00001029 mComposerClient->setVsyncAllowed(false);
ramindani2740bac2021-11-24 22:58:32 +00001030}
1031
ramindanic2b8d082021-11-06 02:03:50 +00001032TEST_P(GraphicsComposerAidlTest, SetPowerMode) {
ramindani431aad42022-02-01 21:44:29 +00001033 const auto& [status, capabilities] =
1034 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
1035 ASSERT_TRUE(status.isOk());
1036
Ady Abraham6679baf2021-12-08 18:28:27 -08001037 const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
1038 DisplayCapability::DOZE) != capabilities.end();
1039 const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
1040 DisplayCapability::SUSPEND) != capabilities.end();
1041
ramindanic2b8d082021-11-06 02:03:50 +00001042 std::vector<PowerMode> modes;
1043 modes.push_back(PowerMode::OFF);
ramindanic2b8d082021-11-06 02:03:50 +00001044 modes.push_back(PowerMode::ON);
1045
Ady Abraham6679baf2021-12-08 18:28:27 -08001046 if (isSuspendSupported) {
1047 modes.push_back(PowerMode::ON_SUSPEND);
1048 }
1049
ramindani770d7082021-11-30 00:36:42 +00001050 if (isDozeSupported) {
1051 modes.push_back(PowerMode::DOZE);
Ady Abraham6679baf2021-12-08 18:28:27 -08001052 }
1053
1054 if (isSuspendSupported && isDozeSupported) {
ramindani770d7082021-11-30 00:36:42 +00001055 modes.push_back(PowerMode::DOZE_SUSPEND);
1056 }
1057
ramindanic2b8d082021-11-06 02:03:50 +00001058 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001059 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindanic2b8d082021-11-06 02:03:50 +00001060 }
1061}
1062
1063TEST_P(GraphicsComposerAidlTest, SetPowerModeVariations) {
ramindani431aad42022-02-01 21:44:29 +00001064 const auto& [status, capabilities] =
1065 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
1066 ASSERT_TRUE(status.isOk());
1067
Ady Abraham6679baf2021-12-08 18:28:27 -08001068 const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
1069 DisplayCapability::DOZE) != capabilities.end();
1070 const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
1071 DisplayCapability::SUSPEND) != capabilities.end();
1072
ramindanic2b8d082021-11-06 02:03:50 +00001073 std::vector<PowerMode> modes;
1074
1075 modes.push_back(PowerMode::OFF);
ramindani770d7082021-11-30 00:36:42 +00001076 modes.push_back(PowerMode::ON);
ramindanic2b8d082021-11-06 02:03:50 +00001077 modes.push_back(PowerMode::OFF);
ramindanic2b8d082021-11-06 02:03:50 +00001078 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001079 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindanic2b8d082021-11-06 02:03:50 +00001080 }
ramindani770d7082021-11-30 00:36:42 +00001081 modes.clear();
ramindanic2b8d082021-11-06 02:03:50 +00001082
ramindani770d7082021-11-30 00:36:42 +00001083 modes.push_back(PowerMode::OFF);
1084 modes.push_back(PowerMode::OFF);
1085 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001086 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindani770d7082021-11-30 00:36:42 +00001087 }
ramindanic2b8d082021-11-06 02:03:50 +00001088 modes.clear();
1089
1090 modes.push_back(PowerMode::ON);
1091 modes.push_back(PowerMode::ON);
ramindanic2b8d082021-11-06 02:03:50 +00001092 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001093 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindanic2b8d082021-11-06 02:03:50 +00001094 }
ramindanic2b8d082021-11-06 02:03:50 +00001095 modes.clear();
1096
Ady Abraham6679baf2021-12-08 18:28:27 -08001097 if (isSuspendSupported) {
1098 modes.push_back(PowerMode::ON_SUSPEND);
1099 modes.push_back(PowerMode::ON_SUSPEND);
1100 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001101 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
Ady Abraham6679baf2021-12-08 18:28:27 -08001102 }
1103 modes.clear();
ramindanic2b8d082021-11-06 02:03:50 +00001104 }
1105
ramindanic2b8d082021-11-06 02:03:50 +00001106 if (isDozeSupported) {
ramindanic2b8d082021-11-06 02:03:50 +00001107 modes.push_back(PowerMode::DOZE);
1108 modes.push_back(PowerMode::DOZE);
ramindanic2b8d082021-11-06 02:03:50 +00001109 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001110 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindanic2b8d082021-11-06 02:03:50 +00001111 }
ramindanic2b8d082021-11-06 02:03:50 +00001112 modes.clear();
Ady Abraham6679baf2021-12-08 18:28:27 -08001113 }
ramindanic2b8d082021-11-06 02:03:50 +00001114
Ady Abraham6679baf2021-12-08 18:28:27 -08001115 if (isSuspendSupported && isDozeSupported) {
ramindanic2b8d082021-11-06 02:03:50 +00001116 modes.push_back(PowerMode::DOZE_SUSPEND);
1117 modes.push_back(PowerMode::DOZE_SUSPEND);
ramindanic2b8d082021-11-06 02:03:50 +00001118 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001119 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindanic2b8d082021-11-06 02:03:50 +00001120 }
Ady Abraham6679baf2021-12-08 18:28:27 -08001121 modes.clear();
ramindanic2b8d082021-11-06 02:03:50 +00001122 }
1123}
1124
ramindani431aad42022-02-01 21:44:29 +00001125TEST_P(GraphicsComposerAidlTest, SetPowerMode_BadDisplay) {
1126 const auto& status = mComposerClient->setPowerMode(getInvalidDisplayId(), PowerMode::ON);
ramindanic2b8d082021-11-06 02:03:50 +00001127
ramindani431aad42022-02-01 21:44:29 +00001128 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00001129 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindanic2b8d082021-11-06 02:03:50 +00001130}
1131
ramindani431aad42022-02-01 21:44:29 +00001132TEST_P(GraphicsComposerAidlTest, SetPowerMode_BadParameter) {
1133 const auto& status =
1134 mComposerClient->setPowerMode(getPrimaryDisplayId(), static_cast<PowerMode>(-1));
ramindanic2b8d082021-11-06 02:03:50 +00001135
ramindani431aad42022-02-01 21:44:29 +00001136 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00001137 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
ramindanic2b8d082021-11-06 02:03:50 +00001138}
1139
ramindanic2b8d082021-11-06 02:03:50 +00001140TEST_P(GraphicsComposerAidlTest, GetDataspaceSaturationMatrix) {
ramindani431aad42022-02-01 21:44:29 +00001141 const auto& [status, matrix] =
1142 mComposerClient->getDataspaceSaturationMatrix(common::Dataspace::SRGB_LINEAR);
1143 ASSERT_TRUE(status.isOk());
1144 ASSERT_EQ(16, matrix.size()); // matrix should not be empty if call succeeded.
ramindanideb059e2021-11-18 01:57:25 +00001145
ramindanic2b8d082021-11-06 02:03:50 +00001146 // the last row is known
ramindani431aad42022-02-01 21:44:29 +00001147 EXPECT_EQ(0.0f, matrix[12]);
1148 EXPECT_EQ(0.0f, matrix[13]);
1149 EXPECT_EQ(0.0f, matrix[14]);
1150 EXPECT_EQ(1.0f, matrix[15]);
ramindanic2b8d082021-11-06 02:03:50 +00001151}
1152
ramindani431aad42022-02-01 21:44:29 +00001153TEST_P(GraphicsComposerAidlTest, GetDataspaceSaturationMatrix_BadParameter) {
1154 const auto& [status, matrix] =
1155 mComposerClient->getDataspaceSaturationMatrix(common::Dataspace::UNKNOWN);
ramindanic2b8d082021-11-06 02:03:50 +00001156
ramindani431aad42022-02-01 21:44:29 +00001157 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00001158 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
ramindanic2b8d082021-11-06 02:03:50 +00001159}
1160
ramindani12423f52023-06-14 20:04:51 -07001161/*
1162 * Test that no two display configs are exactly the same.
1163 */
1164TEST_P(GraphicsComposerAidlTest, GetDisplayConfigNoRepetitions) {
1165 for (const auto& display : mDisplays) {
1166 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
1167 for (std::vector<int>::size_type i = 0; i < configs.size(); i++) {
1168 for (std::vector<int>::size_type j = i + 1; j < configs.size(); j++) {
1169 const auto& [widthStatus1, width1] = mComposerClient->getDisplayAttribute(
1170 display.getDisplayId(), configs[i], DisplayAttribute::WIDTH);
1171 const auto& [heightStatus1, height1] = mComposerClient->getDisplayAttribute(
1172 display.getDisplayId(), configs[i], DisplayAttribute::HEIGHT);
1173 const auto& [vsyncPeriodStatus1, vsyncPeriod1] =
1174 mComposerClient->getDisplayAttribute(display.getDisplayId(), configs[i],
1175 DisplayAttribute::VSYNC_PERIOD);
1176 const auto& [groupStatus1, group1] = mComposerClient->getDisplayAttribute(
1177 display.getDisplayId(), configs[i], DisplayAttribute::CONFIG_GROUP);
1178
1179 const auto& [widthStatus2, width2] = mComposerClient->getDisplayAttribute(
1180 display.getDisplayId(), configs[j], DisplayAttribute::WIDTH);
1181 const auto& [heightStatus2, height2] = mComposerClient->getDisplayAttribute(
1182 display.getDisplayId(), configs[j], DisplayAttribute::HEIGHT);
1183 const auto& [vsyncPeriodStatus2, vsyncPeriod2] =
1184 mComposerClient->getDisplayAttribute(display.getDisplayId(), configs[j],
1185 DisplayAttribute::VSYNC_PERIOD);
1186 const auto& [groupStatus2, group2] = mComposerClient->getDisplayAttribute(
1187 display.getDisplayId(), configs[j], DisplayAttribute::CONFIG_GROUP);
1188
1189 ASSERT_FALSE(width1 == width2 && height1 == height2 &&
1190 vsyncPeriod1 == vsyncPeriod2 && group1 == group2);
1191 }
1192 }
1193 }
1194}
1195
Ady Abrahama00d2462023-12-26 14:21:20 -08001196TEST_P(GraphicsComposerAidlTest, LayerLifecycleCapabilityNotSupportedOnOldVersions) {
1197 if (hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
1198 EXPECT_GE(getInterfaceVersion(), 3);
1199 }
1200}
1201
ramindani12423f52023-06-14 20:04:51 -07001202class GraphicsComposerAidlV2Test : public GraphicsComposerAidlTest {
1203 protected:
1204 void SetUp() override {
1205 GraphicsComposerAidlTest::SetUp();
1206 if (getInterfaceVersion() <= 1) {
1207 GTEST_SKIP() << "Device interface version is expected to be >= 2";
1208 }
1209 }
1210};
1211
1212TEST_P(GraphicsComposerAidlV2Test, GetOverlaySupport) {
1213 const auto& [status, properties] = mComposerClient->getOverlaySupport();
1214 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
1215 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
1216 GTEST_SUCCEED() << "getOverlaySupport is not supported";
1217 return;
1218 }
1219
1220 ASSERT_TRUE(status.isOk());
1221 for (const auto& i : properties.combinations) {
1222 for (const auto standard : i.standards) {
1223 const auto val = static_cast<int32_t>(standard) &
1224 static_cast<int32_t>(common::Dataspace::STANDARD_MASK);
1225 ASSERT_TRUE(val == static_cast<int32_t>(standard));
1226 }
1227 for (const auto transfer : i.transfers) {
1228 const auto val = static_cast<int32_t>(transfer) &
1229 static_cast<int32_t>(common::Dataspace::TRANSFER_MASK);
1230 ASSERT_TRUE(val == static_cast<int32_t>(transfer));
1231 }
1232 for (const auto range : i.ranges) {
1233 const auto val = static_cast<int32_t>(range) &
1234 static_cast<int32_t>(common::Dataspace::RANGE_MASK);
1235 ASSERT_TRUE(val == static_cast<int32_t>(range));
1236 }
1237 }
1238}
1239
ramindani02fe4772023-06-30 18:04:41 -07001240class GraphicsComposerAidlV3Test : public GraphicsComposerAidlTest {
1241 protected:
1242 void SetUp() override {
1243 GraphicsComposerAidlTest::SetUp();
1244 if (getInterfaceVersion() <= 2) {
1245 GTEST_SKIP() << "Device interface version is expected to be >= 3";
1246 }
1247 }
1248};
1249
1250TEST_P(GraphicsComposerAidlV3Test, GetDisplayConfigurations) {
1251 for (const auto& display : mDisplays) {
1252 const auto& [status, displayConfigurations] =
1253 mComposerClient->getDisplayConfigurations(display.getDisplayId());
1254 EXPECT_TRUE(status.isOk());
1255 EXPECT_FALSE(displayConfigurations.empty());
1256
1257 for (const auto& displayConfig : displayConfigurations) {
1258 EXPECT_NE(-1, displayConfig.width);
1259 EXPECT_NE(-1, displayConfig.height);
1260 EXPECT_NE(-1, displayConfig.vsyncPeriod);
1261 EXPECT_NE(-1, displayConfig.configGroup);
1262 if (displayConfig.dpi) {
ramindani2b2ec502023-08-25 18:47:38 -07001263 EXPECT_NE(-1.f, displayConfig.dpi->x);
1264 EXPECT_NE(-1.f, displayConfig.dpi->y);
ramindani02fe4772023-06-30 18:04:41 -07001265 }
ramindani2704c5f2023-07-18 20:53:24 -07001266 if (displayConfig.vrrConfig) {
1267 const auto& vrrConfig = *displayConfig.vrrConfig;
1268 EXPECT_GE(vrrConfig.minFrameIntervalNs, displayConfig.vsyncPeriod);
1269
ramindani2b2ec502023-08-25 18:47:38 -07001270 EXPECT_EQ(1, std::count_if(
1271 displayConfigurations.cbegin(), displayConfigurations.cend(),
1272 [displayConfig](const auto& config) {
1273 return config.configGroup == displayConfig.configGroup;
1274 }))
1275 << "There should be only one VRR mode in one ConfigGroup";
1276
ramindani2704c5f2023-07-18 20:53:24 -07001277 const auto verifyFrameIntervalIsDivisorOfVsync = [&](int32_t frameIntervalNs) {
1278 constexpr auto kThreshold = 0.05f; // 5%
1279 const auto ratio =
1280 static_cast<float>(frameIntervalNs) / displayConfig.vsyncPeriod;
1281 return ratio - std::round(ratio) <= kThreshold;
1282 };
1283
1284 EXPECT_TRUE(verifyFrameIntervalIsDivisorOfVsync(vrrConfig.minFrameIntervalNs));
1285
1286 if (vrrConfig.frameIntervalPowerHints) {
1287 const auto& frameIntervalPowerHints = *vrrConfig.frameIntervalPowerHints;
1288 EXPECT_FALSE(frameIntervalPowerHints.empty());
1289
1290 const auto minFrameInterval = *min_element(frameIntervalPowerHints.cbegin(),
1291 frameIntervalPowerHints.cend());
1292 EXPECT_LE(minFrameInterval->frameIntervalNs,
1293 VtsComposerClient::kMaxFrameIntervalNs);
1294
1295 EXPECT_TRUE(std::all_of(frameIntervalPowerHints.cbegin(),
1296 frameIntervalPowerHints.cend(),
1297 [&](const auto& frameIntervalPowerHint) {
1298 return verifyFrameIntervalIsDivisorOfVsync(
1299 frameIntervalPowerHint->frameIntervalNs);
1300 }));
1301 }
1302
1303 if (vrrConfig.notifyExpectedPresentConfig) {
1304 const auto& notifyExpectedPresentConfig =
1305 *vrrConfig.notifyExpectedPresentConfig;
ramindani52416e02023-12-19 16:03:14 -08001306 EXPECT_GE(notifyExpectedPresentConfig.headsUpNs, 0);
1307 EXPECT_GE(notifyExpectedPresentConfig.timeoutNs, 0);
ramindani2704c5f2023-07-18 20:53:24 -07001308 }
1309 }
ramindani02fe4772023-06-30 18:04:41 -07001310 }
1311 }
1312}
1313
1314TEST_P(GraphicsComposerAidlV3Test, GetDisplayConfigsIsSubsetOfGetDisplayConfigurations) {
1315 for (const auto& display : mDisplays) {
1316 const auto& [status, displayConfigurations] =
1317 mComposerClient->getDisplayConfigurations(display.getDisplayId());
1318 EXPECT_TRUE(status.isOk());
1319
1320 const auto& [legacyConfigStatus, legacyConfigs] =
1321 mComposerClient->getDisplayConfigs(display.getDisplayId());
1322 EXPECT_TRUE(legacyConfigStatus.isOk());
1323 EXPECT_FALSE(legacyConfigs.empty());
1324 EXPECT_TRUE(legacyConfigs.size() <= displayConfigurations.size());
1325
1326 for (const auto legacyConfigId : legacyConfigs) {
1327 const auto& legacyWidth = mComposerClient->getDisplayAttribute(
1328 display.getDisplayId(), legacyConfigId, DisplayAttribute::WIDTH);
1329 const auto& legacyHeight = mComposerClient->getDisplayAttribute(
1330 display.getDisplayId(), legacyConfigId, DisplayAttribute::HEIGHT);
1331 const auto& legacyVsyncPeriod = mComposerClient->getDisplayAttribute(
1332 display.getDisplayId(), legacyConfigId, DisplayAttribute::VSYNC_PERIOD);
1333 const auto& legacyConfigGroup = mComposerClient->getDisplayAttribute(
1334 display.getDisplayId(), legacyConfigId, DisplayAttribute::CONFIG_GROUP);
1335 const auto& legacyDpiX = mComposerClient->getDisplayAttribute(
1336 display.getDisplayId(), legacyConfigId, DisplayAttribute::DPI_X);
1337 const auto& legacyDpiY = mComposerClient->getDisplayAttribute(
1338 display.getDisplayId(), legacyConfigId, DisplayAttribute::DPI_Y);
1339
1340 EXPECT_TRUE(legacyWidth.first.isOk() && legacyHeight.first.isOk() &&
1341 legacyVsyncPeriod.first.isOk() && legacyConfigGroup.first.isOk());
1342
1343 EXPECT_TRUE(std::any_of(
1344 displayConfigurations.begin(), displayConfigurations.end(),
1345 [&](const auto& displayConfiguration) {
1346 const bool requiredAttributesPredicate =
1347 displayConfiguration.configId == legacyConfigId &&
1348 displayConfiguration.width == legacyWidth.second &&
1349 displayConfiguration.height == legacyHeight.second &&
1350 displayConfiguration.vsyncPeriod == legacyVsyncPeriod.second &&
1351 displayConfiguration.configGroup == legacyConfigGroup.second;
1352
1353 if (!requiredAttributesPredicate) {
1354 // Required attributes did not match
1355 return false;
1356 }
1357
1358 // Check optional attributes
1359 const auto& [legacyDpiXStatus, legacyDpiXValue] = legacyDpiX;
1360 const auto& [legacyDpiYStatus, legacyDpiYValue] = legacyDpiY;
1361 if (displayConfiguration.dpi) {
1362 if (!legacyDpiXStatus.isOk() || !legacyDpiYStatus.isOk()) {
1363 // getDisplayAttribute failed for optional attributes
1364 return false;
1365 }
1366
1367 // DPI values in DisplayConfigurations are not scaled (* 1000.f)
1368 // the way they are in the legacy DisplayConfigs.
1369 constexpr float kEpsilon = 0.001f;
1370 return std::abs(displayConfiguration.dpi->x -
1371 legacyDpiXValue / 1000.f) < kEpsilon &&
1372 std::abs(displayConfiguration.dpi->y -
1373 legacyDpiYValue / 1000.f) < kEpsilon;
1374 } else {
1375 return !legacyDpiXStatus.isOk() && !legacyDpiYStatus.isOk() &&
1376 EX_SERVICE_SPECIFIC == legacyDpiXStatus.getExceptionCode() &&
1377 EX_SERVICE_SPECIFIC == legacyDpiYStatus.getExceptionCode() &&
1378 IComposerClient::EX_UNSUPPORTED ==
1379 legacyDpiXStatus.getServiceSpecificError() &&
1380 IComposerClient::EX_UNSUPPORTED ==
1381 legacyDpiYStatus.getServiceSpecificError();
1382 }
1383 }));
1384 }
1385 }
1386}
1387
ramindani2704c5f2023-07-18 20:53:24 -07001388// TODO(b/291792736) Add detailed VTS test cases for NotifyExpectedPresent
1389TEST_P(GraphicsComposerAidlV3Test, NotifyExpectedPresent) {
1390 for (const auto& display : mDisplays) {
1391 EXPECT_TRUE(mComposerClient
1392 ->notifyExpectedPresent(display.getDisplayId(),
1393 ClockMonotonicTimestamp{0},
1394 std::chrono::nanoseconds{8ms}.count())
1395 .isOk());
1396 }
1397}
1398
ramindanidcfe3a82021-11-29 17:00:31 +00001399// Tests for Command.
1400class GraphicsComposerAidlCommandTest : public GraphicsComposerAidlTest {
1401 protected:
ramindanidcfe3a82021-11-29 17:00:31 +00001402 void TearDown() override {
Ady Abraham3192f3d2021-12-03 16:08:56 -08001403 const auto errors = mReader.takeErrors();
1404 ASSERT_TRUE(mReader.takeErrors().empty());
ramindani431aad42022-02-01 21:44:29 +00001405 ASSERT_TRUE(mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty());
Ady Abraham3192f3d2021-12-03 16:08:56 -08001406
Ady Abrahama00d2462023-12-26 14:21:20 -08001407 ASSERT_TRUE(mComposerClient->tearDown(&getWriter(getPrimaryDisplayId())));
ramindanidcfe3a82021-11-29 17:00:31 +00001408 ASSERT_NO_FATAL_FAILURE(GraphicsComposerAidlTest::TearDown());
1409 }
1410
1411 void execute() {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001412 std::vector<CommandResultPayload> payloads;
1413 for (auto& [_, writer] : mWriters) {
Joen Chene0a962c2023-08-28 09:49:11 +00001414 executeInternal(writer, payloads);
ramindanidcfe3a82021-11-29 17:00:31 +00001415 }
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001416 mReader.parse(std::move(payloads));
ramindanidcfe3a82021-11-29 17:00:31 +00001417 }
1418
Joen Chene0a962c2023-08-28 09:49:11 +00001419 void execute(ComposerClientWriter& writer, ComposerClientReader& reader) {
1420 std::vector<CommandResultPayload> payloads;
1421 executeInternal(writer, payloads);
1422 reader.parse(std::move(payloads));
1423 }
1424
ramindanidcfe3a82021-11-29 17:00:31 +00001425 static inline auto toTimePoint(nsecs_t time) {
1426 return std::chrono::time_point<std::chrono::steady_clock>(std::chrono::nanoseconds(time));
1427 }
1428
ramindanidcfe3a82021-11-29 17:00:31 +00001429 void forEachTwoConfigs(int64_t display, std::function<void(int32_t, int32_t)> func) {
ramindani431aad42022-02-01 21:44:29 +00001430 const auto& [status, displayConfigs] = mComposerClient->getDisplayConfigs(display);
1431 ASSERT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001432 for (const int32_t config1 : displayConfigs) {
1433 for (const int32_t config2 : displayConfigs) {
1434 if (config1 != config2) {
1435 func(config1, config2);
1436 }
1437 }
1438 }
1439 }
1440
1441 void waitForVsyncPeriodChange(int64_t display, const VsyncPeriodChangeTimeline& timeline,
1442 int64_t desiredTimeNanos, int64_t oldPeriodNanos,
1443 int64_t newPeriodNanos) {
1444 const auto kChangeDeadline = toTimePoint(timeline.newVsyncAppliedTimeNanos) + 100ms;
1445 while (std::chrono::steady_clock::now() <= kChangeDeadline) {
ramindani431aad42022-02-01 21:44:29 +00001446 const auto& [status, vsyncPeriodNanos] =
1447 mComposerClient->getDisplayVsyncPeriod(display);
1448 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001449 if (systemTime() <= desiredTimeNanos) {
1450 EXPECT_EQ(vsyncPeriodNanos, oldPeriodNanos);
1451 } else if (vsyncPeriodNanos == newPeriodNanos) {
1452 break;
1453 }
1454 std::this_thread::sleep_for(std::chrono::nanoseconds(oldPeriodNanos));
1455 }
1456 }
1457
ramindani9dd8c482023-02-21 18:07:56 -08001458 bool checkIfCallbackRefreshRateChangedDebugEnabledReceived(
1459 std::function<bool(RefreshRateChangedDebugData)> filter) {
1460 const auto list = mComposerClient->takeListOfRefreshRateChangedDebugData();
1461 return std::any_of(list.begin(), list.end(), [&](auto refreshRateChangedDebugData) {
1462 return filter(refreshRateChangedDebugData);
1463 });
1464 }
1465
Brian Lindahl25e0d092022-12-09 00:32:11 -07001466 sp<GraphicBuffer> allocate(uint32_t width, uint32_t height,
1467 ::android::PixelFormat pixelFormat) {
Brian Lindahl14bd07b2023-01-17 14:54:39 -07001468 return sp<GraphicBuffer>::make(
Brian Lindahl25e0d092022-12-09 00:32:11 -07001469 width, height, pixelFormat, /*layerCount*/ 1U,
1470 static_cast<uint64_t>(common::BufferUsage::CPU_WRITE_OFTEN) |
1471 static_cast<uint64_t>(common::BufferUsage::CPU_READ_OFTEN) |
1472 static_cast<uint64_t>(common::BufferUsage::COMPOSER_OVERLAY),
Brian Lindahl14bd07b2023-01-17 14:54:39 -07001473 "VtsHalGraphicsComposer3_TargetTest");
Brian Lindahlca3eef22022-12-09 00:32:11 -07001474 }
1475
Brian Lindahl25e0d092022-12-09 00:32:11 -07001476 sp<GraphicBuffer> allocate(::android::PixelFormat pixelFormat) {
1477 return allocate(static_cast<uint32_t>(getPrimaryDisplay().getDisplayWidth()),
1478 static_cast<uint32_t>(getPrimaryDisplay().getDisplayHeight()), pixelFormat);
1479 }
1480
ramindanidcfe3a82021-11-29 17:00:31 +00001481 void sendRefreshFrame(const VtsDisplay& display, const VsyncPeriodChangeTimeline* timeline) {
1482 if (timeline != nullptr) {
1483 // Refresh time should be before newVsyncAppliedTimeNanos
1484 EXPECT_LT(timeline->refreshTimeNanos, timeline->newVsyncAppliedTimeNanos);
1485
1486 std::this_thread::sleep_until(toTimePoint(timeline->refreshTimeNanos));
1487 }
1488
ramindani431aad42022-02-01 21:44:29 +00001489 EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::ON).isOk());
1490 EXPECT_TRUE(mComposerClient
1491 ->setColorMode(display.getDisplayId(), ColorMode::NATIVE,
1492 RenderIntent::COLORIMETRIC)
1493 .isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001494
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001495 auto& writer = getWriter(display.getDisplayId());
Ady Abrahama00d2462023-12-26 14:21:20 -08001496 const auto& [status, layer] =
1497 mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
1498 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001499 {
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001500 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindanidcfe3a82021-11-29 17:00:31 +00001501 ASSERT_NE(nullptr, buffer);
1502 ASSERT_EQ(::android::OK, buffer->initCheck());
1503 ASSERT_NE(nullptr, buffer->handle);
1504
ramindani431aad42022-02-01 21:44:29 +00001505 configureLayer(display, layer, Composition::DEVICE, display.getFrameRect(),
1506 display.getCrop());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001507 writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, buffer->handle,
1508 /*acquireFence*/ -1);
1509 writer.setLayerDataspace(display.getDisplayId(), layer, common::Dataspace::UNKNOWN);
ramindanidcfe3a82021-11-29 17:00:31 +00001510
ramindanicdcfcaf2023-11-09 10:00:10 -08001511 writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp,
1512 VtsComposerClient::kNoFrameIntervalNs);
ramindanidcfe3a82021-11-29 17:00:31 +00001513 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001514 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001515
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001516 writer.presentDisplay(display.getDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001517 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001518 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001519 }
1520
1521 {
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001522 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindanidcfe3a82021-11-29 17:00:31 +00001523 ASSERT_NE(nullptr, buffer->handle);
1524
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001525 writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, buffer->handle,
1526 /*acquireFence*/ -1);
1527 writer.setLayerSurfaceDamage(display.getDisplayId(), layer,
1528 std::vector<Rect>(1, {0, 0, 10, 10}));
ramindanicdcfcaf2023-11-09 10:00:10 -08001529 writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp,
1530 VtsComposerClient::kNoFrameIntervalNs);
ramindanidcfe3a82021-11-29 17:00:31 +00001531 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001532 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001533
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001534 writer.presentDisplay(display.getDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001535 execute();
1536 }
1537
Ady Abrahama00d2462023-12-26 14:21:20 -08001538 EXPECT_TRUE(mComposerClient->destroyLayer(display.getDisplayId(), layer, &writer).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001539 }
1540
Ady Abraham72c5b502021-12-10 17:23:39 -08001541 sp<::android::Fence> presentAndGetFence(
1542 std::optional<ClockMonotonicTimestamp> expectedPresentTime) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001543 auto& writer = getWriter(getPrimaryDisplayId());
ramindanicdcfcaf2023-11-09 10:00:10 -08001544 writer.validateDisplay(getPrimaryDisplayId(), expectedPresentTime,
1545 VtsComposerClient::kNoFrameIntervalNs);
Ady Abraham72c5b502021-12-10 17:23:39 -08001546 execute();
1547 EXPECT_TRUE(mReader.takeErrors().empty());
1548
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001549 writer.presentDisplay(getPrimaryDisplayId());
Ady Abraham72c5b502021-12-10 17:23:39 -08001550 execute();
1551 EXPECT_TRUE(mReader.takeErrors().empty());
1552
ramindani431aad42022-02-01 21:44:29 +00001553 auto presentFence = mReader.takePresentFence(getPrimaryDisplayId());
Ady Abraham46219f52021-12-20 09:44:31 -08001554 // take ownership
1555 const int fenceOwner = presentFence.get();
1556 *presentFence.getR() = -1;
1557 EXPECT_NE(-1, fenceOwner);
1558 return sp<::android::Fence>::make(fenceOwner);
Ady Abraham72c5b502021-12-10 17:23:39 -08001559 }
1560
1561 int32_t getVsyncPeriod() {
ramindani431aad42022-02-01 21:44:29 +00001562 const auto& [status, activeConfig] =
1563 mComposerClient->getActiveConfig(getPrimaryDisplayId());
1564 EXPECT_TRUE(status.isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001565
ramindani431aad42022-02-01 21:44:29 +00001566 const auto& [vsyncPeriodStatus, vsyncPeriod] = mComposerClient->getDisplayAttribute(
1567 getPrimaryDisplayId(), activeConfig, DisplayAttribute::VSYNC_PERIOD);
1568 EXPECT_TRUE(vsyncPeriodStatus.isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001569 return vsyncPeriod;
1570 }
1571
ramindani9dd8c482023-02-21 18:07:56 -08001572 int64_t createOnScreenLayer(Composition composition = Composition::DEVICE) {
Ady Abrahama00d2462023-12-26 14:21:20 -08001573 auto& writer = getWriter(getPrimaryDisplayId());
ramindani431aad42022-02-01 21:44:29 +00001574 const auto& [status, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08001575 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
ramindani431aad42022-02-01 21:44:29 +00001576 EXPECT_TRUE(status.isOk());
1577 Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
1578 getPrimaryDisplay().getDisplayHeight()};
1579 FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
1580 (float)getPrimaryDisplay().getDisplayHeight()};
ramindani9dd8c482023-02-21 18:07:56 -08001581 configureLayer(getPrimaryDisplay(), layer, composition, displayFrame, cropRect);
Ady Abrahama00d2462023-12-26 14:21:20 -08001582
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001583 writer.setLayerDataspace(getPrimaryDisplayId(), layer, common::Dataspace::UNKNOWN);
Ady Abraham72c5b502021-12-10 17:23:39 -08001584 return layer;
1585 }
1586
ramindani9dd8c482023-02-21 18:07:56 -08001587 void sendBufferUpdate(int64_t layer) {
1588 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1589 ASSERT_NE(nullptr, buffer->handle);
1590
1591 auto& writer = getWriter(getPrimaryDisplayId());
1592 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer->handle,
1593 /*acquireFence*/ -1);
1594
1595 const sp<::android::Fence> presentFence =
1596 presentAndGetFence(ComposerClientWriter::kNoTimestamp);
1597 presentFence->waitForever(LOG_TAG);
1598 }
1599
Midas Chiena0b56bd2022-01-13 23:27:33 +08001600 bool hasDisplayCapability(int64_t display, DisplayCapability cap) {
ramindani431aad42022-02-01 21:44:29 +00001601 const auto& [status, capabilities] = mComposerClient->getDisplayCapabilities(display);
1602 EXPECT_TRUE(status.isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08001603
1604 return std::find(capabilities.begin(), capabilities.end(), cap) != capabilities.end();
1605 }
1606
ramindanidcfe3a82021-11-29 17:00:31 +00001607 void Test_setActiveConfigWithConstraints(const TestParameters& params) {
1608 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +00001609 forEachTwoConfigs(display.getDisplayId(), [&](int32_t config1, int32_t config2) {
1610 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001611 sendRefreshFrame(display, nullptr);
1612
ramindani431aad42022-02-01 21:44:29 +00001613 const auto displayConfigGroup1 = display.getDisplayConfig(config1);
1614 int32_t vsyncPeriod1 = displayConfigGroup1.vsyncPeriod;
1615 int32_t configGroup1 = displayConfigGroup1.configGroup;
1616
1617 const auto displayConfigGroup2 = display.getDisplayConfig(config2);
1618 int32_t vsyncPeriod2 = displayConfigGroup2.vsyncPeriod;
1619 int32_t configGroup2 = displayConfigGroup2.configGroup;
ramindanidcfe3a82021-11-29 17:00:31 +00001620
1621 if (vsyncPeriod1 == vsyncPeriod2) {
1622 return; // continue
1623 }
1624
1625 // We don't allow delayed change when changing config groups
1626 if (params.delayForChange > 0 && configGroup1 != configGroup2) {
1627 return; // continue
1628 }
1629
ramindanidcfe3a82021-11-29 17:00:31 +00001630 VsyncPeriodChangeConstraints constraints = {
1631 .desiredTimeNanos = systemTime() + params.delayForChange,
1632 .seamlessRequired = false};
ramindani431aad42022-02-01 21:44:29 +00001633 const auto& [status, timeline] = mComposerClient->setActiveConfigWithConstraints(
1634 &display, config2, constraints);
1635 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001636
1637 EXPECT_TRUE(timeline.newVsyncAppliedTimeNanos >= constraints.desiredTimeNanos);
1638 // Refresh rate should change within a reasonable time
1639 constexpr std::chrono::nanoseconds kReasonableTimeForChange = 1s; // 1 second
1640 EXPECT_TRUE(timeline.newVsyncAppliedTimeNanos - constraints.desiredTimeNanos <=
1641 kReasonableTimeForChange.count());
1642
1643 if (timeline.refreshRequired) {
1644 if (params.refreshMiss) {
1645 // Miss the refresh frame on purpose to make sure the implementation sends a
1646 // callback
1647 std::this_thread::sleep_until(toTimePoint(timeline.refreshTimeNanos) +
1648 100ms);
1649 }
1650 sendRefreshFrame(display, &timeline);
1651 }
ramindani431aad42022-02-01 21:44:29 +00001652 waitForVsyncPeriodChange(display.getDisplayId(), timeline,
1653 constraints.desiredTimeNanos, vsyncPeriod1, vsyncPeriod2);
ramindanidcfe3a82021-11-29 17:00:31 +00001654
1655 // At this point the refresh rate should have changed already, however in rare
1656 // cases the implementation might have missed the deadline. In this case a new
1657 // timeline should have been provided.
ramindani431aad42022-02-01 21:44:29 +00001658 auto newTimeline = mComposerClient->takeLastVsyncPeriodChangeTimeline();
ramindanidcfe3a82021-11-29 17:00:31 +00001659 if (timeline.refreshRequired && params.refreshMiss) {
1660 EXPECT_TRUE(newTimeline.has_value());
1661 }
1662
1663 if (newTimeline.has_value()) {
1664 if (newTimeline->refreshRequired) {
1665 sendRefreshFrame(display, &newTimeline.value());
1666 }
ramindani431aad42022-02-01 21:44:29 +00001667 waitForVsyncPeriodChange(display.getDisplayId(), newTimeline.value(),
ramindanidcfe3a82021-11-29 17:00:31 +00001668 constraints.desiredTimeNanos, vsyncPeriod1,
1669 vsyncPeriod2);
1670 }
1671
ramindani431aad42022-02-01 21:44:29 +00001672 const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanos] =
1673 mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
1674 EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001675 EXPECT_EQ(vsyncPeriodNanos, vsyncPeriod2);
1676 });
1677 }
1678 }
1679
Ady Abraham72c5b502021-12-10 17:23:39 -08001680 void Test_expectedPresentTime(std::optional<int> framesDelay) {
Jason Macnak325e8232022-01-24 14:48:55 -08001681 if (hasCapability(Capability::PRESENT_FENCE_IS_NOT_RELIABLE)) {
1682 GTEST_SUCCEED() << "Device has unreliable present fences capability, skipping";
1683 return;
1684 }
1685
ramindani431aad42022-02-01 21:44:29 +00001686 ASSERT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001687
1688 const auto vsyncPeriod = getVsyncPeriod();
1689
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001690 const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1691 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
Ady Abraham72c5b502021-12-10 17:23:39 -08001692 ASSERT_NE(nullptr, buffer1);
1693 ASSERT_NE(nullptr, buffer2);
1694
1695 const auto layer = createOnScreenLayer();
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001696 auto& writer = getWriter(getPrimaryDisplayId());
1697 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer1->handle,
1698 /*acquireFence*/ -1);
Ady Abraham72c5b502021-12-10 17:23:39 -08001699 const sp<::android::Fence> presentFence1 =
1700 presentAndGetFence(ComposerClientWriter::kNoTimestamp);
1701 presentFence1->waitForever(LOG_TAG);
1702
1703 auto expectedPresentTime = presentFence1->getSignalTime() + vsyncPeriod;
1704 if (framesDelay.has_value()) {
1705 expectedPresentTime += *framesDelay * vsyncPeriod;
1706 }
1707
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001708 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer2->handle,
1709 /*acquireFence*/ -1);
Ady Abraham72c5b502021-12-10 17:23:39 -08001710 const auto setExpectedPresentTime = [&]() -> std::optional<ClockMonotonicTimestamp> {
1711 if (!framesDelay.has_value()) {
1712 return ComposerClientWriter::kNoTimestamp;
1713 } else if (*framesDelay == 0) {
1714 return ClockMonotonicTimestamp{0};
1715 }
1716 return ClockMonotonicTimestamp{expectedPresentTime};
1717 }();
1718
1719 const sp<::android::Fence> presentFence2 = presentAndGetFence(setExpectedPresentTime);
1720 presentFence2->waitForever(LOG_TAG);
1721
1722 const auto actualPresentTime = presentFence2->getSignalTime();
Ady Abrahamdf084f32022-01-10 14:10:23 -08001723 EXPECT_GE(actualPresentTime, expectedPresentTime - vsyncPeriod / 2);
Ady Abraham72c5b502021-12-10 17:23:39 -08001724
ramindani431aad42022-02-01 21:44:29 +00001725 ASSERT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001726 }
1727
ramindani431aad42022-02-01 21:44:29 +00001728 void configureLayer(const VtsDisplay& display, int64_t layer, Composition composition,
1729 const Rect& displayFrame, const FRect& cropRect) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001730 auto& writer = getWriter(display.getDisplayId());
1731 writer.setLayerCompositionType(display.getDisplayId(), layer, composition);
1732 writer.setLayerDisplayFrame(display.getDisplayId(), layer, displayFrame);
1733 writer.setLayerPlaneAlpha(display.getDisplayId(), layer, /*alpha*/ 1);
1734 writer.setLayerSourceCrop(display.getDisplayId(), layer, cropRect);
1735 writer.setLayerTransform(display.getDisplayId(), layer, static_cast<Transform>(0));
1736 writer.setLayerVisibleRegion(display.getDisplayId(), layer,
1737 std::vector<Rect>(1, displayFrame));
1738 writer.setLayerZOrder(display.getDisplayId(), layer, /*z*/ 10);
1739 writer.setLayerBlendMode(display.getDisplayId(), layer, BlendMode::NONE);
1740 writer.setLayerSurfaceDamage(display.getDisplayId(), layer,
1741 std::vector<Rect>(1, displayFrame));
ramindani431aad42022-02-01 21:44:29 +00001742 }
ramindanidcfe3a82021-11-29 17:00:31 +00001743 // clang-format off
1744 const std::array<float, 16> kIdentity = {{
1745 1.0f, 0.0f, 0.0f, 0.0f,
1746 0.0f, 1.0f, 0.0f, 0.0f,
1747 0.0f, 0.0f, 1.0f, 0.0f,
1748 0.0f, 0.0f, 0.0f, 1.0f,
1749 }};
1750 // clang-format on
1751
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001752 ComposerClientWriter& getWriter(int64_t display) {
Joen Chene0a962c2023-08-28 09:49:11 +00001753 std::lock_guard guard{mWritersMutex};
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001754 auto [it, _] = mWriters.try_emplace(display, display);
1755 return it->second;
1756 }
1757
Ady Abraham91c9d1a2021-12-15 18:14:45 -08001758 ComposerClientReader mReader;
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001759
1760 private:
Joen Chene0a962c2023-08-28 09:49:11 +00001761 void executeInternal(ComposerClientWriter& writer,
1762 std::vector<CommandResultPayload>& payloads) {
1763 auto commands = writer.takePendingCommands();
1764 if (commands.empty()) {
1765 return;
1766 }
1767
1768 auto [status, results] = mComposerClient->executeCommands(commands);
1769 ASSERT_TRUE(status.isOk()) << "executeCommands failed " << status.getDescription();
1770
1771 payloads.reserve(payloads.size() + results.size());
1772 payloads.insert(payloads.end(), std::make_move_iterator(results.begin()),
1773 std::make_move_iterator(results.end()));
1774 }
1775
1776 // Guards access to the map itself. Callers must ensure not to attempt to
1777 // - modify the same writer from multiple threads
1778 // - insert a new writer into the map during concurrent access, which would invalidate
1779 // references from other threads
1780 std::mutex mWritersMutex;
1781 std::unordered_map<int64_t, ComposerClientWriter> mWriters GUARDED_BY(mWritersMutex);
ramindanidcfe3a82021-11-29 17:00:31 +00001782};
1783
ramindani431aad42022-02-01 21:44:29 +00001784TEST_P(GraphicsComposerAidlCommandTest, SetColorTransform) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001785 auto& writer = getWriter(getPrimaryDisplayId());
1786 writer.setColorTransform(getPrimaryDisplayId(), kIdentity.data());
ramindanidcfe3a82021-11-29 17:00:31 +00001787 execute();
1788}
1789
1790TEST_P(GraphicsComposerAidlCommandTest, SetLayerColorTransform) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001791 auto& writer = getWriter(getPrimaryDisplayId());
Ady Abrahama00d2462023-12-26 14:21:20 -08001792 const auto& [status, layer] =
1793 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
1794 EXPECT_TRUE(status.isOk());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001795 writer.setLayerColorTransform(getPrimaryDisplayId(), layer, kIdentity.data());
ramindanidcfe3a82021-11-29 17:00:31 +00001796 execute();
1797
Ady Abraham3192f3d2021-12-03 16:08:56 -08001798 const auto errors = mReader.takeErrors();
Jason Macnak062bc9a2022-01-20 15:00:09 -08001799 if (errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_UNSUPPORTED) {
ramindanidcfe3a82021-11-29 17:00:31 +00001800 GTEST_SUCCEED() << "setLayerColorTransform is not supported";
1801 return;
1802 }
1803}
1804
Alec Mouri60564e12021-12-09 18:48:20 -08001805TEST_P(GraphicsComposerAidlCommandTest, SetDisplayBrightness) {
Peter Linb9fbd4e2023-12-14 05:43:25 +00001806 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
ramindani431aad42022-02-01 21:44:29 +00001807 const auto& [status, capabilities] =
1808 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
1809 ASSERT_TRUE(status.isOk());
Alec Mouri60564e12021-12-09 18:48:20 -08001810 bool brightnessSupport = std::find(capabilities.begin(), capabilities.end(),
1811 DisplayCapability::BRIGHTNESS) != capabilities.end();
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001812 auto& writer = getWriter(getPrimaryDisplayId());
Alec Mouri60564e12021-12-09 18:48:20 -08001813 if (!brightnessSupport) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001814 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.5f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001815 execute();
1816 const auto errors = mReader.takeErrors();
1817 EXPECT_EQ(1, errors.size());
Jason Macnak062bc9a2022-01-20 15:00:09 -08001818 EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, errors[0].errorCode);
Alec Mouri60564e12021-12-09 18:48:20 -08001819 GTEST_SUCCEED() << "SetDisplayBrightness is not supported";
1820 return;
1821 }
1822
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001823 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001824 execute();
1825 EXPECT_TRUE(mReader.takeErrors().empty());
1826
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001827 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.5f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001828 execute();
1829 EXPECT_TRUE(mReader.takeErrors().empty());
1830
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001831 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 1.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001832 execute();
1833 EXPECT_TRUE(mReader.takeErrors().empty());
1834
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001835 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ -1.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001836 execute();
1837 EXPECT_TRUE(mReader.takeErrors().empty());
1838
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001839 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 2.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001840 execute();
1841 {
1842 const auto errors = mReader.takeErrors();
ramindanib3bdf052022-01-12 18:27:05 +00001843 ASSERT_EQ(1, errors.size());
Alec Mouri60564e12021-12-09 18:48:20 -08001844 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
1845 }
1846
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001847 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ -2.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001848 execute();
1849 {
1850 const auto errors = mReader.takeErrors();
ramindanib3bdf052022-01-12 18:27:05 +00001851 ASSERT_EQ(1, errors.size());
Alec Mouri60564e12021-12-09 18:48:20 -08001852 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
1853 }
1854}
1855
ramindani431aad42022-02-01 21:44:29 +00001856TEST_P(GraphicsComposerAidlCommandTest, SetClientTarget) {
1857 EXPECT_TRUE(mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kBufferSlotCount)
1858 .isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001859
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001860 auto& writer = getWriter(getPrimaryDisplayId());
1861 writer.setClientTarget(getPrimaryDisplayId(), /*slot*/ 0, nullptr, /*acquireFence*/ -1,
Alec Mouri8062f1f2023-09-06 02:14:47 +00001862 Dataspace::UNKNOWN, std::vector<Rect>(), 1.0f);
ramindanidcfe3a82021-11-29 17:00:31 +00001863
1864 execute();
1865}
1866
ramindani431aad42022-02-01 21:44:29 +00001867TEST_P(GraphicsComposerAidlCommandTest, SetOutputBuffer) {
1868 const auto& [status, virtualDisplayCount] = mComposerClient->getMaxVirtualDisplayCount();
1869 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001870 if (virtualDisplayCount == 0) {
1871 GTEST_SUCCEED() << "no virtual display support";
1872 return;
1873 }
1874
ramindani431aad42022-02-01 21:44:29 +00001875 const auto& [displayStatus, display] = mComposerClient->createVirtualDisplay(
1876 /*width*/ 64, /*height*/ 64, common::PixelFormat::IMPLEMENTATION_DEFINED,
1877 kBufferSlotCount);
1878 EXPECT_TRUE(displayStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001879
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001880 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001881 const auto handle = buffer->handle;
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001882 auto& writer = getWriter(display.display);
1883 writer.setOutputBuffer(display.display, /*slot*/ 0, handle, /*releaseFence*/ -1);
ramindanidcfe3a82021-11-29 17:00:31 +00001884 execute();
1885}
1886
ramindani431aad42022-02-01 21:44:29 +00001887TEST_P(GraphicsComposerAidlCommandTest, ValidDisplay) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001888 auto& writer = getWriter(getPrimaryDisplayId());
ramindanicdcfcaf2023-11-09 10:00:10 -08001889 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
1890 VtsComposerClient::kNoFrameIntervalNs);
ramindanidcfe3a82021-11-29 17:00:31 +00001891 execute();
1892}
1893
ramindani431aad42022-02-01 21:44:29 +00001894TEST_P(GraphicsComposerAidlCommandTest, AcceptDisplayChanges) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001895 auto& writer = getWriter(getPrimaryDisplayId());
ramindanicdcfcaf2023-11-09 10:00:10 -08001896 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
1897 VtsComposerClient::kNoFrameIntervalNs);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001898 writer.acceptDisplayChanges(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001899 execute();
1900}
1901
ramindani431aad42022-02-01 21:44:29 +00001902TEST_P(GraphicsComposerAidlCommandTest, PresentDisplay) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001903 auto& writer = getWriter(getPrimaryDisplayId());
ramindanicdcfcaf2023-11-09 10:00:10 -08001904 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
1905 VtsComposerClient::kNoFrameIntervalNs);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001906 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001907 execute();
1908}
1909
1910/**
1911 * Test IComposerClient::Command::PRESENT_DISPLAY
1912 *
1913 * Test that IComposerClient::Command::PRESENT_DISPLAY works without
1914 * additional call to validateDisplay when only the layer buffer handle and
1915 * surface damage have been set
1916 */
ramindani431aad42022-02-01 21:44:29 +00001917TEST_P(GraphicsComposerAidlCommandTest, PresentDisplayNoLayerStateChanges) {
ramindani431aad42022-02-01 21:44:29 +00001918 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001919
ramindani431aad42022-02-01 21:44:29 +00001920 const auto& [renderIntentsStatus, renderIntents] =
1921 mComposerClient->getRenderIntents(getPrimaryDisplayId(), ColorMode::NATIVE);
1922 EXPECT_TRUE(renderIntentsStatus.isOk());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001923 auto& writer = getWriter(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001924 for (auto intent : renderIntents) {
ramindani431aad42022-02-01 21:44:29 +00001925 EXPECT_TRUE(mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE, intent)
1926 .isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001927
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001928 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001929 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001930 ASSERT_NE(nullptr, handle);
1931
ramindani431aad42022-02-01 21:44:29 +00001932 const auto& [layerStatus, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08001933 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
ramindani431aad42022-02-01 21:44:29 +00001934 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001935
ramindani431aad42022-02-01 21:44:29 +00001936 Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
1937 getPrimaryDisplay().getDisplayHeight()};
1938 FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
1939 (float)getPrimaryDisplay().getDisplayHeight()};
1940 configureLayer(getPrimaryDisplay(), layer, Composition::CURSOR, displayFrame, cropRect);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001941 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle,
1942 /*acquireFence*/ -1);
1943 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
ramindanicdcfcaf2023-11-09 10:00:10 -08001944 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
1945 VtsComposerClient::kNoFrameIntervalNs);
ramindanidcfe3a82021-11-29 17:00:31 +00001946 execute();
ramindani431aad42022-02-01 21:44:29 +00001947 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
ramindanidcfe3a82021-11-29 17:00:31 +00001948 GTEST_SUCCEED() << "Composition change requested, skipping test";
1949 return;
1950 }
1951
Ady Abraham3192f3d2021-12-03 16:08:56 -08001952 ASSERT_TRUE(mReader.takeErrors().empty());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001953 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001954 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001955 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001956
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001957 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001958 const auto handle2 = buffer2->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001959 ASSERT_NE(nullptr, handle2);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001960 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle2,
1961 /*acquireFence*/ -1);
1962 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer,
1963 std::vector<Rect>(1, {0, 0, 10, 10}));
1964 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001965 execute();
1966 }
1967}
1968
ramindani431aad42022-02-01 21:44:29 +00001969TEST_P(GraphicsComposerAidlCommandTest, SetLayerCursorPosition) {
Ady Abrahama00d2462023-12-26 14:21:20 -08001970 auto& writer = getWriter(getPrimaryDisplayId());
ramindani431aad42022-02-01 21:44:29 +00001971 const auto& [layerStatus, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08001972 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
ramindani431aad42022-02-01 21:44:29 +00001973 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001974
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001975 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001976 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001977 ASSERT_NE(nullptr, handle);
ramindanidcfe3a82021-11-29 17:00:31 +00001978
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001979 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle, /*acquireFence*/ -1);
ramindani431aad42022-02-01 21:44:29 +00001980
1981 Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
1982 getPrimaryDisplay().getDisplayHeight()};
1983 FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
1984 (float)getPrimaryDisplay().getDisplayHeight()};
1985 configureLayer(getPrimaryDisplay(), layer, Composition::CURSOR, displayFrame, cropRect);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001986 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
ramindanicdcfcaf2023-11-09 10:00:10 -08001987 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
1988 VtsComposerClient::kNoFrameIntervalNs);
ramindanidcfe3a82021-11-29 17:00:31 +00001989
1990 execute();
Ady Abraham46219f52021-12-20 09:44:31 -08001991
ramindani431aad42022-02-01 21:44:29 +00001992 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
ramindanidcfe3a82021-11-29 17:00:31 +00001993 GTEST_SUCCEED() << "Composition change requested, skipping test";
1994 return;
1995 }
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001996 writer.presentDisplay(getPrimaryDisplayId());
Ady Abraham3192f3d2021-12-03 16:08:56 -08001997 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001998
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001999 writer.setLayerCursorPosition(getPrimaryDisplayId(), layer, /*x*/ 1, /*y*/ 1);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002000 execute();
2001
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002002 writer.setLayerCursorPosition(getPrimaryDisplayId(), layer, /*x*/ 0, /*y*/ 0);
ramindanicdcfcaf2023-11-09 10:00:10 -08002003 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
2004 VtsComposerClient::kNoFrameIntervalNs);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002005 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00002006 execute();
2007}
2008
ramindani431aad42022-02-01 21:44:29 +00002009TEST_P(GraphicsComposerAidlCommandTest, SetLayerBuffer) {
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002010 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00002011 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00002012 ASSERT_NE(nullptr, handle);
2013
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002014 auto& writer = getWriter(getPrimaryDisplayId());
Ady Abrahama00d2462023-12-26 14:21:20 -08002015 const auto& [layerStatus, layer] =
2016 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
2017 EXPECT_TRUE(layerStatus.isOk());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002018 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle, /*acquireFence*/ -1);
ramindanidcfe3a82021-11-29 17:00:31 +00002019 execute();
2020}
2021
Brian Lindahl25e0d092022-12-09 00:32:11 -07002022TEST_P(GraphicsComposerAidlCommandTest, SetLayerBufferMultipleTimes) {
Brian Lindahl25e0d092022-12-09 00:32:11 -07002023 auto& writer = getWriter(getPrimaryDisplayId());
Ady Abrahama00d2462023-12-26 14:21:20 -08002024 const auto& [layerStatus, layer] =
2025 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
2026 EXPECT_TRUE(layerStatus.isOk());
Brian Lindahl25e0d092022-12-09 00:32:11 -07002027
2028 // Setup 3 buffers in the buffer cache, with the last buffer being active. Then, emulate the
2029 // Android platform code that clears all 3 buffer slots by setting all but the active buffer
2030 // slot to a placeholder buffer, and then restoring the active buffer.
2031
2032 // This is used on HALs that don't support setLayerBufferSlotsToClear (version <= 3.1).
2033
2034 const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2035 ASSERT_NE(nullptr, buffer1);
2036 const auto handle1 = buffer1->handle;
2037 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle1, /*acquireFence*/ -1);
2038 execute();
2039 ASSERT_TRUE(mReader.takeErrors().empty());
2040
2041 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2042 ASSERT_NE(nullptr, buffer2);
2043 const auto handle2 = buffer2->handle;
2044 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 1, handle2, /*acquireFence*/ -1);
2045 execute();
2046 ASSERT_TRUE(mReader.takeErrors().empty());
2047
2048 const auto buffer3 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2049 ASSERT_NE(nullptr, buffer3);
2050 const auto handle3 = buffer3->handle;
2051 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 2, handle3, /*acquireFence*/ -1);
2052 execute();
2053 ASSERT_TRUE(mReader.takeErrors().empty());
2054
2055 // Older versions of the HAL clear all but the active buffer slot with a placeholder buffer,
2056 // and then restoring the current active buffer at the end
2057 auto clearSlotBuffer = allocate(1u, 1u, ::android::PIXEL_FORMAT_RGB_888);
2058 ASSERT_NE(nullptr, clearSlotBuffer);
2059 auto clearSlotBufferHandle = clearSlotBuffer->handle;
2060
2061 // clear buffer slots 0 and 1 with new layer commands... and then...
2062 writer.setLayerBufferWithNewCommand(getPrimaryDisplayId(), layer, /* slot */ 0,
2063 clearSlotBufferHandle, /*acquireFence*/ -1);
2064 writer.setLayerBufferWithNewCommand(getPrimaryDisplayId(), layer, /* slot */ 1,
2065 clearSlotBufferHandle, /*acquireFence*/ -1);
2066 // ...reset the layer buffer to the current active buffer slot with a final new command
2067 writer.setLayerBufferWithNewCommand(getPrimaryDisplayId(), layer, /*slot*/ 2, nullptr,
2068 /*acquireFence*/ -1);
2069 execute();
2070 ASSERT_TRUE(mReader.takeErrors().empty());
2071}
2072
ramindani431aad42022-02-01 21:44:29 +00002073TEST_P(GraphicsComposerAidlCommandTest, SetLayerSurfaceDamage) {
Ady Abrahama00d2462023-12-26 14:21:20 -08002074 auto& writer = getWriter(getPrimaryDisplayId());
ramindani431aad42022-02-01 21:44:29 +00002075 const auto& [layerStatus, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08002076 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
ramindani431aad42022-02-01 21:44:29 +00002077 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002078
2079 Rect empty{0, 0, 0, 0};
2080 Rect unit{0, 0, 1, 1};
2081
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002082 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
ramindanidcfe3a82021-11-29 17:00:31 +00002083 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002084 ASSERT_TRUE(mReader.takeErrors().empty());
2085
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002086 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
Ady Abraham3192f3d2021-12-03 16:08:56 -08002087 execute();
2088 ASSERT_TRUE(mReader.takeErrors().empty());
2089
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002090 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>());
Ady Abraham3192f3d2021-12-03 16:08:56 -08002091 execute();
2092 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002093}
2094
ramindani431aad42022-02-01 21:44:29 +00002095TEST_P(GraphicsComposerAidlCommandTest, SetLayerBlockingRegion) {
Ady Abrahama00d2462023-12-26 14:21:20 -08002096 auto& writer = getWriter(getPrimaryDisplayId());
ramindani431aad42022-02-01 21:44:29 +00002097 const auto& [layerStatus, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08002098 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
ramindani431aad42022-02-01 21:44:29 +00002099 EXPECT_TRUE(layerStatus.isOk());
Leon Scroggins III03318152022-01-13 12:24:19 -05002100
2101 Rect empty{0, 0, 0, 0};
2102 Rect unit{0, 0, 1, 1};
2103
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002104 writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
Leon Scroggins III03318152022-01-13 12:24:19 -05002105 execute();
2106 ASSERT_TRUE(mReader.takeErrors().empty());
2107
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002108 writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
Leon Scroggins III03318152022-01-13 12:24:19 -05002109 execute();
2110 ASSERT_TRUE(mReader.takeErrors().empty());
2111
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002112 writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>());
Leon Scroggins III03318152022-01-13 12:24:19 -05002113 execute();
2114 ASSERT_TRUE(mReader.takeErrors().empty());
2115}
2116
ramindani431aad42022-02-01 21:44:29 +00002117TEST_P(GraphicsComposerAidlCommandTest, SetLayerBlendMode) {
Ady Abrahama00d2462023-12-26 14:21:20 -08002118 auto& writer = getWriter(getPrimaryDisplayId());
ramindani431aad42022-02-01 21:44:29 +00002119 const auto& [layerStatus, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08002120 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
ramindani431aad42022-02-01 21:44:29 +00002121 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002122
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002123 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::NONE);
ramindanidcfe3a82021-11-29 17:00:31 +00002124 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002125 ASSERT_TRUE(mReader.takeErrors().empty());
2126
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002127 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::PREMULTIPLIED);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002128 execute();
2129 ASSERT_TRUE(mReader.takeErrors().empty());
2130
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002131 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::COVERAGE);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002132 execute();
2133 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002134}
2135
ramindani431aad42022-02-01 21:44:29 +00002136TEST_P(GraphicsComposerAidlCommandTest, SetLayerColor) {
Ady Abrahama00d2462023-12-26 14:21:20 -08002137 auto& writer = getWriter(getPrimaryDisplayId());
ramindani431aad42022-02-01 21:44:29 +00002138 const auto& [layerStatus, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08002139 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
ramindani431aad42022-02-01 21:44:29 +00002140 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002141
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002142 writer.setLayerColor(getPrimaryDisplayId(), layer, Color{1.0f, 1.0f, 1.0f, 1.0f});
ramindanidcfe3a82021-11-29 17:00:31 +00002143 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002144 ASSERT_TRUE(mReader.takeErrors().empty());
2145
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002146 writer.setLayerColor(getPrimaryDisplayId(), layer, Color{0.0f, 0.0f, 0.0f, 0.0f});
Ady Abraham3192f3d2021-12-03 16:08:56 -08002147 execute();
2148 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002149}
2150
ramindani431aad42022-02-01 21:44:29 +00002151TEST_P(GraphicsComposerAidlCommandTest, SetLayerCompositionType) {
Ady Abrahama00d2462023-12-26 14:21:20 -08002152 auto& writer = getWriter(getPrimaryDisplayId());
ramindani431aad42022-02-01 21:44:29 +00002153 const auto& [layerStatus, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08002154 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
ramindani431aad42022-02-01 21:44:29 +00002155 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002156
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002157 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::CLIENT);
ramindanidcfe3a82021-11-29 17:00:31 +00002158 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002159 ASSERT_TRUE(mReader.takeErrors().empty());
2160
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002161 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::DEVICE);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002162 execute();
2163 ASSERT_TRUE(mReader.takeErrors().empty());
2164
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002165 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::SOLID_COLOR);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002166 execute();
2167 ASSERT_TRUE(mReader.takeErrors().empty());
2168
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002169 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::CURSOR);
ramindani431aad42022-02-01 21:44:29 +00002170 execute();
2171}
2172
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002173TEST_P(GraphicsComposerAidlCommandTest, DisplayDecoration) {
2174 for (VtsDisplay& display : mDisplays) {
Ady Abrahama00d2462023-12-26 14:21:20 -08002175 auto& writer = getWriter(display.getDisplayId());
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002176 const auto [layerStatus, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08002177 mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002178 EXPECT_TRUE(layerStatus.isOk());
2179
2180 const auto [error, support] =
2181 mComposerClient->getDisplayDecorationSupport(display.getDisplayId());
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002182
Leon Scroggins III91590872022-02-23 09:51:21 -05002183 const auto format = (error.isOk() && support) ? support->format
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002184 : aidl::android::hardware::graphics::common::PixelFormat::RGBA_8888;
2185 const auto decorBuffer = allocate(static_cast<::android::PixelFormat>(format));
2186 ASSERT_NE(nullptr, decorBuffer);
2187 if (::android::OK != decorBuffer->initCheck()) {
2188 if (support) {
2189 FAIL() << "Device advertised display decoration support with format "
2190 << aidl::android::hardware::graphics::common::toString(format)
2191 << " but failed to allocate it!";
2192 } else {
2193 FAIL() << "Device advertised NO display decoration support, but it should "
2194 << "still be able to allocate "
2195 << aidl::android::hardware::graphics::common::toString(format);
2196 }
2197 }
2198
Midas Chien7d55d422022-06-07 02:32:28 +08002199 configureLayer(display, layer, Composition::DISPLAY_DECORATION, display.getFrameRect(),
Ady Abrahama00d2462023-12-26 14:21:20 -08002200 display.getCrop());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002201 writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, decorBuffer->handle,
2202 /*acquireFence*/ -1);
ramindanicdcfcaf2023-11-09 10:00:10 -08002203 writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp,
2204 VtsComposerClient::kNoFrameIntervalNs);
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002205 execute();
2206 if (support) {
2207 ASSERT_TRUE(mReader.takeErrors().empty());
2208 } else {
2209 const auto errors = mReader.takeErrors();
2210 ASSERT_EQ(1, errors.size());
Leon Scroggins III6455e792022-02-24 12:18:58 -05002211 EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, errors[0].errorCode);
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002212 }
2213 }
2214}
2215
ramindani431aad42022-02-01 21:44:29 +00002216TEST_P(GraphicsComposerAidlCommandTest, SetLayerDataspace) {
Ady Abrahama00d2462023-12-26 14:21:20 -08002217 auto& writer = getWriter(getPrimaryDisplayId());
ramindani431aad42022-02-01 21:44:29 +00002218 const auto& [layerStatus, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08002219 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
ramindani431aad42022-02-01 21:44:29 +00002220 EXPECT_TRUE(layerStatus.isOk());
2221
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002222 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
ramindani431aad42022-02-01 21:44:29 +00002223 execute();
2224}
2225
2226TEST_P(GraphicsComposerAidlCommandTest, SetLayerDisplayFrame) {
Ady Abrahama00d2462023-12-26 14:21:20 -08002227 auto& writer = getWriter(getPrimaryDisplayId());
ramindani431aad42022-02-01 21:44:29 +00002228 const auto& [layerStatus, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08002229 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
ramindani431aad42022-02-01 21:44:29 +00002230 EXPECT_TRUE(layerStatus.isOk());
2231
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002232 writer.setLayerDisplayFrame(getPrimaryDisplayId(), layer, Rect{0, 0, 1, 1});
ramindani431aad42022-02-01 21:44:29 +00002233 execute();
2234}
2235
2236TEST_P(GraphicsComposerAidlCommandTest, SetLayerPlaneAlpha) {
Ady Abrahama00d2462023-12-26 14:21:20 -08002237 auto& writer = getWriter(getPrimaryDisplayId());
ramindani431aad42022-02-01 21:44:29 +00002238 const auto& [layerStatus, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08002239 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
ramindani431aad42022-02-01 21:44:29 +00002240 EXPECT_TRUE(layerStatus.isOk());
2241
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002242 writer.setLayerPlaneAlpha(getPrimaryDisplayId(), layer, /*alpha*/ 0.0f);
ramindani431aad42022-02-01 21:44:29 +00002243 execute();
2244 ASSERT_TRUE(mReader.takeErrors().empty());
2245
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002246 writer.setLayerPlaneAlpha(getPrimaryDisplayId(), layer, /*alpha*/ 1.0f);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002247 execute();
2248 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002249}
2250
ramindani431aad42022-02-01 21:44:29 +00002251TEST_P(GraphicsComposerAidlCommandTest, SetLayerSidebandStream) {
Jason Macnak325e8232022-01-24 14:48:55 -08002252 if (!hasCapability(Capability::SIDEBAND_STREAM)) {
ramindanidcfe3a82021-11-29 17:00:31 +00002253 GTEST_SUCCEED() << "no sideband stream support";
2254 return;
2255 }
2256
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002257 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00002258 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00002259 ASSERT_NE(nullptr, handle);
2260
Ady Abrahama00d2462023-12-26 14:21:20 -08002261 auto& writer = getWriter(getPrimaryDisplayId());
ramindani431aad42022-02-01 21:44:29 +00002262 const auto& [layerStatus, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08002263 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
ramindani431aad42022-02-01 21:44:29 +00002264 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002265
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002266 writer.setLayerSidebandStream(getPrimaryDisplayId(), layer, handle);
ramindanidcfe3a82021-11-29 17:00:31 +00002267 execute();
2268}
2269
ramindani431aad42022-02-01 21:44:29 +00002270TEST_P(GraphicsComposerAidlCommandTest, SetLayerSourceCrop) {
Ady Abrahama00d2462023-12-26 14:21:20 -08002271 auto& writer = getWriter(getPrimaryDisplayId());
ramindani431aad42022-02-01 21:44:29 +00002272 const auto& [layerStatus, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08002273 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
ramindani431aad42022-02-01 21:44:29 +00002274 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002275
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002276 writer.setLayerSourceCrop(getPrimaryDisplayId(), layer, FRect{0.0f, 0.0f, 1.0f, 1.0f});
ramindanidcfe3a82021-11-29 17:00:31 +00002277 execute();
2278}
2279
ramindani431aad42022-02-01 21:44:29 +00002280TEST_P(GraphicsComposerAidlCommandTest, SetLayerTransform) {
Ady Abrahama00d2462023-12-26 14:21:20 -08002281 auto& writer = getWriter(getPrimaryDisplayId());
ramindani431aad42022-02-01 21:44:29 +00002282 const auto& [layerStatus, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08002283 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
ramindani431aad42022-02-01 21:44:29 +00002284 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002285
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002286 writer.setLayerTransform(getPrimaryDisplayId(), layer, static_cast<Transform>(0));
ramindanidcfe3a82021-11-29 17:00:31 +00002287 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002288 ASSERT_TRUE(mReader.takeErrors().empty());
2289
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002290 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::FLIP_H);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002291 execute();
2292 ASSERT_TRUE(mReader.takeErrors().empty());
2293
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002294 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::FLIP_V);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002295 execute();
2296 ASSERT_TRUE(mReader.takeErrors().empty());
2297
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002298 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_90);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002299 execute();
2300 ASSERT_TRUE(mReader.takeErrors().empty());
2301
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002302 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_180);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002303 execute();
2304 ASSERT_TRUE(mReader.takeErrors().empty());
2305
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002306 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_270);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002307 execute();
2308 ASSERT_TRUE(mReader.takeErrors().empty());
2309
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002310 writer.setLayerTransform(getPrimaryDisplayId(), layer,
2311 static_cast<Transform>(static_cast<int>(Transform::FLIP_H) |
2312 static_cast<int>(Transform::ROT_90)));
Ady Abraham3192f3d2021-12-03 16:08:56 -08002313 execute();
2314 ASSERT_TRUE(mReader.takeErrors().empty());
2315
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002316 writer.setLayerTransform(getPrimaryDisplayId(), layer,
2317 static_cast<Transform>(static_cast<int>(Transform::FLIP_V) |
2318 static_cast<int>(Transform::ROT_90)));
Ady Abraham3192f3d2021-12-03 16:08:56 -08002319 execute();
2320 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002321}
2322
ramindani431aad42022-02-01 21:44:29 +00002323TEST_P(GraphicsComposerAidlCommandTest, SetLayerVisibleRegion) {
Ady Abrahama00d2462023-12-26 14:21:20 -08002324 auto& writer = getWriter(getPrimaryDisplayId());
ramindani431aad42022-02-01 21:44:29 +00002325 const auto& [layerStatus, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08002326 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
ramindani431aad42022-02-01 21:44:29 +00002327 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002328
2329 Rect empty{0, 0, 0, 0};
2330 Rect unit{0, 0, 1, 1};
2331
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002332 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
ramindanidcfe3a82021-11-29 17:00:31 +00002333 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002334 ASSERT_TRUE(mReader.takeErrors().empty());
2335
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002336 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
Ady Abraham3192f3d2021-12-03 16:08:56 -08002337 execute();
2338 ASSERT_TRUE(mReader.takeErrors().empty());
2339
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002340 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>());
Ady Abraham3192f3d2021-12-03 16:08:56 -08002341 execute();
2342 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002343}
2344
ramindani431aad42022-02-01 21:44:29 +00002345TEST_P(GraphicsComposerAidlCommandTest, SetLayerZOrder) {
Ady Abrahama00d2462023-12-26 14:21:20 -08002346 auto& writer = getWriter(getPrimaryDisplayId());
2347
ramindani431aad42022-02-01 21:44:29 +00002348 const auto& [layerStatus, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08002349 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
ramindani431aad42022-02-01 21:44:29 +00002350 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002351
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002352 writer.setLayerZOrder(getPrimaryDisplayId(), layer, /*z*/ 10);
ramindanidcfe3a82021-11-29 17:00:31 +00002353 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002354 ASSERT_TRUE(mReader.takeErrors().empty());
2355
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002356 writer.setLayerZOrder(getPrimaryDisplayId(), layer, /*z*/ 0);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002357 execute();
2358 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002359}
2360
ramindani431aad42022-02-01 21:44:29 +00002361TEST_P(GraphicsComposerAidlCommandTest, SetLayerPerFrameMetadata) {
Ady Abrahama00d2462023-12-26 14:21:20 -08002362 auto& writer = getWriter(getPrimaryDisplayId());
ramindani431aad42022-02-01 21:44:29 +00002363 const auto& [layerStatus, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08002364 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
ramindani431aad42022-02-01 21:44:29 +00002365 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002366
ramindanidcfe3a82021-11-29 17:00:31 +00002367 /**
2368 * DISPLAY_P3 is a color space that uses the DCI_P3 primaries,
2369 * the D65 white point and the SRGB transfer functions.
2370 * Rendering Intent: Colorimetric
2371 * Primaries:
2372 * x y
2373 * green 0.265 0.690
2374 * blue 0.150 0.060
2375 * red 0.680 0.320
2376 * white (D65) 0.3127 0.3290
2377 */
2378
2379 std::vector<PerFrameMetadata> aidlMetadata;
2380 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X, 0.680f});
2381 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y, 0.320f});
2382 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X, 0.265f});
2383 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y, 0.690f});
2384 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X, 0.150f});
2385 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y, 0.060f});
2386 aidlMetadata.push_back({PerFrameMetadataKey::WHITE_POINT_X, 0.3127f});
2387 aidlMetadata.push_back({PerFrameMetadataKey::WHITE_POINT_Y, 0.3290f});
2388 aidlMetadata.push_back({PerFrameMetadataKey::MAX_LUMINANCE, 100.0f});
2389 aidlMetadata.push_back({PerFrameMetadataKey::MIN_LUMINANCE, 0.1f});
2390 aidlMetadata.push_back({PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL, 78.0});
2391 aidlMetadata.push_back({PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL, 62.0});
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002392 writer.setLayerPerFrameMetadata(getPrimaryDisplayId(), layer, aidlMetadata);
ramindanidcfe3a82021-11-29 17:00:31 +00002393 execute();
2394
Ady Abraham3192f3d2021-12-03 16:08:56 -08002395 const auto errors = mReader.takeErrors();
2396 if (errors.size() == 1 && errors[0].errorCode == EX_UNSUPPORTED_OPERATION) {
ramindanidcfe3a82021-11-29 17:00:31 +00002397 GTEST_SUCCEED() << "SetLayerPerFrameMetadata is not supported";
Ady Abrahama00d2462023-12-26 14:21:20 -08002398 EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer, &writer).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002399 return;
2400 }
2401
Ady Abrahama00d2462023-12-26 14:21:20 -08002402 EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer, &writer).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002403}
2404
Alec Mourib1f16722022-02-07 13:03:44 -08002405TEST_P(GraphicsComposerAidlCommandTest, setLayerBrightness) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002406 auto& writer = getWriter(getPrimaryDisplayId());
Ady Abrahama00d2462023-12-26 14:21:20 -08002407
2408 const auto& [layerStatus, layer] =
2409 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
2410
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002411 writer.setLayerBrightness(getPrimaryDisplayId(), layer, 0.2f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002412 execute();
2413 ASSERT_TRUE(mReader.takeErrors().empty());
2414
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002415 writer.setLayerBrightness(getPrimaryDisplayId(), layer, 1.f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002416 execute();
2417 ASSERT_TRUE(mReader.takeErrors().empty());
2418
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002419 writer.setLayerBrightness(getPrimaryDisplayId(), layer, 0.f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002420 execute();
2421 ASSERT_TRUE(mReader.takeErrors().empty());
2422
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002423 writer.setLayerBrightness(getPrimaryDisplayId(), layer, -1.f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002424 execute();
Alec Mourib1f16722022-02-07 13:03:44 -08002425 {
2426 const auto errors = mReader.takeErrors();
2427 ASSERT_EQ(1, errors.size());
2428 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
2429 }
2430
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002431 writer.setLayerBrightness(getPrimaryDisplayId(), layer, std::nanf(""));
Alec Mourib1f16722022-02-07 13:03:44 -08002432 execute();
2433 {
2434 const auto errors = mReader.takeErrors();
2435 ASSERT_EQ(1, errors.size());
2436 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
2437 }
Alec Mouri95e490b2022-01-06 13:46:58 -08002438}
2439
ramindani431aad42022-02-01 21:44:29 +00002440TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints) {
ramindanidcfe3a82021-11-29 17:00:31 +00002441 Test_setActiveConfigWithConstraints({.delayForChange = 0, .refreshMiss = false});
2442}
2443
ramindani431aad42022-02-01 21:44:29 +00002444TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_Delayed) {
ramindanidcfe3a82021-11-29 17:00:31 +00002445 Test_setActiveConfigWithConstraints({.delayForChange = 300'000'000, // 300ms
2446 .refreshMiss = false});
2447}
2448
ramindani431aad42022-02-01 21:44:29 +00002449TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_MissRefresh) {
ramindanidcfe3a82021-11-29 17:00:31 +00002450 Test_setActiveConfigWithConstraints({.delayForChange = 0, .refreshMiss = true});
2451}
2452
ramindani431aad42022-02-01 21:44:29 +00002453TEST_P(GraphicsComposerAidlCommandTest, GetDisplayVsyncPeriod) {
ramindanidcfe3a82021-11-29 17:00:31 +00002454 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +00002455 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
2456 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002457
ramindani431aad42022-02-01 21:44:29 +00002458 for (int32_t config : configs) {
2459 int32_t expectedVsyncPeriodNanos = display.getDisplayConfig(config).vsyncPeriod;
2460
ramindanidcfe3a82021-11-29 17:00:31 +00002461 VsyncPeriodChangeConstraints constraints;
2462
2463 constraints.desiredTimeNanos = systemTime();
2464 constraints.seamlessRequired = false;
ramindani431aad42022-02-01 21:44:29 +00002465
2466 const auto& [timelineStatus, timeline] =
2467 mComposerClient->setActiveConfigWithConstraints(&display, config, constraints);
2468 EXPECT_TRUE(timelineStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002469
2470 if (timeline.refreshRequired) {
2471 sendRefreshFrame(display, &timeline);
2472 }
ramindani431aad42022-02-01 21:44:29 +00002473 waitForVsyncPeriodChange(display.getDisplayId(), timeline, constraints.desiredTimeNanos,
2474 /*odPeriodNanos*/ 0, expectedVsyncPeriodNanos);
ramindanidcfe3a82021-11-29 17:00:31 +00002475
2476 int32_t vsyncPeriodNanos;
2477 int retryCount = 100;
2478 do {
2479 std::this_thread::sleep_for(10ms);
ramindani431aad42022-02-01 21:44:29 +00002480 const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanosValue] =
2481 mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
2482
2483 EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
2484 vsyncPeriodNanos = vsyncPeriodNanosValue;
ramindanidcfe3a82021-11-29 17:00:31 +00002485 --retryCount;
2486 } while (vsyncPeriodNanos != expectedVsyncPeriodNanos && retryCount > 0);
2487
2488 EXPECT_EQ(vsyncPeriodNanos, expectedVsyncPeriodNanos);
2489
2490 // Make sure that the vsync period stays the same if the active config is not
2491 // changed.
2492 auto timeout = 1ms;
2493 for (int i = 0; i < 10; i++) {
2494 std::this_thread::sleep_for(timeout);
2495 timeout *= 2;
2496 vsyncPeriodNanos = 0;
ramindani431aad42022-02-01 21:44:29 +00002497 const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanosValue] =
2498 mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
2499
2500 EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
2501 vsyncPeriodNanos = vsyncPeriodNanosValue;
ramindanidcfe3a82021-11-29 17:00:31 +00002502 EXPECT_EQ(vsyncPeriodNanos, expectedVsyncPeriodNanos);
2503 }
2504 }
2505 }
2506}
2507
ramindani431aad42022-02-01 21:44:29 +00002508TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_SeamlessNotAllowed) {
ramindanidcfe3a82021-11-29 17:00:31 +00002509 VsyncPeriodChangeConstraints constraints;
ramindanidcfe3a82021-11-29 17:00:31 +00002510 constraints.seamlessRequired = true;
2511 constraints.desiredTimeNanos = systemTime();
2512
2513 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +00002514 forEachTwoConfigs(display.getDisplayId(), [&](int32_t config1, int32_t config2) {
2515 int32_t configGroup1 = display.getDisplayConfig(config1).configGroup;
2516 int32_t configGroup2 = display.getDisplayConfig(config2).configGroup;
ramindanidcfe3a82021-11-29 17:00:31 +00002517 if (configGroup1 != configGroup2) {
ramindani431aad42022-02-01 21:44:29 +00002518 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002519 sendRefreshFrame(display, nullptr);
ramindani431aad42022-02-01 21:44:29 +00002520 const auto& [status, _] = mComposerClient->setActiveConfigWithConstraints(
2521 &display, config2, constraints);
2522 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00002523 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(
2524 status, IComposerClient::EX_SEAMLESS_NOT_ALLOWED));
ramindanidcfe3a82021-11-29 17:00:31 +00002525 }
2526 });
2527 }
2528}
2529
ramindani431aad42022-02-01 21:44:29 +00002530TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_NoTimestamp) {
2531 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ std::nullopt));
Ady Abraham72c5b502021-12-10 17:23:39 -08002532}
2533
ramindani431aad42022-02-01 21:44:29 +00002534TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_0) {
2535 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ 0));
Ady Abraham72c5b502021-12-10 17:23:39 -08002536}
2537
ramindani431aad42022-02-01 21:44:29 +00002538TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_5) {
2539 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ 5));
Ady Abraham72c5b502021-12-10 17:23:39 -08002540}
2541
ramindani431aad42022-02-01 21:44:29 +00002542TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Unsupported) {
2543 const bool hasDisplayIdleTimerSupport =
2544 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002545 if (!hasDisplayIdleTimerSupport) {
ramindani431aad42022-02-01 21:44:29 +00002546 const auto& status =
2547 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0);
2548 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00002549 EXPECT_NO_FATAL_FAILURE(
2550 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
Midas Chiena0b56bd2022-01-13 23:27:33 +08002551 }
2552}
2553
ramindani431aad42022-02-01 21:44:29 +00002554TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_BadParameter) {
2555 const bool hasDisplayIdleTimerSupport =
2556 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002557 if (!hasDisplayIdleTimerSupport) {
2558 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2559 return;
2560 }
2561
ramindani431aad42022-02-01 21:44:29 +00002562 const auto& status =
2563 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ -1);
2564 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00002565 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
Midas Chiena0b56bd2022-01-13 23:27:33 +08002566}
2567
ramindani431aad42022-02-01 21:44:29 +00002568TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Disable) {
2569 const bool hasDisplayIdleTimerSupport =
2570 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002571 if (!hasDisplayIdleTimerSupport) {
2572 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2573 return;
2574 }
2575
ramindani431aad42022-02-01 21:44:29 +00002576 EXPECT_TRUE(mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002577 std::this_thread::sleep_for(1s);
ramindani431aad42022-02-01 21:44:29 +00002578 EXPECT_EQ(0, mComposerClient->getVsyncIdleCount());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002579}
2580
ramindani431aad42022-02-01 21:44:29 +00002581TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Timeout_2) {
2582 const bool hasDisplayIdleTimerSupport =
2583 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002584 if (!hasDisplayIdleTimerSupport) {
2585 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2586 return;
2587 }
2588
ramindani431aad42022-02-01 21:44:29 +00002589 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
2590 EXPECT_TRUE(mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002591
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002592 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002593 ASSERT_NE(nullptr, buffer->handle);
2594
2595 const auto layer = createOnScreenLayer();
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002596 auto& writer = getWriter(getPrimaryDisplayId());
2597 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer->handle,
2598 /*acquireFence*/ -1);
ramindani431aad42022-02-01 21:44:29 +00002599 int32_t vsyncIdleCount = mComposerClient->getVsyncIdleCount();
Midas Chiena0b56bd2022-01-13 23:27:33 +08002600 auto earlyVsyncIdleTime = systemTime() + std::chrono::nanoseconds(2s).count();
ramindani431aad42022-02-01 21:44:29 +00002601 EXPECT_TRUE(
2602 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 2000).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002603
2604 const sp<::android::Fence> presentFence =
ramindani431aad42022-02-01 21:44:29 +00002605 presentAndGetFence(ComposerClientWriter::kNoTimestamp);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002606 presentFence->waitForever(LOG_TAG);
2607
2608 std::this_thread::sleep_for(3s);
ramindani431aad42022-02-01 21:44:29 +00002609 if (vsyncIdleCount < mComposerClient->getVsyncIdleCount()) {
2610 EXPECT_GE(mComposerClient->getVsyncIdleTime(), earlyVsyncIdleTime);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002611 }
2612
ramindani431aad42022-02-01 21:44:29 +00002613 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002614}
2615
ramindani12423f52023-06-14 20:04:51 -07002616class GraphicsComposerAidlCommandV2Test : public GraphicsComposerAidlCommandTest {
2617 protected:
2618 void SetUp() override {
2619 GraphicsComposerAidlTest::SetUp();
2620 if (getInterfaceVersion() <= 1) {
2621 GTEST_SKIP() << "Device interface version is expected to be >= 2";
2622 }
ramindani17c71102023-03-20 10:51:14 -07002623 }
ramindani12423f52023-06-14 20:04:51 -07002624};
2625/**
2626 * Test Capability::SKIP_VALIDATE
2627 *
2628 * Capability::SKIP_VALIDATE has been deprecated and should not be enabled.
2629 */
2630TEST_P(GraphicsComposerAidlCommandV2Test, SkipValidateDeprecatedTest) {
Leon Scroggins III79d7ae82023-10-11 16:03:52 -04002631#pragma clang diagnostic push
2632#pragma clang diagnostic ignored "-Wdeprecated-declarations"
ramindani12423f52023-06-14 20:04:51 -07002633 ASSERT_FALSE(hasCapability(Capability::SKIP_VALIDATE))
2634 << "Found Capability::SKIP_VALIDATE capability.";
Leon Scroggins III79d7ae82023-10-11 16:03:52 -04002635#pragma clang diagnostic pop
ramindani12423f52023-06-14 20:04:51 -07002636}
2637
2638TEST_P(GraphicsComposerAidlCommandV2Test, SetLayerBufferSlotsToClear) {
Ady Abrahama00d2462023-12-26 14:21:20 -08002639 auto& writer = getWriter(getPrimaryDisplayId());
ramindani12423f52023-06-14 20:04:51 -07002640 // Older HAL versions use a backwards compatible way of clearing buffer slots
2641 // HAL at version 1 or lower does not have LayerCommand::bufferSlotsToClear
2642 const auto& [layerStatus, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08002643 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
ramindani12423f52023-06-14 20:04:51 -07002644 EXPECT_TRUE(layerStatus.isOk());
ramindani12423f52023-06-14 20:04:51 -07002645
2646 // setup 3 buffers in the buffer cache, with the last buffer being active
2647 // then emulate the Android platform code that clears all 3 buffer slots
2648
2649 const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2650 ASSERT_NE(nullptr, buffer1);
2651 const auto handle1 = buffer1->handle;
2652 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle1, /*acquireFence*/ -1);
2653 execute();
2654 ASSERT_TRUE(mReader.takeErrors().empty());
2655
2656 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2657 ASSERT_NE(nullptr, buffer2);
2658 const auto handle2 = buffer2->handle;
2659 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 1, handle2, /*acquireFence*/ -1);
2660 execute();
2661 ASSERT_TRUE(mReader.takeErrors().empty());
2662
2663 const auto buffer3 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2664 ASSERT_NE(nullptr, buffer3);
2665 const auto handle3 = buffer3->handle;
2666 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 2, handle3, /*acquireFence*/ -1);
2667 execute();
2668 ASSERT_TRUE(mReader.takeErrors().empty());
2669
2670 // Ensure we can clear all 3 buffer slots, even the active buffer - it is assumed the
2671 // current active buffer's slot will be cleared, but still remain the active buffer and no
2672 // errors will occur.
2673 writer.setLayerBufferSlotsToClear(getPrimaryDisplayId(), layer, {0, 1, 2});
2674 execute();
2675 ASSERT_TRUE(mReader.takeErrors().empty());
2676}
2677
2678TEST_P(GraphicsComposerAidlCommandV2Test, SetRefreshRateChangedCallbackDebug_Unsupported) {
ramindani9dd8c482023-02-21 18:07:56 -08002679 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2680 auto status = mComposerClient->setRefreshRateChangedCallbackDebugEnabled(
2681 getPrimaryDisplayId(), /*enabled*/ true);
2682 EXPECT_FALSE(status.isOk());
2683 EXPECT_NO_FATAL_FAILURE(
2684 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
2685
2686 status = mComposerClient->setRefreshRateChangedCallbackDebugEnabled(getPrimaryDisplayId(),
2687 /*enabled*/ false);
2688 EXPECT_FALSE(status.isOk());
2689 EXPECT_NO_FATAL_FAILURE(
2690 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
2691 }
2692}
2693
ramindani12423f52023-06-14 20:04:51 -07002694TEST_P(GraphicsComposerAidlCommandV2Test, SetRefreshRateChangedCallbackDebug_Enabled) {
ramindani9dd8c482023-02-21 18:07:56 -08002695 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2696 GTEST_SUCCEED() << "Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG is not supported";
2697 return;
2698 }
2699
ramindania2a6dea2023-12-11 13:42:36 -08002700 for (VtsDisplay& display : mDisplays) {
2701 const auto displayId = display.getDisplayId();
2702 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2703 // Enable the callback
2704 ASSERT_TRUE(mComposerClient
2705 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2706 /*enabled*/ true)
2707 .isOk());
2708 std::this_thread::sleep_for(100ms);
ramindani9dd8c482023-02-21 18:07:56 -08002709
ramindania2a6dea2023-12-11 13:42:36 -08002710 const auto [status, configId] = mComposerClient->getActiveConfig(display.getDisplayId());
2711 EXPECT_TRUE(status.isOk());
ramindani9dd8c482023-02-21 18:07:56 -08002712
ramindania2a6dea2023-12-11 13:42:36 -08002713 const auto displayFilter = [&](auto refreshRateChangedDebugData) {
2714 bool nonVrrRateMatching = true;
2715 if (std::optional<VrrConfig> vrrConfigOpt =
2716 display.getDisplayConfig(configId).vrrConfig;
2717 getInterfaceVersion() >= 3 && !vrrConfigOpt) {
2718 nonVrrRateMatching = refreshRateChangedDebugData.refreshPeriodNanos ==
2719 refreshRateChangedDebugData.vsyncPeriodNanos;
2720 }
2721 const bool isDisplaySame =
2722 display.getDisplayId() == refreshRateChangedDebugData.display;
2723 return nonVrrRateMatching && isDisplaySame;
2724 };
ramindani9dd8c482023-02-21 18:07:56 -08002725
ramindania2a6dea2023-12-11 13:42:36 -08002726 // Check that we immediately got a callback
2727 EXPECT_TRUE(checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter));
2728
2729 ASSERT_TRUE(mComposerClient
2730 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2731 /*enabled*/ false)
2732 .isOk());
2733 }
ramindani9dd8c482023-02-21 18:07:56 -08002734}
2735
ramindani12423f52023-06-14 20:04:51 -07002736TEST_P(GraphicsComposerAidlCommandV2Test,
ramindani9dd8c482023-02-21 18:07:56 -08002737 SetRefreshRateChangedCallbackDebugEnabled_noCallbackWhenIdle) {
2738 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2739 GTEST_SUCCEED() << "Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG is not supported";
2740 return;
2741 }
2742
2743 auto display = getEditablePrimaryDisplay();
2744 const auto displayId = display.getDisplayId();
2745
2746 if (!hasDisplayCapability(displayId, DisplayCapability::DISPLAY_IDLE_TIMER)) {
2747 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2748 return;
2749 }
2750
2751 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2752 EXPECT_TRUE(mComposerClient->setPeakRefreshRateConfig(&display).isOk());
2753
2754 ASSERT_TRUE(mComposerClient->setIdleTimerEnabled(displayId, /*timeoutMs*/ 500).isOk());
2755 // Enable the callback
2756 ASSERT_TRUE(mComposerClient
2757 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2758 /*enabled*/ true)
2759 .isOk());
2760
ramindani91518892023-03-03 16:55:09 +00002761 const auto displayFilter = [displayId](auto refreshRateChangedDebugData) {
2762 return displayId == refreshRateChangedDebugData.display;
2763 };
ramindani9dd8c482023-02-21 18:07:56 -08002764
2765 int retryCount = 3;
2766 do {
2767 // Wait for 1s so that we enter the idle state
2768 std::this_thread::sleep_for(1s);
ramindani91518892023-03-03 16:55:09 +00002769 if (!checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter)) {
ramindani9dd8c482023-02-21 18:07:56 -08002770 // DID NOT receive a callback, we are in the idle state.
2771 break;
2772 }
2773 } while (--retryCount > 0);
2774
2775 if (retryCount == 0) {
2776 GTEST_SUCCEED() << "Unable to enter the idle mode";
2777 return;
2778 }
2779
2780 // Send the REFRESH_RATE_INDICATOR update
2781 ASSERT_NO_FATAL_FAILURE(
2782 sendBufferUpdate(createOnScreenLayer(Composition::REFRESH_RATE_INDICATOR)));
2783 std::this_thread::sleep_for(1s);
ramindani91518892023-03-03 16:55:09 +00002784 EXPECT_FALSE(checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter))
ramindani9dd8c482023-02-21 18:07:56 -08002785 << "A callback should not be received for REFRESH_RATE_INDICATOR";
2786
2787 EXPECT_TRUE(mComposerClient
2788 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2789 /*enabled*/ false)
2790 .isOk());
2791}
2792
ramindani12423f52023-06-14 20:04:51 -07002793TEST_P(GraphicsComposerAidlCommandV2Test,
ramindani9dd8c482023-02-21 18:07:56 -08002794 SetRefreshRateChangedCallbackDebugEnabled_SetActiveConfigWithConstraints) {
2795 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2796 GTEST_SUCCEED() << "Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG is not supported";
2797 return;
2798 }
2799
2800 VsyncPeriodChangeConstraints constraints;
2801 constraints.seamlessRequired = false;
2802 constraints.desiredTimeNanos = systemTime();
2803
2804 for (VtsDisplay& display : mDisplays) {
2805 const auto displayId = display.getDisplayId();
2806 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2807
2808 // Enable the callback
2809 ASSERT_TRUE(mComposerClient
2810 ->setRefreshRateChangedCallbackDebugEnabled(displayId, /*enabled*/ true)
2811 .isOk());
2812
2813 forEachTwoConfigs(displayId, [&](int32_t config1, int32_t config2) {
2814 const int32_t vsyncPeriod1 = display.getDisplayConfig(config1).vsyncPeriod;
2815 const int32_t vsyncPeriod2 = display.getDisplayConfig(config2).vsyncPeriod;
2816
2817 if (vsyncPeriod1 == vsyncPeriod2) {
2818 return; // continue
2819 }
2820
2821 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
2822 sendRefreshFrame(display, nullptr);
2823
2824 const auto& [status, timeline] =
2825 mComposerClient->setActiveConfigWithConstraints(&display, config2, constraints);
2826 EXPECT_TRUE(status.isOk());
2827
2828 if (timeline.refreshRequired) {
2829 sendRefreshFrame(display, &timeline);
2830 }
2831
ramindani91518892023-03-03 16:55:09 +00002832 const auto callbackFilter = [displayId,
2833 vsyncPeriod2](auto refreshRateChangedDebugData) {
2834 constexpr int kVsyncThreshold = 1000;
2835 return displayId == refreshRateChangedDebugData.display &&
2836 std::abs(vsyncPeriod2 - refreshRateChangedDebugData.vsyncPeriodNanos) <=
2837 kVsyncThreshold;
2838 };
ramindani9dd8c482023-02-21 18:07:56 -08002839
2840 int retryCount = 3;
2841 do {
2842 std::this_thread::sleep_for(100ms);
ramindani91518892023-03-03 16:55:09 +00002843 if (checkIfCallbackRefreshRateChangedDebugEnabledReceived(callbackFilter)) {
ramindani9dd8c482023-02-21 18:07:56 -08002844 GTEST_SUCCEED() << "Received a callback successfully";
2845 break;
2846 }
2847 } while (--retryCount > 0);
2848
2849 if (retryCount == 0) {
2850 GTEST_FAIL() << "failed to get a callback for the display " << displayId
2851 << " with config " << config2;
2852 }
2853 });
2854
2855 EXPECT_TRUE(
2856 mComposerClient
2857 ->setRefreshRateChangedCallbackDebugEnabled(displayId, /*enabled*/ false)
2858 .isOk());
2859 }
2860}
2861
Joen Chene0a962c2023-08-28 09:49:11 +00002862TEST_P(GraphicsComposerAidlCommandTest, MultiThreadedPresent) {
2863 std::vector<VtsDisplay*> displays;
2864 for (auto& display : mDisplays) {
2865 if (hasDisplayCapability(display.getDisplayId(),
2866 DisplayCapability::MULTI_THREADED_PRESENT)) {
2867 displays.push_back(&display);
2868 }
2869 }
2870
2871 const size_t numDisplays = displays.size();
2872 if (numDisplays <= 1u) {
2873 GTEST_SKIP();
2874 }
2875
2876 // When multi-threaded, use a reader per display. As with mWriters, this mutex
2877 // guards access to the map.
2878 std::mutex readersMutex;
2879 std::unordered_map<int64_t, ComposerClientReader> readers;
2880 std::vector<std::thread> threads;
2881 threads.reserve(numDisplays);
2882
2883 // Each display will have a layer to present. This maps from the display to
2884 // the layer, so we can properly destroy each layer at the end.
2885 std::unordered_map<int64_t, int64_t> layers;
2886
2887 for (auto* const display : displays) {
2888 const int64_t displayId = display->getDisplayId();
2889
2890 // Ensure that all writers and readers have been added to their respective
2891 // maps initially, so that the following loop never modifies the maps. The
2892 // maps are accessed from different threads, and if the maps were modified,
2893 // this would invalidate their iterators, and therefore references to the
2894 // writers and readers.
2895 auto& writer = getWriter(displayId);
2896 {
2897 std::lock_guard guard{readersMutex};
2898 readers.try_emplace(displayId, displayId);
2899 }
2900
2901 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2902
Ady Abrahama00d2462023-12-26 14:21:20 -08002903 const auto& [status, layer] =
2904 mComposerClient->createLayer(displayId, kBufferSlotCount, &writer);
Joen Chene0a962c2023-08-28 09:49:11 +00002905 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2906 ASSERT_NE(nullptr, buffer);
2907 ASSERT_EQ(::android::OK, buffer->initCheck());
2908 ASSERT_NE(nullptr, buffer->handle);
2909
2910 configureLayer(*display, layer, Composition::DEVICE, display->getFrameRect(),
2911 display->getCrop());
2912 writer.setLayerBuffer(displayId, layer, /*slot*/ 0, buffer->handle,
2913 /*acquireFence*/ -1);
2914 writer.setLayerDataspace(displayId, layer, common::Dataspace::UNKNOWN);
2915 layers.try_emplace(displayId, layer);
2916 }
2917
2918 for (auto* const display : displays) {
2919 const int64_t displayId = display->getDisplayId();
2920 auto& writer = getWriter(displayId);
2921 std::unique_lock lock{readersMutex};
2922 auto& reader = readers.at(displayId);
2923 lock.unlock();
2924
ramindanicdcfcaf2023-11-09 10:00:10 -08002925 writer.validateDisplay(displayId, ComposerClientWriter::kNoTimestamp,
2926 VtsComposerClient::kNoFrameIntervalNs);
Joen Chene0a962c2023-08-28 09:49:11 +00002927 execute(writer, reader);
2928
2929 threads.emplace_back([this, displayId, &readers, &readersMutex]() {
2930 auto& writer = getWriter(displayId);
2931 std::unique_lock lock{readersMutex};
2932 ComposerClientReader& reader = readers.at(displayId);
2933 lock.unlock();
2934
2935 writer.presentDisplay(displayId);
2936 execute(writer, reader);
2937 ASSERT_TRUE(reader.takeErrors().empty());
2938
2939 auto presentFence = reader.takePresentFence(displayId);
2940 // take ownership
2941 const int fenceOwner = presentFence.get();
2942 *presentFence.getR() = -1;
2943 EXPECT_NE(-1, fenceOwner);
2944 const auto presentFence2 = sp<::android::Fence>::make(fenceOwner);
2945 presentFence2->waitForever(LOG_TAG);
2946 });
2947 }
2948
2949 for (auto& thread : threads) {
2950 thread.join();
2951 }
2952
2953 for (auto& [displayId, layer] : layers) {
Ady Abrahama00d2462023-12-26 14:21:20 -08002954 auto& writer = getWriter(displayId);
2955 EXPECT_TRUE(mComposerClient->destroyLayer(displayId, layer, &writer).isOk());
Joen Chene0a962c2023-08-28 09:49:11 +00002956 }
2957
2958 std::lock_guard guard{readersMutex};
2959 for (auto& [displayId, reader] : readers) {
2960 ASSERT_TRUE(reader.takeErrors().empty());
2961 ASSERT_TRUE(reader.takeChangedCompositionTypes(displayId).empty());
2962 }
2963}
2964
Ady Abrahama00d2462023-12-26 14:21:20 -08002965class GraphicsComposerAidlCommandV3Test : public GraphicsComposerAidlCommandTest {
Manali Bhutiyani38565cc2023-11-11 06:16:24 +00002966 protected:
2967 void SetUp() override {
Ady Abrahama00d2462023-12-26 14:21:20 -08002968 GraphicsComposerAidlTest::SetUp();
Manali Bhutiyani38565cc2023-11-11 06:16:24 +00002969 if (getInterfaceVersion() <= 2) {
2970 GTEST_SKIP() << "Device interface version is expected to be >= 3";
2971 }
2972 }
Manali Bhutiyani38565cc2023-11-11 06:16:24 +00002973};
2974
Ady Abrahama00d2462023-12-26 14:21:20 -08002975TEST_P(GraphicsComposerAidlCommandV3Test, CreateBatchedCommand) {
2976 if (!hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
2977 GTEST_SKIP() << "LAYER_LIFECYCLE_BATCH_COMMAND not supported by the implementation";
2978 return;
2979 }
2980
Manali Bhutiyani38565cc2023-11-11 06:16:24 +00002981 auto& writer = getWriter(getPrimaryDisplayId());
2982 int64_t layer = 5;
2983 writer.setLayerLifecycleBatchCommandType(getPrimaryDisplayId(), layer,
2984 LayerLifecycleBatchCommandType::CREATE);
2985 writer.setNewBufferSlotCount(getPrimaryDisplayId(), layer, 1);
2986 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
2987 VtsComposerClient::kNoFrameIntervalNs);
2988 execute();
2989 ASSERT_TRUE(mReader.takeErrors().empty());
2990}
2991
Ady Abrahama00d2462023-12-26 14:21:20 -08002992TEST_P(GraphicsComposerAidlCommandV3Test, CreateBatchedCommand_BadDisplay) {
2993 if (!hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
2994 GTEST_SKIP() << "LAYER_LIFECYCLE_BATCH_COMMAND not supported by the implementation";
2995 return;
2996 }
2997
2998 auto& writer = getWriter(getPrimaryDisplayId());
2999 int64_t layer = 5;
3000 writer.setLayerLifecycleBatchCommandType(getInvalidDisplayId(), layer,
3001 LayerLifecycleBatchCommandType::CREATE);
3002 writer.setNewBufferSlotCount(getPrimaryDisplayId(), layer, 1);
3003 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
3004 VtsComposerClient::kNoFrameIntervalNs);
3005 execute();
3006 const auto errors = mReader.takeErrors();
3007 ASSERT_TRUE(errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_BAD_DISPLAY);
3008}
3009
3010TEST_P(GraphicsComposerAidlCommandV3Test, DestroyBatchedCommand) {
3011 if (!hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
3012 GTEST_SKIP() << "LAYER_LIFECYCLE_BATCH_COMMAND not supported by the implementation";
3013 return;
3014 }
3015
Manali Bhutiyani38565cc2023-11-11 06:16:24 +00003016 auto& writer = getWriter(getPrimaryDisplayId());
3017 int64_t layer = 5;
3018 writer.setLayerLifecycleBatchCommandType(getPrimaryDisplayId(), layer,
3019 LayerLifecycleBatchCommandType::CREATE);
3020 writer.setNewBufferSlotCount(getPrimaryDisplayId(), layer, 1);
3021 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
3022 VtsComposerClient::kNoFrameIntervalNs);
3023 execute();
3024 ASSERT_TRUE(mReader.takeErrors().empty());
3025 writer.setLayerLifecycleBatchCommandType(getPrimaryDisplayId(), layer,
3026 LayerLifecycleBatchCommandType::DESTROY);
3027 layer++;
3028 writer.setLayerLifecycleBatchCommandType(getPrimaryDisplayId(), layer,
3029 LayerLifecycleBatchCommandType::CREATE);
3030 writer.setNewBufferSlotCount(getPrimaryDisplayId(), layer, 1);
3031
3032 execute();
Ady Abrahama00d2462023-12-26 14:21:20 -08003033 const auto errors = mReader.takeErrors();
3034 ASSERT_TRUE(errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_BAD_DISPLAY);
3035}
3036
3037TEST_P(GraphicsComposerAidlCommandV3Test, DestroyBatchedCommand_BadDisplay) {
3038 if (!hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
3039 GTEST_SKIP() << "LAYER_LIFECYCLE_BATCH_COMMAND not supported by the implementation";
3040 return;
3041 }
3042
3043 auto& writer = getWriter(getPrimaryDisplayId());
3044 int64_t layer = 5;
3045 writer.setLayerLifecycleBatchCommandType(getPrimaryDisplayId(), layer,
3046 LayerLifecycleBatchCommandType::CREATE);
3047 writer.setNewBufferSlotCount(getPrimaryDisplayId(), layer, 1);
3048 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
3049 VtsComposerClient::kNoFrameIntervalNs);
3050 execute();
3051 ASSERT_TRUE(mReader.takeErrors().empty());
3052 writer.setLayerLifecycleBatchCommandType(getInvalidDisplayId(), layer,
3053 LayerLifecycleBatchCommandType::DESTROY);
3054 layer++;
3055 writer.setLayerLifecycleBatchCommandType(getInvalidDisplayId(), layer,
3056 LayerLifecycleBatchCommandType::CREATE);
3057 writer.setNewBufferSlotCount(getPrimaryDisplayId(), layer, 1);
3058
3059 execute();
Manali Bhutiyani38565cc2023-11-11 06:16:24 +00003060 ASSERT_TRUE(mReader.takeErrors().empty());
3061}
3062
Ady Abrahama00d2462023-12-26 14:21:20 -08003063TEST_P(GraphicsComposerAidlCommandV3Test, NoCreateDestroyBatchedCommandIncorrectLayer) {
3064 if (!hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
3065 GTEST_SKIP() << "LAYER_LIFECYCLE_BATCH_COMMAND not supported by the implementation";
3066 return;
3067 }
3068
Manali Bhutiyani38565cc2023-11-11 06:16:24 +00003069 auto& writer = getWriter(getPrimaryDisplayId());
3070 int64_t layer = 5;
3071 writer.setLayerLifecycleBatchCommandType(getPrimaryDisplayId(), layer,
3072 LayerLifecycleBatchCommandType::DESTROY);
3073 execute();
3074 const auto errors = mReader.takeErrors();
3075 ASSERT_TRUE(errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_BAD_LAYER);
3076}
3077
ramindanidcfe3a82021-11-29 17:00:31 +00003078GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlCommandTest);
3079INSTANTIATE_TEST_SUITE_P(
3080 PerInstance, GraphicsComposerAidlCommandTest,
3081 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
3082 ::android::PrintInstanceNameToString);
ramindanid32ae8e2021-10-01 18:48:39 +00003083GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlTest);
3084INSTANTIATE_TEST_SUITE_P(
3085 PerInstance, GraphicsComposerAidlTest,
3086 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
3087 ::android::PrintInstanceNameToString);
ramindani12423f52023-06-14 20:04:51 -07003088GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlV2Test);
3089INSTANTIATE_TEST_SUITE_P(
3090 PerInstance, GraphicsComposerAidlV2Test,
3091 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
3092 ::android::PrintInstanceNameToString);
ramindani02fe4772023-06-30 18:04:41 -07003093GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlV3Test);
3094INSTANTIATE_TEST_SUITE_P(
3095 PerInstance, GraphicsComposerAidlV3Test,
3096 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
3097 ::android::PrintInstanceNameToString);
ramindani12423f52023-06-14 20:04:51 -07003098GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlCommandV2Test);
3099INSTANTIATE_TEST_SUITE_P(
3100 PerInstance, GraphicsComposerAidlCommandV2Test,
3101 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
3102 ::android::PrintInstanceNameToString);
Ady Abrahama00d2462023-12-26 14:21:20 -08003103GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlCommandV3Test);
3104INSTANTIATE_TEST_SUITE_P(
3105 PerInstance, GraphicsComposerAidlCommandV3Test,
3106 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
3107 ::android::PrintInstanceNameToString);
ramindanid32ae8e2021-10-01 18:48:39 +00003108} // namespace aidl::android::hardware::graphics::composer3::vts
3109
3110int main(int argc, char** argv) {
3111 ::testing::InitGoogleTest(&argc, argv);
3112
3113 using namespace std::chrono_literals;
3114 if (!android::base::WaitForProperty("init.svc.surfaceflinger", "stopped", 10s)) {
3115 ALOGE("Failed to stop init.svc.surfaceflinger");
3116 return -1;
3117 }
ramindanibeea10e2021-12-07 21:02:49 +00003118
3119 android::ProcessState::self()->setThreadPoolMaxThreadCount(4);
3120
3121 // The binder threadpool we start will inherit sched policy and priority
3122 // of (this) creating thread. We want the binder thread pool to have
3123 // SCHED_FIFO policy and priority 1 (lowest RT priority)
3124 // Once the pool is created we reset this thread's priority back to
3125 // original.
3126 // This thread policy is based on what we do in the SurfaceFlinger while starting
3127 // the thread pool and we need to replicate that for the VTS tests.
3128 int newPriority = 0;
3129 int origPolicy = sched_getscheduler(0);
3130 struct sched_param origSchedParam;
3131
3132 int errorInPriorityModification = sched_getparam(0, &origSchedParam);
3133 if (errorInPriorityModification == 0) {
3134 int policy = SCHED_FIFO;
3135 newPriority = sched_get_priority_min(policy);
3136
3137 struct sched_param param;
3138 param.sched_priority = newPriority;
3139
3140 errorInPriorityModification = sched_setscheduler(0, policy, &param);
3141 }
3142
3143 // start the thread pool
3144 android::ProcessState::self()->startThreadPool();
3145
3146 // Reset current thread's policy and priority
3147 if (errorInPriorityModification == 0) {
3148 errorInPriorityModification = sched_setscheduler(0, origPolicy, &origSchedParam);
3149 } else {
3150 ALOGE("Failed to set VtsHalGraphicsComposer3_TargetTest binder threadpool priority to "
3151 "SCHED_FIFO");
3152 }
3153
ramindanid32ae8e2021-10-01 18:48:39 +00003154 return RUN_ALL_TESTS();
Leon Scroggins III45095052023-03-23 18:23:15 -04003155}