1 /**
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 */
16
17 #include <aidl/Gtest.h>
18 #include <aidl/Vintf.h>
19 #include <aidl/android/hardware/graphics/common/BlendMode.h>
20 #include <aidl/android/hardware/graphics/common/BufferUsage.h>
21 #include <aidl/android/hardware/graphics/common/FRect.h>
22 #include <aidl/android/hardware/graphics/common/PixelFormat.h>
23 #include <aidl/android/hardware/graphics/common/Rect.h>
24 #include <aidl/android/hardware/graphics/composer3/Composition.h>
25 #include <aidl/android/hardware/graphics/composer3/IComposer.h>
26 #include <android-base/properties.h>
27 #include <android/binder_process.h>
28 #include <android/hardware/graphics/composer3/ComposerClientReader.h>
29 #include <android/hardware/graphics/composer3/ComposerClientWriter.h>
30 #include <binder/ProcessState.h>
31 #include <gtest/gtest.h>
32 #include <ui/Fence.h>
33 #include <ui/GraphicBuffer.h>
34 #include <ui/PixelFormat.h>
35 #include <algorithm>
36 #include <iterator>
37 #include <numeric>
38 #include <string>
39 #include <thread>
40 #include <unordered_map>
41 #include "GraphicsComposerCallback.h"
42 #include "VtsComposerClient.h"
43
44 #undef LOG_TAG
45 #define LOG_TAG "VtsHalGraphicsComposer3_TargetTest"
46
47 namespace aidl::android::hardware::graphics::composer3::vts {
48 namespace {
49
50 using namespace std::chrono_literals;
51
52 using ::android::GraphicBuffer;
53 using ::android::sp;
54
55 class GraphicsComposerAidlTest : public ::testing::TestWithParam<std::string> {
56 protected:
SetUp()57 void SetUp() override {
58 mComposerClient = std::make_unique<VtsComposerClient>(GetParam());
59 ASSERT_TRUE(mComposerClient->createClient().isOk());
60
61 const auto& [status, displays] = mComposerClient->getDisplays();
62 ASSERT_TRUE(status.isOk());
63 mDisplays = displays;
64
65 // explicitly disable vsync
66 for (const auto& display : mDisplays) {
67 EXPECT_TRUE(mComposerClient->setVsync(display.getDisplayId(), false).isOk());
68 }
69 mComposerClient->setVsyncAllowed(false);
70 }
71
TearDown()72 void TearDown() override {
73 ASSERT_TRUE(mComposerClient->tearDown());
74 mComposerClient.reset();
75 }
76
assertServiceSpecificError(const ScopedAStatus & status,int32_t serviceSpecificError)77 void assertServiceSpecificError(const ScopedAStatus& status, int32_t serviceSpecificError) {
78 ASSERT_EQ(status.getExceptionCode(), EX_SERVICE_SPECIFIC);
79 ASSERT_EQ(status.getServiceSpecificError(), serviceSpecificError);
80 }
81
Test_setContentTypeForDisplay(int64_t display,const std::vector<ContentType> & supportedContentTypes,ContentType contentType,const char * contentTypeStr)82 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();
88
89 if (!contentTypeSupport) {
90 const auto& status = mComposerClient->setContentType(display, contentType);
91 EXPECT_FALSE(status.isOk());
92 EXPECT_NO_FATAL_FAILURE(
93 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
94 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
Test_setContentType(ContentType contentType,const char * contentTypeStr)103 void Test_setContentType(ContentType contentType, const char* contentTypeStr) {
104 for (const auto& display : mDisplays) {
105 const auto& [status, supportedContentTypes] =
106 mComposerClient->getSupportedContentTypes(display.getDisplayId());
107 EXPECT_TRUE(status.isOk());
108 Test_setContentTypeForDisplay(display.getDisplayId(), supportedContentTypes,
109 contentType, contentTypeStr);
110 }
111 }
112
hasCapability(Capability capability)113 bool hasCapability(Capability capability) {
114 const auto& [status, capabilities] = mComposerClient->getCapabilities();
115 EXPECT_TRUE(status.isOk());
116 return std::any_of(
117 capabilities.begin(), capabilities.end(),
118 [&](const Capability& activeCapability) { return activeCapability == capability; });
119 }
120
getInterfaceVersion()121 int getInterfaceVersion() {
122 const auto& [versionStatus, version] = mComposerClient->getInterfaceVersion();
123 EXPECT_TRUE(versionStatus.isOk());
124 return version;
125 }
126
getPrimaryDisplay() const127 const VtsDisplay& getPrimaryDisplay() const { return mDisplays[0]; }
128
getPrimaryDisplayId() const129 int64_t getPrimaryDisplayId() const { return getPrimaryDisplay().getDisplayId(); }
130
getInvalidDisplayId() const131 int64_t getInvalidDisplayId() const { return mComposerClient->getInvalidDisplayId(); }
132
getEditablePrimaryDisplay()133 VtsDisplay& getEditablePrimaryDisplay() { return mDisplays[0]; }
134
135 struct TestParameters {
136 nsecs_t delayForChange;
137 bool refreshMiss;
138 };
139
140 std::unique_ptr<VtsComposerClient> mComposerClient;
141 std::vector<VtsDisplay> mDisplays;
142 // use the slot count usually set by SF
143 static constexpr uint32_t kBufferSlotCount = 64;
144 };
145
TEST_P(GraphicsComposerAidlTest,GetDisplayCapabilities_BadDisplay)146 TEST_P(GraphicsComposerAidlTest, GetDisplayCapabilities_BadDisplay) {
147 const auto& [status, _] = mComposerClient->getDisplayCapabilities(getInvalidDisplayId());
148
149 EXPECT_FALSE(status.isOk());
150 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
151 }
152
TEST_P(GraphicsComposerAidlTest,GetDisplayCapabilities)153 TEST_P(GraphicsComposerAidlTest, GetDisplayCapabilities) {
154 for (const auto& display : mDisplays) {
155 const auto& [status, capabilities] =
156 mComposerClient->getDisplayCapabilities(display.getDisplayId());
157
158 EXPECT_TRUE(status.isOk());
159 }
160 }
161
TEST_P(GraphicsComposerAidlTest,DumpDebugInfo)162 TEST_P(GraphicsComposerAidlTest, DumpDebugInfo) {
163 ASSERT_TRUE(mComposerClient->dumpDebugInfo().isOk());
164 }
165
TEST_P(GraphicsComposerAidlTest,CreateClientSingleton)166 TEST_P(GraphicsComposerAidlTest, CreateClientSingleton) {
167 std::shared_ptr<IComposerClient> composerClient;
168 const auto& status = mComposerClient->createClient();
169
170 EXPECT_FALSE(status.isOk());
171 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_NO_RESOURCES));
172 }
173
TEST_P(GraphicsComposerAidlTest,GetDisplayIdentificationData)174 TEST_P(GraphicsComposerAidlTest, GetDisplayIdentificationData) {
175 const auto& [status0, displayIdentification0] =
176 mComposerClient->getDisplayIdentificationData(getPrimaryDisplayId());
177 if (!status0.isOk() && status0.getExceptionCode() == EX_SERVICE_SPECIFIC &&
178 status0.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
179 GTEST_SUCCEED() << "Display identification data not supported, skipping test";
180 return;
181 }
182 ASSERT_TRUE(status0.isOk()) << "failed to get display identification data";
183 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
198 const auto& [status1, displayIdentification1] =
199 mComposerClient->getDisplayIdentificationData(getPrimaryDisplayId());
200 ASSERT_TRUE(status1.isOk());
201
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
TEST_P(GraphicsComposerAidlTest,GetHdrCapabilities)209 TEST_P(GraphicsComposerAidlTest, GetHdrCapabilities) {
210 const auto& [status, hdrCapabilities] =
211 mComposerClient->getHdrCapabilities(getPrimaryDisplayId());
212
213 ASSERT_TRUE(status.isOk());
214 EXPECT_TRUE(hdrCapabilities.maxLuminance >= hdrCapabilities.minLuminance);
215 }
216
TEST_P(GraphicsComposerAidlTest,GetPerFrameMetadataKeys)217 TEST_P(GraphicsComposerAidlTest, GetPerFrameMetadataKeys) {
218 const auto& [status, keys] = mComposerClient->getPerFrameMetadataKeys(getPrimaryDisplayId());
219 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
220 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
221 GTEST_SUCCEED() << "getPerFrameMetadataKeys is not supported";
222 return;
223 }
224
225 ASSERT_TRUE(status.isOk());
226 EXPECT_TRUE(keys.size() >= 0);
227 }
228
TEST_P(GraphicsComposerAidlTest,GetReadbackBufferAttributes)229 TEST_P(GraphicsComposerAidlTest, GetReadbackBufferAttributes) {
230 const auto& [status, _] = mComposerClient->getReadbackBufferAttributes(getPrimaryDisplayId());
231 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
232 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
233 GTEST_SUCCEED() << "getReadbackBufferAttributes is not supported";
234 return;
235 }
236
237 ASSERT_TRUE(status.isOk());
238 }
239
TEST_P(GraphicsComposerAidlTest,GetRenderIntents)240 TEST_P(GraphicsComposerAidlTest, GetRenderIntents) {
241 const auto& [status, modes] = mComposerClient->getColorModes(getPrimaryDisplayId());
242 EXPECT_TRUE(status.isOk());
243
244 for (auto mode : modes) {
245 const auto& [intentStatus, intents] =
246 mComposerClient->getRenderIntents(getPrimaryDisplayId(), mode);
247 EXPECT_TRUE(intentStatus.isOk());
248 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
261 const auto iter = std::find(intents.cbegin(), intents.cend(), requiredIntent);
262 EXPECT_NE(intents.cend(), iter);
263 }
264 }
265
TEST_P(GraphicsComposerAidlTest,GetRenderIntents_BadDisplay)266 TEST_P(GraphicsComposerAidlTest, GetRenderIntents_BadDisplay) {
267 const auto& [status, modes] = mComposerClient->getColorModes(getPrimaryDisplayId());
268 ASSERT_TRUE(status.isOk());
269
270 for (auto mode : modes) {
271 const auto& [intentStatus, _] =
272 mComposerClient->getRenderIntents(getInvalidDisplayId(), mode);
273
274 EXPECT_FALSE(intentStatus.isOk());
275 EXPECT_NO_FATAL_FAILURE(
276 assertServiceSpecificError(intentStatus, IComposerClient::EX_BAD_DISPLAY));
277 }
278 }
279
TEST_P(GraphicsComposerAidlTest,GetRenderIntents_BadParameter)280 TEST_P(GraphicsComposerAidlTest, GetRenderIntents_BadParameter) {
281 const auto& [status, _] =
282 mComposerClient->getRenderIntents(getPrimaryDisplayId(), static_cast<ColorMode>(-1));
283
284 EXPECT_FALSE(status.isOk());
285 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
286 }
287
TEST_P(GraphicsComposerAidlTest,GetColorModes)288 TEST_P(GraphicsComposerAidlTest, GetColorModes) {
289 const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
290 ASSERT_TRUE(status.isOk());
291
292 const auto native = std::find(colorModes.cbegin(), colorModes.cend(), ColorMode::NATIVE);
293 EXPECT_NE(colorModes.cend(), native);
294 }
295
TEST_P(GraphicsComposerAidlTest,GetColorMode_BadDisplay)296 TEST_P(GraphicsComposerAidlTest, GetColorMode_BadDisplay) {
297 const auto& [status, _] = mComposerClient->getColorModes(getInvalidDisplayId());
298
299 EXPECT_FALSE(status.isOk());
300 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
301 }
302
TEST_P(GraphicsComposerAidlTest,SetColorMode)303 TEST_P(GraphicsComposerAidlTest, SetColorMode) {
304 const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
305 EXPECT_TRUE(status.isOk());
306
307 for (auto mode : colorModes) {
308 const auto& [intentStatus, intents] =
309 mComposerClient->getRenderIntents(getPrimaryDisplayId(), mode);
310 EXPECT_TRUE(intentStatus.isOk()) << "failed to get render intents";
311
312 for (auto intent : intents) {
313 const auto modeStatus =
314 mComposerClient->setColorMode(getPrimaryDisplayId(), mode, intent);
315 EXPECT_TRUE(modeStatus.isOk() ||
316 (modeStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
317 IComposerClient::EX_UNSUPPORTED == modeStatus.getServiceSpecificError()))
318 << "failed to set color mode";
319 }
320 }
321
322 const auto modeStatus = mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE,
323 RenderIntent::COLORIMETRIC);
324 EXPECT_TRUE(modeStatus.isOk() ||
325 (modeStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
326 IComposerClient::EX_UNSUPPORTED == modeStatus.getServiceSpecificError()))
327 << "failed to set color mode";
328 }
329
TEST_P(GraphicsComposerAidlTest,SetColorMode_BadDisplay)330 TEST_P(GraphicsComposerAidlTest, SetColorMode_BadDisplay) {
331 const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
332 ASSERT_TRUE(status.isOk());
333
334 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());
344 EXPECT_NO_FATAL_FAILURE(
345 assertServiceSpecificError(modeStatus, IComposerClient::EX_BAD_DISPLAY));
346 }
347 }
348 }
349
TEST_P(GraphicsComposerAidlTest,SetColorMode_BadParameter)350 TEST_P(GraphicsComposerAidlTest, SetColorMode_BadParameter) {
351 auto status = mComposerClient->setColorMode(getPrimaryDisplayId(), static_cast<ColorMode>(-1),
352 RenderIntent::COLORIMETRIC);
353
354 EXPECT_FALSE(status.isOk());
355 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
356
357 status = mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE,
358 static_cast<RenderIntent>(-1));
359
360 EXPECT_FALSE(status.isOk());
361 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
362 }
363
TEST_P(GraphicsComposerAidlTest,GetDisplayedContentSamplingAttributes)364 TEST_P(GraphicsComposerAidlTest, GetDisplayedContentSamplingAttributes) {
365 int constexpr kInvalid = -1;
366 const auto& [status, format] =
367 mComposerClient->getDisplayedContentSamplingAttributes(getPrimaryDisplayId());
368
369 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
370 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
371 SUCCEED() << "Device does not support optional extension. Test skipped";
372 return;
373 }
374
375 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));
379 };
380
TEST_P(GraphicsComposerAidlTest,SetDisplayedContentSamplingEnabled)381 TEST_P(GraphicsComposerAidlTest, SetDisplayedContentSamplingEnabled) {
382 int constexpr kMaxFrames = 10;
383 FormatColorComponent enableAllComponents = FormatColorComponent::FORMAT_COMPONENT_0;
384 auto status = mComposerClient->setDisplayedContentSamplingEnabled(
385 getPrimaryDisplayId(), /*isEnabled*/ true, enableAllComponents, kMaxFrames);
386 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
387 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
388 SUCCEED() << "Device does not support optional extension. Test skipped";
389 return;
390 }
391 EXPECT_TRUE(status.isOk());
392
393 status = mComposerClient->setDisplayedContentSamplingEnabled(
394 getPrimaryDisplayId(), /*isEnabled*/ false, enableAllComponents, kMaxFrames);
395 EXPECT_TRUE(status.isOk());
396 }
397
TEST_P(GraphicsComposerAidlTest,GetDisplayedContentSample)398 TEST_P(GraphicsComposerAidlTest, GetDisplayedContentSample) {
399 const auto& [status, displayContentSamplingAttributes] =
400 mComposerClient->getDisplayedContentSamplingAttributes(getPrimaryDisplayId());
401 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
402 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
403 SUCCEED() << "Sampling attributes aren't supported on this device, test skipped";
404 return;
405 }
406
407 int64_t constexpr kMaxFrames = 10;
408 int64_t constexpr kTimestamp = 0;
409 const auto& [sampleStatus, displayContentSample] = mComposerClient->getDisplayedContentSample(
410 getPrimaryDisplayId(), kMaxFrames, kTimestamp);
411 if (!sampleStatus.isOk() && sampleStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
412 sampleStatus.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
413 SUCCEED() << "Device does not support optional extension. Test skipped";
414 return;
415 }
416
417 EXPECT_TRUE(sampleStatus.isOk());
418 const std::vector<std::vector<int64_t>> histogram = {
419 displayContentSample.sampleComponent0, displayContentSample.sampleComponent1,
420 displayContentSample.sampleComponent2, displayContentSample.sampleComponent3};
421
422 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());
426 }
427 }
428
TEST_P(GraphicsComposerAidlTest,GetDisplayConnectionType)429 TEST_P(GraphicsComposerAidlTest, GetDisplayConnectionType) {
430 const auto& [status, type] = mComposerClient->getDisplayConnectionType(getInvalidDisplayId());
431
432 EXPECT_FALSE(status.isOk());
433 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
434
435 for (const auto& display : mDisplays) {
436 const auto& [connectionTypeStatus, _] =
437 mComposerClient->getDisplayConnectionType(display.getDisplayId());
438 EXPECT_TRUE(connectionTypeStatus.isOk());
439 }
440 }
441
TEST_P(GraphicsComposerAidlTest,GetDisplayAttribute)442 TEST_P(GraphicsComposerAidlTest, GetDisplayAttribute) {
443 for (const auto& display : mDisplays) {
444 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
445 EXPECT_TRUE(status.isOk());
446
447 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 }};
454 for (const auto& attribute : requiredAttributes) {
455 const auto& [attribStatus, value] = mComposerClient->getDisplayAttribute(
456 display.getDisplayId(), config, attribute);
457 EXPECT_TRUE(attribStatus.isOk());
458 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) {
466 const auto& [attribStatus, value] = mComposerClient->getDisplayAttribute(
467 display.getDisplayId(), config, attribute);
468 EXPECT_TRUE(attribStatus.isOk() ||
469 (attribStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
470 IComposerClient::EX_UNSUPPORTED ==
471 attribStatus.getServiceSpecificError()));
472 }
473 }
474 }
475 }
476
TEST_P(GraphicsComposerAidlTest,CheckConfigsAreValid)477 TEST_P(GraphicsComposerAidlTest, CheckConfigsAreValid) {
478 for (const auto& display : mDisplays) {
479 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
480 EXPECT_TRUE(status.isOk());
481
482 EXPECT_FALSE(std::any_of(configs.begin(), configs.end(), [](auto config) {
483 return config == IComposerClient::INVALID_CONFIGURATION;
484 }));
485 }
486 }
487
TEST_P(GraphicsComposerAidlTest,GetDisplayVsyncPeriod_BadDisplay)488 TEST_P(GraphicsComposerAidlTest, GetDisplayVsyncPeriod_BadDisplay) {
489 const auto& [status, vsyncPeriodNanos] =
490 mComposerClient->getDisplayVsyncPeriod(getInvalidDisplayId());
491
492 EXPECT_FALSE(status.isOk());
493 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
494 }
495
TEST_P(GraphicsComposerAidlTest,SetActiveConfigWithConstraints_BadDisplay)496 TEST_P(GraphicsComposerAidlTest, SetActiveConfigWithConstraints_BadDisplay) {
497 VsyncPeriodChangeConstraints constraints;
498 constraints.seamlessRequired = false;
499 constraints.desiredTimeNanos = systemTime();
500 auto invalidDisplay = VtsDisplay(getInvalidDisplayId());
501
502 const auto& [status, timeline] = mComposerClient->setActiveConfigWithConstraints(
503 &invalidDisplay, /*config*/ 0, constraints);
504
505 EXPECT_FALSE(status.isOk());
506 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
507 }
508
TEST_P(GraphicsComposerAidlTest,SetActiveConfigWithConstraints_BadConfig)509 TEST_P(GraphicsComposerAidlTest, SetActiveConfigWithConstraints_BadConfig) {
510 VsyncPeriodChangeConstraints constraints;
511 constraints.seamlessRequired = false;
512 constraints.desiredTimeNanos = systemTime();
513
514 for (VtsDisplay& display : mDisplays) {
515 int32_t constexpr kInvalidConfigId = IComposerClient::INVALID_CONFIGURATION;
516 const auto& [status, _] = mComposerClient->setActiveConfigWithConstraints(
517 &display, kInvalidConfigId, constraints);
518
519 EXPECT_FALSE(status.isOk());
520 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_CONFIG));
521 }
522 }
523
TEST_P(GraphicsComposerAidlTest,SetBootDisplayConfig_BadDisplay)524 TEST_P(GraphicsComposerAidlTest, SetBootDisplayConfig_BadDisplay) {
525 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
526 GTEST_SUCCEED() << "Boot Display Config not supported";
527 return;
528 }
529 const auto& status = mComposerClient->setBootDisplayConfig(getInvalidDisplayId(), /*config*/ 0);
530
531 EXPECT_FALSE(status.isOk());
532 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
533 }
534
TEST_P(GraphicsComposerAidlTest,SetBootDisplayConfig_BadConfig)535 TEST_P(GraphicsComposerAidlTest, SetBootDisplayConfig_BadConfig) {
536 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
537 GTEST_SUCCEED() << "Boot Display Config not supported";
538 return;
539 }
540 for (VtsDisplay& display : mDisplays) {
541 int32_t constexpr kInvalidConfigId = IComposerClient::INVALID_CONFIGURATION;
542 const auto& status =
543 mComposerClient->setBootDisplayConfig(display.getDisplayId(), kInvalidConfigId);
544
545 EXPECT_FALSE(status.isOk());
546 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_CONFIG));
547 }
548 }
549
TEST_P(GraphicsComposerAidlTest,SetBootDisplayConfig)550 TEST_P(GraphicsComposerAidlTest, SetBootDisplayConfig) {
551 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
552 GTEST_SUCCEED() << "Boot Display Config not supported";
553 return;
554 }
555 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());
559 }
560 }
561
TEST_P(GraphicsComposerAidlTest,ClearBootDisplayConfig_BadDisplay)562 TEST_P(GraphicsComposerAidlTest, ClearBootDisplayConfig_BadDisplay) {
563 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
564 GTEST_SUCCEED() << "Boot Display Config not supported";
565 return;
566 }
567 const auto& status = mComposerClient->clearBootDisplayConfig(getInvalidDisplayId());
568
569 EXPECT_FALSE(status.isOk());
570 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
571 }
572
TEST_P(GraphicsComposerAidlTest,ClearBootDisplayConfig)573 TEST_P(GraphicsComposerAidlTest, ClearBootDisplayConfig) {
574 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
575 GTEST_SUCCEED() << "Boot Display Config not supported";
576 return;
577 }
578 EXPECT_TRUE(mComposerClient->clearBootDisplayConfig(getPrimaryDisplayId()).isOk());
579 }
580
TEST_P(GraphicsComposerAidlTest,GetPreferredBootDisplayConfig_BadDisplay)581 TEST_P(GraphicsComposerAidlTest, GetPreferredBootDisplayConfig_BadDisplay) {
582 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
583 GTEST_SUCCEED() << "Boot Display Config not supported";
584 return;
585 }
586 const auto& [status, _] = mComposerClient->getPreferredBootDisplayConfig(getInvalidDisplayId());
587
588 EXPECT_FALSE(status.isOk());
589 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
590 }
591
TEST_P(GraphicsComposerAidlTest,GetPreferredBootDisplayConfig)592 TEST_P(GraphicsComposerAidlTest, GetPreferredBootDisplayConfig) {
593 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
594 GTEST_SUCCEED() << "Boot Display Config not supported";
595 return;
596 }
597 const auto& [status, preferredDisplayConfig] =
598 mComposerClient->getPreferredBootDisplayConfig(getPrimaryDisplayId());
599 EXPECT_TRUE(status.isOk());
600
601 const auto& [configStatus, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
602
603 EXPECT_TRUE(configStatus.isOk());
604 EXPECT_NE(configs.end(), std::find(configs.begin(), configs.end(), preferredDisplayConfig));
605 }
606
TEST_P(GraphicsComposerAidlTest,BootDisplayConfig_Unsupported)607 TEST_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());
615 EXPECT_NO_FATAL_FAILURE(
616 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
617
618 status = mComposerClient->getPreferredBootDisplayConfig(getPrimaryDisplayId()).first;
619 EXPECT_FALSE(status.isOk());
620 EXPECT_NO_FATAL_FAILURE(
621 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
622
623 status = mComposerClient->clearBootDisplayConfig(getPrimaryDisplayId());
624 EXPECT_FALSE(status.isOk());
625 EXPECT_NO_FATAL_FAILURE(
626 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
627 }
628 }
629
TEST_P(GraphicsComposerAidlTest,GetHdrConversionCapabilities)630 TEST_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
TEST_P(GraphicsComposerAidlTest,SetHdrConversionStrategy_Passthrough)639 TEST_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);
646 const auto& [status, preferredHdrOutputType] =
647 mComposerClient->setHdrConversionStrategy(hdrConversionStrategy);
648 EXPECT_TRUE(status.isOk());
649 EXPECT_EQ(common::Hdr::INVALID, preferredHdrOutputType);
650 }
651
TEST_P(GraphicsComposerAidlTest,SetHdrConversionStrategy_Force)652 TEST_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();
658 const auto& [status2, hdrCapabilities] =
659 mComposerClient->getHdrCapabilities(getPrimaryDisplayId());
660 const auto& hdrTypes = hdrCapabilities.types;
661 for (auto conversionCapability : conversionCapabilities) {
662 if (conversionCapability.outputType != common::Hdr::INVALID) {
663 if (std::find(hdrTypes.begin(), hdrTypes.end(), conversionCapability.outputType) ==
664 hdrTypes.end()) {
665 continue;
666 }
667 common::HdrConversionStrategy hdrConversionStrategy;
668 hdrConversionStrategy.set<common::HdrConversionStrategy::Tag::forceHdrConversion>(
669 conversionCapability.outputType);
670 const auto& [statusSet, preferredHdrOutputType] =
671 mComposerClient->setHdrConversionStrategy(hdrConversionStrategy);
672 EXPECT_TRUE(statusSet.isOk());
673 EXPECT_EQ(common::Hdr::INVALID, preferredHdrOutputType);
674 }
675 }
676 }
677
TEST_P(GraphicsComposerAidlTest,SetHdrConversionStrategy_Auto)678 TEST_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();
684 const auto& [status2, hdrCapabilities] =
685 mComposerClient->getHdrCapabilities(getPrimaryDisplayId());
686 if (hdrCapabilities.types.size() <= 0) {
687 return;
688 }
689 std::vector<aidl::android::hardware::graphics::common::Hdr> autoHdrTypes;
690 for (auto conversionCapability : conversionCapabilities) {
691 if (conversionCapability.outputType != common::Hdr::INVALID) {
692 autoHdrTypes.push_back(conversionCapability.outputType);
693 }
694 }
695 common::HdrConversionStrategy hdrConversionStrategy;
696 hdrConversionStrategy.set<common::HdrConversionStrategy::Tag::autoAllowedHdrTypes>(
697 autoHdrTypes);
698 const auto& [statusSet, preferredHdrOutputType] =
699 mComposerClient->setHdrConversionStrategy(hdrConversionStrategy);
700 EXPECT_TRUE(statusSet.isOk());
701 EXPECT_NE(common::Hdr::INVALID, preferredHdrOutputType);
702 }
703
TEST_P(GraphicsComposerAidlTest,SetAutoLowLatencyMode_BadDisplay)704 TEST_P(GraphicsComposerAidlTest, SetAutoLowLatencyMode_BadDisplay) {
705 auto status = mComposerClient->setAutoLowLatencyMode(getInvalidDisplayId(), /*isEnabled*/ true);
706 EXPECT_FALSE(status.isOk());
707 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
708
709 status = mComposerClient->setAutoLowLatencyMode(getInvalidDisplayId(), /*isEnabled*/ false);
710 EXPECT_FALSE(status.isOk());
711 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
712 }
713
TEST_P(GraphicsComposerAidlTest,SetAutoLowLatencyMode)714 TEST_P(GraphicsComposerAidlTest, SetAutoLowLatencyMode) {
715 for (const auto& display : mDisplays) {
716 const auto& [status, capabilities] =
717 mComposerClient->getDisplayCapabilities(display.getDisplayId());
718 ASSERT_TRUE(status.isOk());
719
720 const bool allmSupport =
721 std::find(capabilities.begin(), capabilities.end(),
722 DisplayCapability::AUTO_LOW_LATENCY_MODE) != capabilities.end();
723
724 if (!allmSupport) {
725 const auto& statusIsOn = mComposerClient->setAutoLowLatencyMode(display.getDisplayId(),
726 /*isEnabled*/ true);
727 EXPECT_FALSE(statusIsOn.isOk());
728 EXPECT_NO_FATAL_FAILURE(
729 assertServiceSpecificError(statusIsOn, IComposerClient::EX_UNSUPPORTED));
730 const auto& statusIsOff = mComposerClient->setAutoLowLatencyMode(display.getDisplayId(),
731 /*isEnabled*/ false);
732 EXPECT_FALSE(statusIsOff.isOk());
733 EXPECT_NO_FATAL_FAILURE(
734 assertServiceSpecificError(statusIsOff, IComposerClient::EX_UNSUPPORTED));
735 GTEST_SUCCEED() << "Auto Low Latency Mode is not supported on display "
736 << std::to_string(display.getDisplayId()) << ", skipping test";
737 return;
738 }
739
740 EXPECT_TRUE(mComposerClient->setAutoLowLatencyMode(display.getDisplayId(), true).isOk());
741 EXPECT_TRUE(mComposerClient->setAutoLowLatencyMode(display.getDisplayId(), false).isOk());
742 }
743 }
744
TEST_P(GraphicsComposerAidlTest,GetSupportedContentTypes_BadDisplay)745 TEST_P(GraphicsComposerAidlTest, GetSupportedContentTypes_BadDisplay) {
746 const auto& [status, _] = mComposerClient->getSupportedContentTypes(getInvalidDisplayId());
747
748 EXPECT_FALSE(status.isOk());
749 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
750 }
751
TEST_P(GraphicsComposerAidlTest,GetSupportedContentTypes)752 TEST_P(GraphicsComposerAidlTest, GetSupportedContentTypes) {
753 for (const auto& display : mDisplays) {
754 const auto& [status, supportedContentTypes] =
755 mComposerClient->getSupportedContentTypes(display.getDisplayId());
756 ASSERT_TRUE(status.isOk());
757
758 const bool noneSupported =
759 std::find(supportedContentTypes.begin(), supportedContentTypes.end(),
760 ContentType::NONE) != supportedContentTypes.end();
761
762 EXPECT_FALSE(noneSupported);
763 }
764 }
765
TEST_P(GraphicsComposerAidlTest,SetContentTypeNoneAlwaysAccepted)766 TEST_P(GraphicsComposerAidlTest, SetContentTypeNoneAlwaysAccepted) {
767 for (const auto& display : mDisplays) {
768 EXPECT_TRUE(
769 mComposerClient->setContentType(display.getDisplayId(), ContentType::NONE).isOk());
770 }
771 }
772
TEST_P(GraphicsComposerAidlTest,SetContentType_BadDisplay)773 TEST_P(GraphicsComposerAidlTest, SetContentType_BadDisplay) {
774 constexpr ContentType types[] = {ContentType::NONE, ContentType::GRAPHICS, ContentType::PHOTO,
775 ContentType::CINEMA, ContentType::GAME};
776 for (const auto& type : types) {
777 const auto& status = mComposerClient->setContentType(getInvalidDisplayId(), type);
778
779 EXPECT_FALSE(status.isOk());
780 EXPECT_NO_FATAL_FAILURE(
781 assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
782 }
783 }
784
TEST_P(GraphicsComposerAidlTest,SetGraphicsContentType)785 TEST_P(GraphicsComposerAidlTest, SetGraphicsContentType) {
786 Test_setContentType(ContentType::GRAPHICS, "GRAPHICS");
787 }
788
TEST_P(GraphicsComposerAidlTest,SetPhotoContentType)789 TEST_P(GraphicsComposerAidlTest, SetPhotoContentType) {
790 Test_setContentType(ContentType::PHOTO, "PHOTO");
791 }
792
TEST_P(GraphicsComposerAidlTest,SetCinemaContentType)793 TEST_P(GraphicsComposerAidlTest, SetCinemaContentType) {
794 Test_setContentType(ContentType::CINEMA, "CINEMA");
795 }
796
TEST_P(GraphicsComposerAidlTest,SetGameContentType)797 TEST_P(GraphicsComposerAidlTest, SetGameContentType) {
798 Test_setContentType(ContentType::GAME, "GAME");
799 }
800
TEST_P(GraphicsComposerAidlTest,CreateVirtualDisplay)801 TEST_P(GraphicsComposerAidlTest, CreateVirtualDisplay) {
802 const auto& [status, maxVirtualDisplayCount] = mComposerClient->getMaxVirtualDisplayCount();
803 EXPECT_TRUE(status.isOk());
804
805 if (maxVirtualDisplayCount == 0) {
806 GTEST_SUCCEED() << "no virtual display support";
807 return;
808 }
809
810 const auto& [virtualDisplayStatus, virtualDisplay] = mComposerClient->createVirtualDisplay(
811 /*width*/ 64, /*height*/ 64, common::PixelFormat::IMPLEMENTATION_DEFINED,
812 kBufferSlotCount);
813
814 ASSERT_TRUE(virtualDisplayStatus.isOk());
815 EXPECT_TRUE(mComposerClient->destroyVirtualDisplay(virtualDisplay.display).isOk());
816 }
817
TEST_P(GraphicsComposerAidlTest,DestroyVirtualDisplay_BadDisplay)818 TEST_P(GraphicsComposerAidlTest, DestroyVirtualDisplay_BadDisplay) {
819 const auto& [status, maxDisplayCount] = mComposerClient->getMaxVirtualDisplayCount();
820 EXPECT_TRUE(status.isOk());
821
822 if (maxDisplayCount == 0) {
823 GTEST_SUCCEED() << "no virtual display support";
824 return;
825 }
826
827 const auto& destroyStatus = mComposerClient->destroyVirtualDisplay(getInvalidDisplayId());
828
829 EXPECT_FALSE(destroyStatus.isOk());
830 EXPECT_NO_FATAL_FAILURE(
831 assertServiceSpecificError(destroyStatus, IComposerClient::EX_BAD_DISPLAY));
832 }
833
TEST_P(GraphicsComposerAidlTest,CreateLayer)834 TEST_P(GraphicsComposerAidlTest, CreateLayer) {
835 const auto& [status, layer] =
836 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
837
838 EXPECT_TRUE(status.isOk());
839 EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
840 }
841
TEST_P(GraphicsComposerAidlTest,CreateLayer_BadDisplay)842 TEST_P(GraphicsComposerAidlTest, CreateLayer_BadDisplay) {
843 const auto& [status, _] = mComposerClient->createLayer(getInvalidDisplayId(), kBufferSlotCount);
844
845 EXPECT_FALSE(status.isOk());
846 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
847 }
848
TEST_P(GraphicsComposerAidlTest,DestroyLayer_BadDisplay)849 TEST_P(GraphicsComposerAidlTest, DestroyLayer_BadDisplay) {
850 const auto& [status, layer] =
851 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
852 EXPECT_TRUE(status.isOk());
853
854 const auto& destroyStatus = mComposerClient->destroyLayer(getInvalidDisplayId(), layer);
855
856 EXPECT_FALSE(destroyStatus.isOk());
857 EXPECT_NO_FATAL_FAILURE(
858 assertServiceSpecificError(destroyStatus, IComposerClient::EX_BAD_DISPLAY));
859 ASSERT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
860 }
861
TEST_P(GraphicsComposerAidlTest,DestroyLayer_BadLayerError)862 TEST_P(GraphicsComposerAidlTest, DestroyLayer_BadLayerError) {
863 // We haven't created any layers yet, so any id should be invalid
864 const auto& status = mComposerClient->destroyLayer(getPrimaryDisplayId(), /*layer*/ 1);
865
866 EXPECT_FALSE(status.isOk());
867 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_LAYER));
868 }
869
TEST_P(GraphicsComposerAidlTest,GetActiveConfig_BadDisplay)870 TEST_P(GraphicsComposerAidlTest, GetActiveConfig_BadDisplay) {
871 const auto& [status, _] = mComposerClient->getActiveConfig(getInvalidDisplayId());
872
873 EXPECT_FALSE(status.isOk());
874 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
875 }
876
TEST_P(GraphicsComposerAidlTest,GetDisplayConfig)877 TEST_P(GraphicsComposerAidlTest, GetDisplayConfig) {
878 const auto& [status, _] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
879 EXPECT_TRUE(status.isOk());
880 }
881
TEST_P(GraphicsComposerAidlTest,GetDisplayConfig_BadDisplay)882 TEST_P(GraphicsComposerAidlTest, GetDisplayConfig_BadDisplay) {
883 const auto& [status, _] = mComposerClient->getDisplayConfigs(getInvalidDisplayId());
884
885 EXPECT_FALSE(status.isOk());
886 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
887 }
888
TEST_P(GraphicsComposerAidlTest,GetDisplayName)889 TEST_P(GraphicsComposerAidlTest, GetDisplayName) {
890 const auto& [status, _] = mComposerClient->getDisplayName(getPrimaryDisplayId());
891 EXPECT_TRUE(status.isOk());
892 }
893
TEST_P(GraphicsComposerAidlTest,GetOverlaySupport)894 TEST_P(GraphicsComposerAidlTest, GetOverlaySupport) {
895 if (getInterfaceVersion() <= 1) {
896 GTEST_SUCCEED() << "Device does not support the new API for overlay support";
897 return;
898 }
899
900 const auto& [status, properties] = mComposerClient->getOverlaySupport();
901 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
902 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
903 GTEST_SUCCEED() << "getOverlaySupport is not supported";
904 return;
905 }
906
907 ASSERT_TRUE(status.isOk());
908 for (const auto& i : properties.combinations) {
909 for (const auto standard : i.standards) {
910 const auto val = static_cast<int32_t>(standard) &
911 static_cast<int32_t>(common::Dataspace::STANDARD_MASK);
912 ASSERT_TRUE(val == static_cast<int32_t>(standard));
913 }
914 for (const auto transfer : i.transfers) {
915 const auto val = static_cast<int32_t>(transfer) &
916 static_cast<int32_t>(common::Dataspace::TRANSFER_MASK);
917 ASSERT_TRUE(val == static_cast<int32_t>(transfer));
918 }
919 for (const auto range : i.ranges) {
920 const auto val = static_cast<int32_t>(range) &
921 static_cast<int32_t>(common::Dataspace::RANGE_MASK);
922 ASSERT_TRUE(val == static_cast<int32_t>(range));
923 }
924 }
925 }
926
TEST_P(GraphicsComposerAidlTest,GetDisplayPhysicalOrientation_BadDisplay)927 TEST_P(GraphicsComposerAidlTest, GetDisplayPhysicalOrientation_BadDisplay) {
928 const auto& [status, _] = mComposerClient->getDisplayPhysicalOrientation(getInvalidDisplayId());
929
930 EXPECT_FALSE(status.isOk());
931 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
932 }
933
TEST_P(GraphicsComposerAidlTest,GetDisplayPhysicalOrientation)934 TEST_P(GraphicsComposerAidlTest, GetDisplayPhysicalOrientation) {
935 const auto allowedDisplayOrientations = std::array<Transform, 4>{
936 Transform::NONE,
937 Transform::ROT_90,
938 Transform::ROT_180,
939 Transform::ROT_270,
940 };
941
942 const auto& [status, displayOrientation] =
943 mComposerClient->getDisplayPhysicalOrientation(getPrimaryDisplayId());
944
945 EXPECT_TRUE(status.isOk());
946 EXPECT_NE(std::find(allowedDisplayOrientations.begin(), allowedDisplayOrientations.end(),
947 displayOrientation),
948 allowedDisplayOrientations.end());
949 }
950
TEST_P(GraphicsComposerAidlTest,SetClientTargetSlotCount)951 TEST_P(GraphicsComposerAidlTest, SetClientTargetSlotCount) {
952 EXPECT_TRUE(mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kBufferSlotCount)
953 .isOk());
954 }
955
TEST_P(GraphicsComposerAidlTest,SetActiveConfig)956 TEST_P(GraphicsComposerAidlTest, SetActiveConfig) {
957 const auto& [status, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
958 EXPECT_TRUE(status.isOk());
959
960 for (const auto& config : configs) {
961 auto display = getEditablePrimaryDisplay();
962 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config).isOk());
963 const auto& [configStatus, config1] =
964 mComposerClient->getActiveConfig(getPrimaryDisplayId());
965 EXPECT_TRUE(configStatus.isOk());
966 EXPECT_EQ(config, config1);
967 }
968 }
969
TEST_P(GraphicsComposerAidlTest,SetActiveConfigPowerCycle)970 TEST_P(GraphicsComposerAidlTest, SetActiveConfigPowerCycle) {
971 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
972 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
973
974 const auto& [status, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
975 EXPECT_TRUE(status.isOk());
976
977 for (const auto& config : configs) {
978 auto display = getEditablePrimaryDisplay();
979 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config).isOk());
980 const auto& [config1Status, config1] =
981 mComposerClient->getActiveConfig(getPrimaryDisplayId());
982 EXPECT_TRUE(config1Status.isOk());
983 EXPECT_EQ(config, config1);
984
985 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
986 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
987 const auto& [config2Status, config2] =
988 mComposerClient->getActiveConfig(getPrimaryDisplayId());
989 EXPECT_TRUE(config2Status.isOk());
990 EXPECT_EQ(config, config2);
991 }
992 }
993
TEST_P(GraphicsComposerAidlTest,SetPowerModeUnsupported)994 TEST_P(GraphicsComposerAidlTest, SetPowerModeUnsupported) {
995 const auto& [status, capabilities] =
996 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
997 ASSERT_TRUE(status.isOk());
998
999 const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
1000 DisplayCapability::DOZE) != capabilities.end();
1001 const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
1002 DisplayCapability::SUSPEND) != capabilities.end();
1003
1004 if (!isDozeSupported) {
1005 const auto& powerModeDozeStatus =
1006 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE);
1007 EXPECT_FALSE(powerModeDozeStatus.isOk());
1008 EXPECT_NO_FATAL_FAILURE(
1009 assertServiceSpecificError(powerModeDozeStatus, IComposerClient::EX_UNSUPPORTED));
1010
1011 const auto& powerModeDozeSuspendStatus =
1012 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE_SUSPEND);
1013 EXPECT_FALSE(powerModeDozeSuspendStatus.isOk());
1014 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeDozeSuspendStatus,
1015 IComposerClient::EX_UNSUPPORTED));
1016 }
1017
1018 if (!isSuspendSupported) {
1019 const auto& powerModeSuspendStatus =
1020 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON_SUSPEND);
1021 EXPECT_FALSE(powerModeSuspendStatus.isOk());
1022 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeSuspendStatus,
1023 IComposerClient::EX_UNSUPPORTED));
1024
1025 const auto& powerModeDozeSuspendStatus =
1026 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE_SUSPEND);
1027 EXPECT_FALSE(powerModeDozeSuspendStatus.isOk());
1028 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeDozeSuspendStatus,
1029 IComposerClient::EX_UNSUPPORTED));
1030 }
1031 }
1032
TEST_P(GraphicsComposerAidlTest,SetVsyncEnabled)1033 TEST_P(GraphicsComposerAidlTest, SetVsyncEnabled) {
1034 mComposerClient->setVsyncAllowed(true);
1035
1036 EXPECT_TRUE(mComposerClient->setVsync(getPrimaryDisplayId(), true).isOk());
1037 usleep(60 * 1000);
1038 EXPECT_TRUE(mComposerClient->setVsync(getPrimaryDisplayId(), false).isOk());
1039
1040 mComposerClient->setVsyncAllowed(false);
1041 }
1042
TEST_P(GraphicsComposerAidlTest,SetPowerMode)1043 TEST_P(GraphicsComposerAidlTest, SetPowerMode) {
1044 const auto& [status, capabilities] =
1045 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
1046 ASSERT_TRUE(status.isOk());
1047
1048 const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
1049 DisplayCapability::DOZE) != capabilities.end();
1050 const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
1051 DisplayCapability::SUSPEND) != capabilities.end();
1052
1053 std::vector<PowerMode> modes;
1054 modes.push_back(PowerMode::OFF);
1055 modes.push_back(PowerMode::ON);
1056
1057 if (isSuspendSupported) {
1058 modes.push_back(PowerMode::ON_SUSPEND);
1059 }
1060
1061 if (isDozeSupported) {
1062 modes.push_back(PowerMode::DOZE);
1063 }
1064
1065 if (isSuspendSupported && isDozeSupported) {
1066 modes.push_back(PowerMode::DOZE_SUSPEND);
1067 }
1068
1069 for (auto mode : modes) {
1070 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
1071 }
1072 }
1073
TEST_P(GraphicsComposerAidlTest,SetPowerModeVariations)1074 TEST_P(GraphicsComposerAidlTest, SetPowerModeVariations) {
1075 const auto& [status, capabilities] =
1076 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
1077 ASSERT_TRUE(status.isOk());
1078
1079 const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
1080 DisplayCapability::DOZE) != capabilities.end();
1081 const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
1082 DisplayCapability::SUSPEND) != capabilities.end();
1083
1084 std::vector<PowerMode> modes;
1085
1086 modes.push_back(PowerMode::OFF);
1087 modes.push_back(PowerMode::ON);
1088 modes.push_back(PowerMode::OFF);
1089 for (auto mode : modes) {
1090 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
1091 }
1092 modes.clear();
1093
1094 modes.push_back(PowerMode::OFF);
1095 modes.push_back(PowerMode::OFF);
1096 for (auto mode : modes) {
1097 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
1098 }
1099 modes.clear();
1100
1101 modes.push_back(PowerMode::ON);
1102 modes.push_back(PowerMode::ON);
1103 for (auto mode : modes) {
1104 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
1105 }
1106 modes.clear();
1107
1108 if (isSuspendSupported) {
1109 modes.push_back(PowerMode::ON_SUSPEND);
1110 modes.push_back(PowerMode::ON_SUSPEND);
1111 for (auto mode : modes) {
1112 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
1113 }
1114 modes.clear();
1115 }
1116
1117 if (isDozeSupported) {
1118 modes.push_back(PowerMode::DOZE);
1119 modes.push_back(PowerMode::DOZE);
1120 for (auto mode : modes) {
1121 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
1122 }
1123 modes.clear();
1124 }
1125
1126 if (isSuspendSupported && isDozeSupported) {
1127 modes.push_back(PowerMode::DOZE_SUSPEND);
1128 modes.push_back(PowerMode::DOZE_SUSPEND);
1129 for (auto mode : modes) {
1130 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
1131 }
1132 modes.clear();
1133 }
1134 }
1135
TEST_P(GraphicsComposerAidlTest,SetPowerMode_BadDisplay)1136 TEST_P(GraphicsComposerAidlTest, SetPowerMode_BadDisplay) {
1137 const auto& status = mComposerClient->setPowerMode(getInvalidDisplayId(), PowerMode::ON);
1138
1139 EXPECT_FALSE(status.isOk());
1140 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
1141 }
1142
TEST_P(GraphicsComposerAidlTest,SetPowerMode_BadParameter)1143 TEST_P(GraphicsComposerAidlTest, SetPowerMode_BadParameter) {
1144 const auto& status =
1145 mComposerClient->setPowerMode(getPrimaryDisplayId(), static_cast<PowerMode>(-1));
1146
1147 EXPECT_FALSE(status.isOk());
1148 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
1149 }
1150
TEST_P(GraphicsComposerAidlTest,GetDataspaceSaturationMatrix)1151 TEST_P(GraphicsComposerAidlTest, GetDataspaceSaturationMatrix) {
1152 const auto& [status, matrix] =
1153 mComposerClient->getDataspaceSaturationMatrix(common::Dataspace::SRGB_LINEAR);
1154 ASSERT_TRUE(status.isOk());
1155 ASSERT_EQ(16, matrix.size()); // matrix should not be empty if call succeeded.
1156
1157 // the last row is known
1158 EXPECT_EQ(0.0f, matrix[12]);
1159 EXPECT_EQ(0.0f, matrix[13]);
1160 EXPECT_EQ(0.0f, matrix[14]);
1161 EXPECT_EQ(1.0f, matrix[15]);
1162 }
1163
TEST_P(GraphicsComposerAidlTest,GetDataspaceSaturationMatrix_BadParameter)1164 TEST_P(GraphicsComposerAidlTest, GetDataspaceSaturationMatrix_BadParameter) {
1165 const auto& [status, matrix] =
1166 mComposerClient->getDataspaceSaturationMatrix(common::Dataspace::UNKNOWN);
1167
1168 EXPECT_FALSE(status.isOk());
1169 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
1170 }
1171
1172 // Tests for Command.
1173 class GraphicsComposerAidlCommandTest : public GraphicsComposerAidlTest {
1174 protected:
TearDown()1175 void TearDown() override {
1176 const auto errors = mReader.takeErrors();
1177 ASSERT_TRUE(mReader.takeErrors().empty());
1178 ASSERT_TRUE(mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty());
1179
1180 ASSERT_NO_FATAL_FAILURE(GraphicsComposerAidlTest::TearDown());
1181 }
1182
execute()1183 void execute() {
1184 std::vector<CommandResultPayload> payloads;
1185 for (auto& [_, writer] : mWriters) {
1186 auto commands = writer.takePendingCommands();
1187 if (commands.empty()) {
1188 continue;
1189 }
1190
1191 auto [status, results] = mComposerClient->executeCommands(commands);
1192 ASSERT_TRUE(status.isOk()) << "executeCommands failed " << status.getDescription();
1193
1194 payloads.reserve(payloads.size() + results.size());
1195 payloads.insert(payloads.end(), std::make_move_iterator(results.begin()),
1196 std::make_move_iterator(results.end()));
1197 }
1198 mReader.parse(std::move(payloads));
1199 }
1200
toTimePoint(nsecs_t time)1201 static inline auto toTimePoint(nsecs_t time) {
1202 return std::chrono::time_point<std::chrono::steady_clock>(std::chrono::nanoseconds(time));
1203 }
1204
forEachTwoConfigs(int64_t display,std::function<void (int32_t,int32_t)> func)1205 void forEachTwoConfigs(int64_t display, std::function<void(int32_t, int32_t)> func) {
1206 const auto& [status, displayConfigs] = mComposerClient->getDisplayConfigs(display);
1207 ASSERT_TRUE(status.isOk());
1208 for (const int32_t config1 : displayConfigs) {
1209 for (const int32_t config2 : displayConfigs) {
1210 if (config1 != config2) {
1211 func(config1, config2);
1212 }
1213 }
1214 }
1215 }
1216
waitForVsyncPeriodChange(int64_t display,const VsyncPeriodChangeTimeline & timeline,int64_t desiredTimeNanos,int64_t oldPeriodNanos,int64_t newPeriodNanos)1217 void waitForVsyncPeriodChange(int64_t display, const VsyncPeriodChangeTimeline& timeline,
1218 int64_t desiredTimeNanos, int64_t oldPeriodNanos,
1219 int64_t newPeriodNanos) {
1220 const auto kChangeDeadline = toTimePoint(timeline.newVsyncAppliedTimeNanos) + 100ms;
1221 while (std::chrono::steady_clock::now() <= kChangeDeadline) {
1222 const auto& [status, vsyncPeriodNanos] =
1223 mComposerClient->getDisplayVsyncPeriod(display);
1224 EXPECT_TRUE(status.isOk());
1225 if (systemTime() <= desiredTimeNanos) {
1226 EXPECT_EQ(vsyncPeriodNanos, oldPeriodNanos);
1227 } else if (vsyncPeriodNanos == newPeriodNanos) {
1228 break;
1229 }
1230 std::this_thread::sleep_for(std::chrono::nanoseconds(oldPeriodNanos));
1231 }
1232 }
1233
checkIfCallbackRefreshRateChangedDebugEnabledReceived(std::function<bool (RefreshRateChangedDebugData)> filter)1234 bool checkIfCallbackRefreshRateChangedDebugEnabledReceived(
1235 std::function<bool(RefreshRateChangedDebugData)> filter) {
1236 const auto list = mComposerClient->takeListOfRefreshRateChangedDebugData();
1237 return std::any_of(list.begin(), list.end(), [&](auto refreshRateChangedDebugData) {
1238 return filter(refreshRateChangedDebugData);
1239 });
1240 }
1241
allocate(uint32_t width,uint32_t height,::android::PixelFormat pixelFormat)1242 sp<GraphicBuffer> allocate(uint32_t width, uint32_t height,
1243 ::android::PixelFormat pixelFormat) {
1244 return sp<GraphicBuffer>::make(
1245 width, height, pixelFormat, /*layerCount*/ 1U,
1246 static_cast<uint64_t>(common::BufferUsage::CPU_WRITE_OFTEN) |
1247 static_cast<uint64_t>(common::BufferUsage::CPU_READ_OFTEN) |
1248 static_cast<uint64_t>(common::BufferUsage::COMPOSER_OVERLAY),
1249 "VtsHalGraphicsComposer3_TargetTest");
1250 }
1251
allocate(::android::PixelFormat pixelFormat)1252 sp<GraphicBuffer> allocate(::android::PixelFormat pixelFormat) {
1253 return allocate(static_cast<uint32_t>(getPrimaryDisplay().getDisplayWidth()),
1254 static_cast<uint32_t>(getPrimaryDisplay().getDisplayHeight()), pixelFormat);
1255 }
1256
sendRefreshFrame(const VtsDisplay & display,const VsyncPeriodChangeTimeline * timeline)1257 void sendRefreshFrame(const VtsDisplay& display, const VsyncPeriodChangeTimeline* timeline) {
1258 if (timeline != nullptr) {
1259 // Refresh time should be before newVsyncAppliedTimeNanos
1260 EXPECT_LT(timeline->refreshTimeNanos, timeline->newVsyncAppliedTimeNanos);
1261
1262 std::this_thread::sleep_until(toTimePoint(timeline->refreshTimeNanos));
1263 }
1264
1265 EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::ON).isOk());
1266 EXPECT_TRUE(mComposerClient
1267 ->setColorMode(display.getDisplayId(), ColorMode::NATIVE,
1268 RenderIntent::COLORIMETRIC)
1269 .isOk());
1270
1271 const auto& [status, layer] =
1272 mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount);
1273 EXPECT_TRUE(status.isOk());
1274 auto& writer = getWriter(display.getDisplayId());
1275 {
1276 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1277 ASSERT_NE(nullptr, buffer);
1278 ASSERT_EQ(::android::OK, buffer->initCheck());
1279 ASSERT_NE(nullptr, buffer->handle);
1280
1281 configureLayer(display, layer, Composition::DEVICE, display.getFrameRect(),
1282 display.getCrop());
1283 writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, buffer->handle,
1284 /*acquireFence*/ -1);
1285 writer.setLayerDataspace(display.getDisplayId(), layer, common::Dataspace::UNKNOWN);
1286
1287 writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp);
1288 execute();
1289 ASSERT_TRUE(mReader.takeErrors().empty());
1290
1291 writer.presentDisplay(display.getDisplayId());
1292 execute();
1293 ASSERT_TRUE(mReader.takeErrors().empty());
1294 }
1295
1296 {
1297 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1298 ASSERT_NE(nullptr, buffer->handle);
1299
1300 writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, buffer->handle,
1301 /*acquireFence*/ -1);
1302 writer.setLayerSurfaceDamage(display.getDisplayId(), layer,
1303 std::vector<Rect>(1, {0, 0, 10, 10}));
1304 writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp);
1305 execute();
1306 ASSERT_TRUE(mReader.takeErrors().empty());
1307
1308 writer.presentDisplay(display.getDisplayId());
1309 execute();
1310 }
1311
1312 EXPECT_TRUE(mComposerClient->destroyLayer(display.getDisplayId(), layer).isOk());
1313 }
1314
presentAndGetFence(std::optional<ClockMonotonicTimestamp> expectedPresentTime)1315 sp<::android::Fence> presentAndGetFence(
1316 std::optional<ClockMonotonicTimestamp> expectedPresentTime) {
1317 auto& writer = getWriter(getPrimaryDisplayId());
1318 writer.validateDisplay(getPrimaryDisplayId(), expectedPresentTime);
1319 execute();
1320 EXPECT_TRUE(mReader.takeErrors().empty());
1321
1322 writer.presentDisplay(getPrimaryDisplayId());
1323 execute();
1324 EXPECT_TRUE(mReader.takeErrors().empty());
1325
1326 auto presentFence = mReader.takePresentFence(getPrimaryDisplayId());
1327 // take ownership
1328 const int fenceOwner = presentFence.get();
1329 *presentFence.getR() = -1;
1330 EXPECT_NE(-1, fenceOwner);
1331 return sp<::android::Fence>::make(fenceOwner);
1332 }
1333
getVsyncPeriod()1334 int32_t getVsyncPeriod() {
1335 const auto& [status, activeConfig] =
1336 mComposerClient->getActiveConfig(getPrimaryDisplayId());
1337 EXPECT_TRUE(status.isOk());
1338
1339 const auto& [vsyncPeriodStatus, vsyncPeriod] = mComposerClient->getDisplayAttribute(
1340 getPrimaryDisplayId(), activeConfig, DisplayAttribute::VSYNC_PERIOD);
1341 EXPECT_TRUE(vsyncPeriodStatus.isOk());
1342 return vsyncPeriod;
1343 }
1344
createOnScreenLayer(Composition composition=Composition::DEVICE)1345 int64_t createOnScreenLayer(Composition composition = Composition::DEVICE) {
1346 const auto& [status, layer] =
1347 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1348 EXPECT_TRUE(status.isOk());
1349 Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
1350 getPrimaryDisplay().getDisplayHeight()};
1351 FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
1352 (float)getPrimaryDisplay().getDisplayHeight()};
1353 configureLayer(getPrimaryDisplay(), layer, composition, displayFrame, cropRect);
1354 auto& writer = getWriter(getPrimaryDisplayId());
1355 writer.setLayerDataspace(getPrimaryDisplayId(), layer, common::Dataspace::UNKNOWN);
1356 return layer;
1357 }
1358
sendBufferUpdate(int64_t layer)1359 void sendBufferUpdate(int64_t layer) {
1360 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1361 ASSERT_NE(nullptr, buffer->handle);
1362
1363 auto& writer = getWriter(getPrimaryDisplayId());
1364 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer->handle,
1365 /*acquireFence*/ -1);
1366
1367 const sp<::android::Fence> presentFence =
1368 presentAndGetFence(ComposerClientWriter::kNoTimestamp);
1369 presentFence->waitForever(LOG_TAG);
1370 }
1371
hasDisplayCapability(int64_t display,DisplayCapability cap)1372 bool hasDisplayCapability(int64_t display, DisplayCapability cap) {
1373 const auto& [status, capabilities] = mComposerClient->getDisplayCapabilities(display);
1374 EXPECT_TRUE(status.isOk());
1375
1376 return std::find(capabilities.begin(), capabilities.end(), cap) != capabilities.end();
1377 }
1378
Test_setActiveConfigWithConstraints(const TestParameters & params)1379 void Test_setActiveConfigWithConstraints(const TestParameters& params) {
1380 for (VtsDisplay& display : mDisplays) {
1381 forEachTwoConfigs(display.getDisplayId(), [&](int32_t config1, int32_t config2) {
1382 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
1383 sendRefreshFrame(display, nullptr);
1384
1385 const auto displayConfigGroup1 = display.getDisplayConfig(config1);
1386 int32_t vsyncPeriod1 = displayConfigGroup1.vsyncPeriod;
1387 int32_t configGroup1 = displayConfigGroup1.configGroup;
1388
1389 const auto displayConfigGroup2 = display.getDisplayConfig(config2);
1390 int32_t vsyncPeriod2 = displayConfigGroup2.vsyncPeriod;
1391 int32_t configGroup2 = displayConfigGroup2.configGroup;
1392
1393 if (vsyncPeriod1 == vsyncPeriod2) {
1394 return; // continue
1395 }
1396
1397 // We don't allow delayed change when changing config groups
1398 if (params.delayForChange > 0 && configGroup1 != configGroup2) {
1399 return; // continue
1400 }
1401
1402 VsyncPeriodChangeConstraints constraints = {
1403 .desiredTimeNanos = systemTime() + params.delayForChange,
1404 .seamlessRequired = false};
1405 const auto& [status, timeline] = mComposerClient->setActiveConfigWithConstraints(
1406 &display, config2, constraints);
1407 EXPECT_TRUE(status.isOk());
1408
1409 EXPECT_TRUE(timeline.newVsyncAppliedTimeNanos >= constraints.desiredTimeNanos);
1410 // Refresh rate should change within a reasonable time
1411 constexpr std::chrono::nanoseconds kReasonableTimeForChange = 1s; // 1 second
1412 EXPECT_TRUE(timeline.newVsyncAppliedTimeNanos - constraints.desiredTimeNanos <=
1413 kReasonableTimeForChange.count());
1414
1415 if (timeline.refreshRequired) {
1416 if (params.refreshMiss) {
1417 // Miss the refresh frame on purpose to make sure the implementation sends a
1418 // callback
1419 std::this_thread::sleep_until(toTimePoint(timeline.refreshTimeNanos) +
1420 100ms);
1421 }
1422 sendRefreshFrame(display, &timeline);
1423 }
1424 waitForVsyncPeriodChange(display.getDisplayId(), timeline,
1425 constraints.desiredTimeNanos, vsyncPeriod1, vsyncPeriod2);
1426
1427 // At this point the refresh rate should have changed already, however in rare
1428 // cases the implementation might have missed the deadline. In this case a new
1429 // timeline should have been provided.
1430 auto newTimeline = mComposerClient->takeLastVsyncPeriodChangeTimeline();
1431 if (timeline.refreshRequired && params.refreshMiss) {
1432 EXPECT_TRUE(newTimeline.has_value());
1433 }
1434
1435 if (newTimeline.has_value()) {
1436 if (newTimeline->refreshRequired) {
1437 sendRefreshFrame(display, &newTimeline.value());
1438 }
1439 waitForVsyncPeriodChange(display.getDisplayId(), newTimeline.value(),
1440 constraints.desiredTimeNanos, vsyncPeriod1,
1441 vsyncPeriod2);
1442 }
1443
1444 const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanos] =
1445 mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
1446 EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
1447 EXPECT_EQ(vsyncPeriodNanos, vsyncPeriod2);
1448 });
1449 }
1450 }
1451
Test_expectedPresentTime(std::optional<int> framesDelay)1452 void Test_expectedPresentTime(std::optional<int> framesDelay) {
1453 if (hasCapability(Capability::PRESENT_FENCE_IS_NOT_RELIABLE)) {
1454 GTEST_SUCCEED() << "Device has unreliable present fences capability, skipping";
1455 return;
1456 }
1457
1458 ASSERT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
1459
1460 const auto vsyncPeriod = getVsyncPeriod();
1461
1462 const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1463 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1464 ASSERT_NE(nullptr, buffer1);
1465 ASSERT_NE(nullptr, buffer2);
1466
1467 const auto layer = createOnScreenLayer();
1468 auto& writer = getWriter(getPrimaryDisplayId());
1469 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer1->handle,
1470 /*acquireFence*/ -1);
1471 const sp<::android::Fence> presentFence1 =
1472 presentAndGetFence(ComposerClientWriter::kNoTimestamp);
1473 presentFence1->waitForever(LOG_TAG);
1474
1475 auto expectedPresentTime = presentFence1->getSignalTime() + vsyncPeriod;
1476 if (framesDelay.has_value()) {
1477 expectedPresentTime += *framesDelay * vsyncPeriod;
1478 }
1479
1480 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer2->handle,
1481 /*acquireFence*/ -1);
1482 const auto setExpectedPresentTime = [&]() -> std::optional<ClockMonotonicTimestamp> {
1483 if (!framesDelay.has_value()) {
1484 return ComposerClientWriter::kNoTimestamp;
1485 } else if (*framesDelay == 0) {
1486 return ClockMonotonicTimestamp{0};
1487 }
1488 return ClockMonotonicTimestamp{expectedPresentTime};
1489 }();
1490
1491 const sp<::android::Fence> presentFence2 = presentAndGetFence(setExpectedPresentTime);
1492 presentFence2->waitForever(LOG_TAG);
1493
1494 const auto actualPresentTime = presentFence2->getSignalTime();
1495 EXPECT_GE(actualPresentTime, expectedPresentTime - vsyncPeriod / 2);
1496
1497 ASSERT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
1498 }
1499
configureLayer(const VtsDisplay & display,int64_t layer,Composition composition,const Rect & displayFrame,const FRect & cropRect)1500 void configureLayer(const VtsDisplay& display, int64_t layer, Composition composition,
1501 const Rect& displayFrame, const FRect& cropRect) {
1502 auto& writer = getWriter(display.getDisplayId());
1503 writer.setLayerCompositionType(display.getDisplayId(), layer, composition);
1504 writer.setLayerDisplayFrame(display.getDisplayId(), layer, displayFrame);
1505 writer.setLayerPlaneAlpha(display.getDisplayId(), layer, /*alpha*/ 1);
1506 writer.setLayerSourceCrop(display.getDisplayId(), layer, cropRect);
1507 writer.setLayerTransform(display.getDisplayId(), layer, static_cast<Transform>(0));
1508 writer.setLayerVisibleRegion(display.getDisplayId(), layer,
1509 std::vector<Rect>(1, displayFrame));
1510 writer.setLayerZOrder(display.getDisplayId(), layer, /*z*/ 10);
1511 writer.setLayerBlendMode(display.getDisplayId(), layer, BlendMode::NONE);
1512 writer.setLayerSurfaceDamage(display.getDisplayId(), layer,
1513 std::vector<Rect>(1, displayFrame));
1514 }
1515 // clang-format off
1516 const std::array<float, 16> kIdentity = {{
1517 1.0f, 0.0f, 0.0f, 0.0f,
1518 0.0f, 1.0f, 0.0f, 0.0f,
1519 0.0f, 0.0f, 1.0f, 0.0f,
1520 0.0f, 0.0f, 0.0f, 1.0f,
1521 }};
1522 // clang-format on
1523
getWriter(int64_t display)1524 ComposerClientWriter& getWriter(int64_t display) {
1525 auto [it, _] = mWriters.try_emplace(display, display);
1526 return it->second;
1527 }
1528
1529 ComposerClientReader mReader;
1530
1531 private:
1532 std::unordered_map<int64_t, ComposerClientWriter> mWriters;
1533 };
1534
TEST_P(GraphicsComposerAidlCommandTest,SetColorTransform)1535 TEST_P(GraphicsComposerAidlCommandTest, SetColorTransform) {
1536 auto& writer = getWriter(getPrimaryDisplayId());
1537 writer.setColorTransform(getPrimaryDisplayId(), kIdentity.data());
1538 execute();
1539 }
1540
TEST_P(GraphicsComposerAidlCommandTest,SetLayerColorTransform)1541 TEST_P(GraphicsComposerAidlCommandTest, SetLayerColorTransform) {
1542 const auto& [status, layer] =
1543 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1544 EXPECT_TRUE(status.isOk());
1545 auto& writer = getWriter(getPrimaryDisplayId());
1546 writer.setLayerColorTransform(getPrimaryDisplayId(), layer, kIdentity.data());
1547 execute();
1548
1549 const auto errors = mReader.takeErrors();
1550 if (errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_UNSUPPORTED) {
1551 GTEST_SUCCEED() << "setLayerColorTransform is not supported";
1552 return;
1553 }
1554 }
1555
TEST_P(GraphicsComposerAidlCommandTest,SetDisplayBrightness)1556 TEST_P(GraphicsComposerAidlCommandTest, SetDisplayBrightness) {
1557 const auto& [status, capabilities] =
1558 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
1559 ASSERT_TRUE(status.isOk());
1560 bool brightnessSupport = std::find(capabilities.begin(), capabilities.end(),
1561 DisplayCapability::BRIGHTNESS) != capabilities.end();
1562 auto& writer = getWriter(getPrimaryDisplayId());
1563 if (!brightnessSupport) {
1564 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.5f, -1.f);
1565 execute();
1566 const auto errors = mReader.takeErrors();
1567 EXPECT_EQ(1, errors.size());
1568 EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, errors[0].errorCode);
1569 GTEST_SUCCEED() << "SetDisplayBrightness is not supported";
1570 return;
1571 }
1572
1573 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.0f, -1.f);
1574 execute();
1575 EXPECT_TRUE(mReader.takeErrors().empty());
1576
1577 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.5f, -1.f);
1578 execute();
1579 EXPECT_TRUE(mReader.takeErrors().empty());
1580
1581 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 1.0f, -1.f);
1582 execute();
1583 EXPECT_TRUE(mReader.takeErrors().empty());
1584
1585 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ -1.0f, -1.f);
1586 execute();
1587 EXPECT_TRUE(mReader.takeErrors().empty());
1588
1589 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 2.0f, -1.f);
1590 execute();
1591 {
1592 const auto errors = mReader.takeErrors();
1593 ASSERT_EQ(1, errors.size());
1594 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
1595 }
1596
1597 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ -2.0f, -1.f);
1598 execute();
1599 {
1600 const auto errors = mReader.takeErrors();
1601 ASSERT_EQ(1, errors.size());
1602 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
1603 }
1604 }
1605
TEST_P(GraphicsComposerAidlCommandTest,SetClientTarget)1606 TEST_P(GraphicsComposerAidlCommandTest, SetClientTarget) {
1607 EXPECT_TRUE(mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kBufferSlotCount)
1608 .isOk());
1609
1610 auto& writer = getWriter(getPrimaryDisplayId());
1611 writer.setClientTarget(getPrimaryDisplayId(), /*slot*/ 0, nullptr, /*acquireFence*/ -1,
1612 Dataspace::UNKNOWN, std::vector<Rect>());
1613
1614 execute();
1615 }
1616
TEST_P(GraphicsComposerAidlCommandTest,SetOutputBuffer)1617 TEST_P(GraphicsComposerAidlCommandTest, SetOutputBuffer) {
1618 const auto& [status, virtualDisplayCount] = mComposerClient->getMaxVirtualDisplayCount();
1619 EXPECT_TRUE(status.isOk());
1620 if (virtualDisplayCount == 0) {
1621 GTEST_SUCCEED() << "no virtual display support";
1622 return;
1623 }
1624
1625 const auto& [displayStatus, display] = mComposerClient->createVirtualDisplay(
1626 /*width*/ 64, /*height*/ 64, common::PixelFormat::IMPLEMENTATION_DEFINED,
1627 kBufferSlotCount);
1628 EXPECT_TRUE(displayStatus.isOk());
1629
1630 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1631 const auto handle = buffer->handle;
1632 auto& writer = getWriter(display.display);
1633 writer.setOutputBuffer(display.display, /*slot*/ 0, handle, /*releaseFence*/ -1);
1634 execute();
1635 }
1636
TEST_P(GraphicsComposerAidlCommandTest,ValidDisplay)1637 TEST_P(GraphicsComposerAidlCommandTest, ValidDisplay) {
1638 auto& writer = getWriter(getPrimaryDisplayId());
1639 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
1640 execute();
1641 }
1642
TEST_P(GraphicsComposerAidlCommandTest,AcceptDisplayChanges)1643 TEST_P(GraphicsComposerAidlCommandTest, AcceptDisplayChanges) {
1644 auto& writer = getWriter(getPrimaryDisplayId());
1645 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
1646 writer.acceptDisplayChanges(getPrimaryDisplayId());
1647 execute();
1648 }
1649
TEST_P(GraphicsComposerAidlCommandTest,PresentDisplay)1650 TEST_P(GraphicsComposerAidlCommandTest, PresentDisplay) {
1651 auto& writer = getWriter(getPrimaryDisplayId());
1652 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
1653 writer.presentDisplay(getPrimaryDisplayId());
1654 execute();
1655 }
1656
1657 /**
1658 * Test IComposerClient::Command::PRESENT_DISPLAY
1659 *
1660 * Test that IComposerClient::Command::PRESENT_DISPLAY works without
1661 * additional call to validateDisplay when only the layer buffer handle and
1662 * surface damage have been set
1663 */
TEST_P(GraphicsComposerAidlCommandTest,PresentDisplayNoLayerStateChanges)1664 TEST_P(GraphicsComposerAidlCommandTest, PresentDisplayNoLayerStateChanges) {
1665 if (!hasCapability(Capability::SKIP_VALIDATE)) {
1666 GTEST_SUCCEED() << "Device does not have skip validate capability, skipping";
1667 return;
1668 }
1669 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
1670
1671 const auto& [renderIntentsStatus, renderIntents] =
1672 mComposerClient->getRenderIntents(getPrimaryDisplayId(), ColorMode::NATIVE);
1673 EXPECT_TRUE(renderIntentsStatus.isOk());
1674 auto& writer = getWriter(getPrimaryDisplayId());
1675 for (auto intent : renderIntents) {
1676 EXPECT_TRUE(mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE, intent)
1677 .isOk());
1678
1679 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1680 const auto handle = buffer->handle;
1681 ASSERT_NE(nullptr, handle);
1682
1683 const auto& [layerStatus, layer] =
1684 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1685 EXPECT_TRUE(layerStatus.isOk());
1686
1687 Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
1688 getPrimaryDisplay().getDisplayHeight()};
1689 FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
1690 (float)getPrimaryDisplay().getDisplayHeight()};
1691 configureLayer(getPrimaryDisplay(), layer, Composition::CURSOR, displayFrame, cropRect);
1692 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle,
1693 /*acquireFence*/ -1);
1694 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
1695 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
1696 execute();
1697 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
1698 GTEST_SUCCEED() << "Composition change requested, skipping test";
1699 return;
1700 }
1701
1702 ASSERT_TRUE(mReader.takeErrors().empty());
1703 writer.presentDisplay(getPrimaryDisplayId());
1704 execute();
1705 ASSERT_TRUE(mReader.takeErrors().empty());
1706
1707 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1708 const auto handle2 = buffer2->handle;
1709 ASSERT_NE(nullptr, handle2);
1710 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle2,
1711 /*acquireFence*/ -1);
1712 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer,
1713 std::vector<Rect>(1, {0, 0, 10, 10}));
1714 writer.presentDisplay(getPrimaryDisplayId());
1715 execute();
1716 }
1717 }
1718
TEST_P(GraphicsComposerAidlCommandTest,SetLayerCursorPosition)1719 TEST_P(GraphicsComposerAidlCommandTest, SetLayerCursorPosition) {
1720 const auto& [layerStatus, layer] =
1721 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1722 EXPECT_TRUE(layerStatus.isOk());
1723
1724 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1725 const auto handle = buffer->handle;
1726 ASSERT_NE(nullptr, handle);
1727
1728 auto& writer = getWriter(getPrimaryDisplayId());
1729 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle, /*acquireFence*/ -1);
1730
1731 Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
1732 getPrimaryDisplay().getDisplayHeight()};
1733 FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
1734 (float)getPrimaryDisplay().getDisplayHeight()};
1735 configureLayer(getPrimaryDisplay(), layer, Composition::CURSOR, displayFrame, cropRect);
1736 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
1737 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
1738
1739 execute();
1740
1741 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
1742 GTEST_SUCCEED() << "Composition change requested, skipping test";
1743 return;
1744 }
1745 writer.presentDisplay(getPrimaryDisplayId());
1746 ASSERT_TRUE(mReader.takeErrors().empty());
1747
1748 writer.setLayerCursorPosition(getPrimaryDisplayId(), layer, /*x*/ 1, /*y*/ 1);
1749 execute();
1750
1751 writer.setLayerCursorPosition(getPrimaryDisplayId(), layer, /*x*/ 0, /*y*/ 0);
1752 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
1753 writer.presentDisplay(getPrimaryDisplayId());
1754 execute();
1755 }
1756
TEST_P(GraphicsComposerAidlCommandTest,SetLayerBuffer)1757 TEST_P(GraphicsComposerAidlCommandTest, SetLayerBuffer) {
1758 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1759 const auto handle = buffer->handle;
1760 ASSERT_NE(nullptr, handle);
1761
1762 const auto& [layerStatus, layer] =
1763 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1764 EXPECT_TRUE(layerStatus.isOk());
1765 auto& writer = getWriter(getPrimaryDisplayId());
1766 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle, /*acquireFence*/ -1);
1767 execute();
1768 }
1769
TEST_P(GraphicsComposerAidlCommandTest,SetLayerBufferSlotsToClear)1770 TEST_P(GraphicsComposerAidlCommandTest, SetLayerBufferSlotsToClear) {
1771 // Older HAL versions use a backwards compatible way of clearing buffer slots
1772 const auto& [versionStatus, version] = mComposerClient->getInterfaceVersion();
1773 ASSERT_TRUE(versionStatus.isOk());
1774 if (version <= 1) {
1775 GTEST_SUCCEED() << "HAL at version 1 or lower does not have "
1776 "LayerCommand::bufferSlotsToClear.";
1777 return;
1778 }
1779
1780 const auto& [layerStatus, layer] =
1781 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1782 EXPECT_TRUE(layerStatus.isOk());
1783 auto& writer = getWriter(getPrimaryDisplayId());
1784
1785 // setup 3 buffers in the buffer cache, with the last buffer being active
1786 // then emulate the Android platform code that clears all 3 buffer slots
1787
1788 const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1789 ASSERT_NE(nullptr, buffer1);
1790 const auto handle1 = buffer1->handle;
1791 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle1, /*acquireFence*/ -1);
1792 execute();
1793 ASSERT_TRUE(mReader.takeErrors().empty());
1794
1795 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1796 ASSERT_NE(nullptr, buffer2);
1797 const auto handle2 = buffer2->handle;
1798 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 1, handle2, /*acquireFence*/ -1);
1799 execute();
1800 ASSERT_TRUE(mReader.takeErrors().empty());
1801
1802 const auto buffer3 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1803 ASSERT_NE(nullptr, buffer3);
1804 const auto handle3 = buffer3->handle;
1805 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 2, handle3, /*acquireFence*/ -1);
1806 execute();
1807 ASSERT_TRUE(mReader.takeErrors().empty());
1808
1809 // Ensure we can clear all 3 buffer slots, even the active buffer - it is assumed the
1810 // current active buffer's slot will be cleared, but still remain the active buffer and no
1811 // errors will occur.
1812 writer.setLayerBufferSlotsToClear(getPrimaryDisplayId(), layer, {0, 1, 2});
1813 execute();
1814 ASSERT_TRUE(mReader.takeErrors().empty());
1815 }
1816
TEST_P(GraphicsComposerAidlCommandTest,SetLayerBufferMultipleTimes)1817 TEST_P(GraphicsComposerAidlCommandTest, SetLayerBufferMultipleTimes) {
1818 const auto& [layerStatus, layer] =
1819 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1820 EXPECT_TRUE(layerStatus.isOk());
1821 auto& writer = getWriter(getPrimaryDisplayId());
1822
1823 // Setup 3 buffers in the buffer cache, with the last buffer being active. Then, emulate the
1824 // Android platform code that clears all 3 buffer slots by setting all but the active buffer
1825 // slot to a placeholder buffer, and then restoring the active buffer.
1826
1827 // This is used on HALs that don't support setLayerBufferSlotsToClear (version <= 3.1).
1828
1829 const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1830 ASSERT_NE(nullptr, buffer1);
1831 const auto handle1 = buffer1->handle;
1832 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle1, /*acquireFence*/ -1);
1833 execute();
1834 ASSERT_TRUE(mReader.takeErrors().empty());
1835
1836 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1837 ASSERT_NE(nullptr, buffer2);
1838 const auto handle2 = buffer2->handle;
1839 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 1, handle2, /*acquireFence*/ -1);
1840 execute();
1841 ASSERT_TRUE(mReader.takeErrors().empty());
1842
1843 const auto buffer3 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1844 ASSERT_NE(nullptr, buffer3);
1845 const auto handle3 = buffer3->handle;
1846 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 2, handle3, /*acquireFence*/ -1);
1847 execute();
1848 ASSERT_TRUE(mReader.takeErrors().empty());
1849
1850 // Older versions of the HAL clear all but the active buffer slot with a placeholder buffer,
1851 // and then restoring the current active buffer at the end
1852 auto clearSlotBuffer = allocate(1u, 1u, ::android::PIXEL_FORMAT_RGB_888);
1853 ASSERT_NE(nullptr, clearSlotBuffer);
1854 auto clearSlotBufferHandle = clearSlotBuffer->handle;
1855
1856 // clear buffer slots 0 and 1 with new layer commands... and then...
1857 writer.setLayerBufferWithNewCommand(getPrimaryDisplayId(), layer, /* slot */ 0,
1858 clearSlotBufferHandle, /*acquireFence*/ -1);
1859 writer.setLayerBufferWithNewCommand(getPrimaryDisplayId(), layer, /* slot */ 1,
1860 clearSlotBufferHandle, /*acquireFence*/ -1);
1861 // ...reset the layer buffer to the current active buffer slot with a final new command
1862 writer.setLayerBufferWithNewCommand(getPrimaryDisplayId(), layer, /*slot*/ 2, nullptr,
1863 /*acquireFence*/ -1);
1864 execute();
1865 ASSERT_TRUE(mReader.takeErrors().empty());
1866 }
1867
TEST_P(GraphicsComposerAidlCommandTest,SetLayerSurfaceDamage)1868 TEST_P(GraphicsComposerAidlCommandTest, SetLayerSurfaceDamage) {
1869 const auto& [layerStatus, layer] =
1870 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1871 EXPECT_TRUE(layerStatus.isOk());
1872
1873 Rect empty{0, 0, 0, 0};
1874 Rect unit{0, 0, 1, 1};
1875
1876 auto& writer = getWriter(getPrimaryDisplayId());
1877 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
1878 execute();
1879 ASSERT_TRUE(mReader.takeErrors().empty());
1880
1881 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
1882 execute();
1883 ASSERT_TRUE(mReader.takeErrors().empty());
1884
1885 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>());
1886 execute();
1887 ASSERT_TRUE(mReader.takeErrors().empty());
1888 }
1889
TEST_P(GraphicsComposerAidlCommandTest,SetLayerBlockingRegion)1890 TEST_P(GraphicsComposerAidlCommandTest, SetLayerBlockingRegion) {
1891 const auto& [layerStatus, layer] =
1892 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1893 EXPECT_TRUE(layerStatus.isOk());
1894
1895 Rect empty{0, 0, 0, 0};
1896 Rect unit{0, 0, 1, 1};
1897
1898 auto& writer = getWriter(getPrimaryDisplayId());
1899 writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
1900 execute();
1901 ASSERT_TRUE(mReader.takeErrors().empty());
1902
1903 writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
1904 execute();
1905 ASSERT_TRUE(mReader.takeErrors().empty());
1906
1907 writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>());
1908 execute();
1909 ASSERT_TRUE(mReader.takeErrors().empty());
1910 }
1911
TEST_P(GraphicsComposerAidlCommandTest,SetLayerBlendMode)1912 TEST_P(GraphicsComposerAidlCommandTest, SetLayerBlendMode) {
1913 const auto& [layerStatus, layer] =
1914 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1915 EXPECT_TRUE(layerStatus.isOk());
1916
1917 auto& writer = getWriter(getPrimaryDisplayId());
1918 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::NONE);
1919 execute();
1920 ASSERT_TRUE(mReader.takeErrors().empty());
1921
1922 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::PREMULTIPLIED);
1923 execute();
1924 ASSERT_TRUE(mReader.takeErrors().empty());
1925
1926 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::COVERAGE);
1927 execute();
1928 ASSERT_TRUE(mReader.takeErrors().empty());
1929 }
1930
TEST_P(GraphicsComposerAidlCommandTest,SetLayerColor)1931 TEST_P(GraphicsComposerAidlCommandTest, SetLayerColor) {
1932 const auto& [layerStatus, layer] =
1933 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1934 EXPECT_TRUE(layerStatus.isOk());
1935
1936 auto& writer = getWriter(getPrimaryDisplayId());
1937 writer.setLayerColor(getPrimaryDisplayId(), layer, Color{1.0f, 1.0f, 1.0f, 1.0f});
1938 execute();
1939 ASSERT_TRUE(mReader.takeErrors().empty());
1940
1941 writer.setLayerColor(getPrimaryDisplayId(), layer, Color{0.0f, 0.0f, 0.0f, 0.0f});
1942 execute();
1943 ASSERT_TRUE(mReader.takeErrors().empty());
1944 }
1945
TEST_P(GraphicsComposerAidlCommandTest,SetLayerCompositionType)1946 TEST_P(GraphicsComposerAidlCommandTest, SetLayerCompositionType) {
1947 const auto& [layerStatus, layer] =
1948 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1949 EXPECT_TRUE(layerStatus.isOk());
1950
1951 auto& writer = getWriter(getPrimaryDisplayId());
1952 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::CLIENT);
1953 execute();
1954 ASSERT_TRUE(mReader.takeErrors().empty());
1955
1956 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::DEVICE);
1957 execute();
1958 ASSERT_TRUE(mReader.takeErrors().empty());
1959
1960 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::SOLID_COLOR);
1961 execute();
1962 ASSERT_TRUE(mReader.takeErrors().empty());
1963
1964 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::CURSOR);
1965 execute();
1966 }
1967
TEST_P(GraphicsComposerAidlCommandTest,DisplayDecoration)1968 TEST_P(GraphicsComposerAidlCommandTest, DisplayDecoration) {
1969 for (VtsDisplay& display : mDisplays) {
1970 const auto [layerStatus, layer] =
1971 mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount);
1972 EXPECT_TRUE(layerStatus.isOk());
1973
1974 const auto [error, support] =
1975 mComposerClient->getDisplayDecorationSupport(display.getDisplayId());
1976
1977 const auto format = (error.isOk() && support) ? support->format
1978 : aidl::android::hardware::graphics::common::PixelFormat::RGBA_8888;
1979 const auto decorBuffer = allocate(static_cast<::android::PixelFormat>(format));
1980 ASSERT_NE(nullptr, decorBuffer);
1981 if (::android::OK != decorBuffer->initCheck()) {
1982 if (support) {
1983 FAIL() << "Device advertised display decoration support with format "
1984 << aidl::android::hardware::graphics::common::toString(format)
1985 << " but failed to allocate it!";
1986 } else {
1987 FAIL() << "Device advertised NO display decoration support, but it should "
1988 << "still be able to allocate "
1989 << aidl::android::hardware::graphics::common::toString(format);
1990 }
1991 }
1992
1993 configureLayer(display, layer, Composition::DISPLAY_DECORATION, display.getFrameRect(),
1994 display.getCrop());
1995 auto& writer = getWriter(display.getDisplayId());
1996 writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, decorBuffer->handle,
1997 /*acquireFence*/ -1);
1998 writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp);
1999 execute();
2000 if (support) {
2001 ASSERT_TRUE(mReader.takeErrors().empty());
2002 } else {
2003 const auto errors = mReader.takeErrors();
2004 ASSERT_EQ(1, errors.size());
2005 EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, errors[0].errorCode);
2006 }
2007 }
2008 }
2009
TEST_P(GraphicsComposerAidlCommandTest,SetLayerDataspace)2010 TEST_P(GraphicsComposerAidlCommandTest, SetLayerDataspace) {
2011 const auto& [layerStatus, layer] =
2012 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2013 EXPECT_TRUE(layerStatus.isOk());
2014
2015 auto& writer = getWriter(getPrimaryDisplayId());
2016 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
2017 execute();
2018 }
2019
TEST_P(GraphicsComposerAidlCommandTest,SetLayerDisplayFrame)2020 TEST_P(GraphicsComposerAidlCommandTest, SetLayerDisplayFrame) {
2021 const auto& [layerStatus, layer] =
2022 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2023 EXPECT_TRUE(layerStatus.isOk());
2024
2025 auto& writer = getWriter(getPrimaryDisplayId());
2026 writer.setLayerDisplayFrame(getPrimaryDisplayId(), layer, Rect{0, 0, 1, 1});
2027 execute();
2028 }
2029
TEST_P(GraphicsComposerAidlCommandTest,SetLayerPlaneAlpha)2030 TEST_P(GraphicsComposerAidlCommandTest, SetLayerPlaneAlpha) {
2031 const auto& [layerStatus, layer] =
2032 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2033 EXPECT_TRUE(layerStatus.isOk());
2034
2035 auto& writer = getWriter(getPrimaryDisplayId());
2036 writer.setLayerPlaneAlpha(getPrimaryDisplayId(), layer, /*alpha*/ 0.0f);
2037 execute();
2038 ASSERT_TRUE(mReader.takeErrors().empty());
2039
2040 writer.setLayerPlaneAlpha(getPrimaryDisplayId(), layer, /*alpha*/ 1.0f);
2041 execute();
2042 ASSERT_TRUE(mReader.takeErrors().empty());
2043 }
2044
TEST_P(GraphicsComposerAidlCommandTest,SetLayerSidebandStream)2045 TEST_P(GraphicsComposerAidlCommandTest, SetLayerSidebandStream) {
2046 if (!hasCapability(Capability::SIDEBAND_STREAM)) {
2047 GTEST_SUCCEED() << "no sideband stream support";
2048 return;
2049 }
2050
2051 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2052 const auto handle = buffer->handle;
2053 ASSERT_NE(nullptr, handle);
2054
2055 const auto& [layerStatus, layer] =
2056 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2057 EXPECT_TRUE(layerStatus.isOk());
2058
2059 auto& writer = getWriter(getPrimaryDisplayId());
2060 writer.setLayerSidebandStream(getPrimaryDisplayId(), layer, handle);
2061 execute();
2062 }
2063
TEST_P(GraphicsComposerAidlCommandTest,SetLayerSourceCrop)2064 TEST_P(GraphicsComposerAidlCommandTest, SetLayerSourceCrop) {
2065 const auto& [layerStatus, layer] =
2066 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2067 EXPECT_TRUE(layerStatus.isOk());
2068
2069 auto& writer = getWriter(getPrimaryDisplayId());
2070 writer.setLayerSourceCrop(getPrimaryDisplayId(), layer, FRect{0.0f, 0.0f, 1.0f, 1.0f});
2071 execute();
2072 }
2073
TEST_P(GraphicsComposerAidlCommandTest,SetLayerTransform)2074 TEST_P(GraphicsComposerAidlCommandTest, SetLayerTransform) {
2075 const auto& [layerStatus, layer] =
2076 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2077 EXPECT_TRUE(layerStatus.isOk());
2078
2079 auto& writer = getWriter(getPrimaryDisplayId());
2080 writer.setLayerTransform(getPrimaryDisplayId(), layer, static_cast<Transform>(0));
2081 execute();
2082 ASSERT_TRUE(mReader.takeErrors().empty());
2083
2084 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::FLIP_H);
2085 execute();
2086 ASSERT_TRUE(mReader.takeErrors().empty());
2087
2088 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::FLIP_V);
2089 execute();
2090 ASSERT_TRUE(mReader.takeErrors().empty());
2091
2092 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_90);
2093 execute();
2094 ASSERT_TRUE(mReader.takeErrors().empty());
2095
2096 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_180);
2097 execute();
2098 ASSERT_TRUE(mReader.takeErrors().empty());
2099
2100 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_270);
2101 execute();
2102 ASSERT_TRUE(mReader.takeErrors().empty());
2103
2104 writer.setLayerTransform(getPrimaryDisplayId(), layer,
2105 static_cast<Transform>(static_cast<int>(Transform::FLIP_H) |
2106 static_cast<int>(Transform::ROT_90)));
2107 execute();
2108 ASSERT_TRUE(mReader.takeErrors().empty());
2109
2110 writer.setLayerTransform(getPrimaryDisplayId(), layer,
2111 static_cast<Transform>(static_cast<int>(Transform::FLIP_V) |
2112 static_cast<int>(Transform::ROT_90)));
2113 execute();
2114 ASSERT_TRUE(mReader.takeErrors().empty());
2115 }
2116
TEST_P(GraphicsComposerAidlCommandTest,SetLayerVisibleRegion)2117 TEST_P(GraphicsComposerAidlCommandTest, SetLayerVisibleRegion) {
2118 const auto& [layerStatus, layer] =
2119 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2120 EXPECT_TRUE(layerStatus.isOk());
2121
2122 Rect empty{0, 0, 0, 0};
2123 Rect unit{0, 0, 1, 1};
2124
2125 auto& writer = getWriter(getPrimaryDisplayId());
2126 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
2127 execute();
2128 ASSERT_TRUE(mReader.takeErrors().empty());
2129
2130 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
2131 execute();
2132 ASSERT_TRUE(mReader.takeErrors().empty());
2133
2134 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>());
2135 execute();
2136 ASSERT_TRUE(mReader.takeErrors().empty());
2137 }
2138
TEST_P(GraphicsComposerAidlCommandTest,SetLayerZOrder)2139 TEST_P(GraphicsComposerAidlCommandTest, SetLayerZOrder) {
2140 const auto& [layerStatus, layer] =
2141 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2142 EXPECT_TRUE(layerStatus.isOk());
2143
2144 auto& writer = getWriter(getPrimaryDisplayId());
2145 writer.setLayerZOrder(getPrimaryDisplayId(), layer, /*z*/ 10);
2146 execute();
2147 ASSERT_TRUE(mReader.takeErrors().empty());
2148
2149 writer.setLayerZOrder(getPrimaryDisplayId(), layer, /*z*/ 0);
2150 execute();
2151 ASSERT_TRUE(mReader.takeErrors().empty());
2152 }
2153
TEST_P(GraphicsComposerAidlCommandTest,SetLayerPerFrameMetadata)2154 TEST_P(GraphicsComposerAidlCommandTest, SetLayerPerFrameMetadata) {
2155 const auto& [layerStatus, layer] =
2156 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2157 EXPECT_TRUE(layerStatus.isOk());
2158
2159 /**
2160 * DISPLAY_P3 is a color space that uses the DCI_P3 primaries,
2161 * the D65 white point and the SRGB transfer functions.
2162 * Rendering Intent: Colorimetric
2163 * Primaries:
2164 * x y
2165 * green 0.265 0.690
2166 * blue 0.150 0.060
2167 * red 0.680 0.320
2168 * white (D65) 0.3127 0.3290
2169 */
2170
2171 auto& writer = getWriter(getPrimaryDisplayId());
2172 std::vector<PerFrameMetadata> aidlMetadata;
2173 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X, 0.680f});
2174 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y, 0.320f});
2175 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X, 0.265f});
2176 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y, 0.690f});
2177 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X, 0.150f});
2178 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y, 0.060f});
2179 aidlMetadata.push_back({PerFrameMetadataKey::WHITE_POINT_X, 0.3127f});
2180 aidlMetadata.push_back({PerFrameMetadataKey::WHITE_POINT_Y, 0.3290f});
2181 aidlMetadata.push_back({PerFrameMetadataKey::MAX_LUMINANCE, 100.0f});
2182 aidlMetadata.push_back({PerFrameMetadataKey::MIN_LUMINANCE, 0.1f});
2183 aidlMetadata.push_back({PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL, 78.0});
2184 aidlMetadata.push_back({PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL, 62.0});
2185 writer.setLayerPerFrameMetadata(getPrimaryDisplayId(), layer, aidlMetadata);
2186 execute();
2187
2188 const auto errors = mReader.takeErrors();
2189 if (errors.size() == 1 && errors[0].errorCode == EX_UNSUPPORTED_OPERATION) {
2190 GTEST_SUCCEED() << "SetLayerPerFrameMetadata is not supported";
2191 EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
2192 return;
2193 }
2194
2195 EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
2196 }
2197
TEST_P(GraphicsComposerAidlCommandTest,setLayerBrightness)2198 TEST_P(GraphicsComposerAidlCommandTest, setLayerBrightness) {
2199 const auto& [layerStatus, layer] =
2200 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2201
2202 auto& writer = getWriter(getPrimaryDisplayId());
2203 writer.setLayerBrightness(getPrimaryDisplayId(), layer, 0.2f);
2204 execute();
2205 ASSERT_TRUE(mReader.takeErrors().empty());
2206
2207 writer.setLayerBrightness(getPrimaryDisplayId(), layer, 1.f);
2208 execute();
2209 ASSERT_TRUE(mReader.takeErrors().empty());
2210
2211 writer.setLayerBrightness(getPrimaryDisplayId(), layer, 0.f);
2212 execute();
2213 ASSERT_TRUE(mReader.takeErrors().empty());
2214
2215 writer.setLayerBrightness(getPrimaryDisplayId(), layer, -1.f);
2216 execute();
2217 {
2218 const auto errors = mReader.takeErrors();
2219 ASSERT_EQ(1, errors.size());
2220 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
2221 }
2222
2223 writer.setLayerBrightness(getPrimaryDisplayId(), layer, std::nanf(""));
2224 execute();
2225 {
2226 const auto errors = mReader.takeErrors();
2227 ASSERT_EQ(1, errors.size());
2228 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
2229 }
2230 }
2231
TEST_P(GraphicsComposerAidlCommandTest,SetActiveConfigWithConstraints)2232 TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints) {
2233 Test_setActiveConfigWithConstraints({.delayForChange = 0, .refreshMiss = false});
2234 }
2235
TEST_P(GraphicsComposerAidlCommandTest,SetActiveConfigWithConstraints_Delayed)2236 TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_Delayed) {
2237 Test_setActiveConfigWithConstraints({.delayForChange = 300'000'000, // 300ms
2238 .refreshMiss = false});
2239 }
2240
TEST_P(GraphicsComposerAidlCommandTest,SetActiveConfigWithConstraints_MissRefresh)2241 TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_MissRefresh) {
2242 Test_setActiveConfigWithConstraints({.delayForChange = 0, .refreshMiss = true});
2243 }
2244
TEST_P(GraphicsComposerAidlCommandTest,GetDisplayVsyncPeriod)2245 TEST_P(GraphicsComposerAidlCommandTest, GetDisplayVsyncPeriod) {
2246 for (VtsDisplay& display : mDisplays) {
2247 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
2248 EXPECT_TRUE(status.isOk());
2249
2250 for (int32_t config : configs) {
2251 int32_t expectedVsyncPeriodNanos = display.getDisplayConfig(config).vsyncPeriod;
2252
2253 VsyncPeriodChangeConstraints constraints;
2254
2255 constraints.desiredTimeNanos = systemTime();
2256 constraints.seamlessRequired = false;
2257
2258 const auto& [timelineStatus, timeline] =
2259 mComposerClient->setActiveConfigWithConstraints(&display, config, constraints);
2260 EXPECT_TRUE(timelineStatus.isOk());
2261
2262 if (timeline.refreshRequired) {
2263 sendRefreshFrame(display, &timeline);
2264 }
2265 waitForVsyncPeriodChange(display.getDisplayId(), timeline, constraints.desiredTimeNanos,
2266 /*odPeriodNanos*/ 0, expectedVsyncPeriodNanos);
2267
2268 int32_t vsyncPeriodNanos;
2269 int retryCount = 100;
2270 do {
2271 std::this_thread::sleep_for(10ms);
2272 const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanosValue] =
2273 mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
2274
2275 EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
2276 vsyncPeriodNanos = vsyncPeriodNanosValue;
2277 --retryCount;
2278 } while (vsyncPeriodNanos != expectedVsyncPeriodNanos && retryCount > 0);
2279
2280 EXPECT_EQ(vsyncPeriodNanos, expectedVsyncPeriodNanos);
2281
2282 // Make sure that the vsync period stays the same if the active config is not
2283 // changed.
2284 auto timeout = 1ms;
2285 for (int i = 0; i < 10; i++) {
2286 std::this_thread::sleep_for(timeout);
2287 timeout *= 2;
2288 vsyncPeriodNanos = 0;
2289 const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanosValue] =
2290 mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
2291
2292 EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
2293 vsyncPeriodNanos = vsyncPeriodNanosValue;
2294 EXPECT_EQ(vsyncPeriodNanos, expectedVsyncPeriodNanos);
2295 }
2296 }
2297 }
2298 }
2299
TEST_P(GraphicsComposerAidlCommandTest,SetActiveConfigWithConstraints_SeamlessNotAllowed)2300 TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_SeamlessNotAllowed) {
2301 VsyncPeriodChangeConstraints constraints;
2302 constraints.seamlessRequired = true;
2303 constraints.desiredTimeNanos = systemTime();
2304
2305 for (VtsDisplay& display : mDisplays) {
2306 forEachTwoConfigs(display.getDisplayId(), [&](int32_t config1, int32_t config2) {
2307 int32_t configGroup1 = display.getDisplayConfig(config1).configGroup;
2308 int32_t configGroup2 = display.getDisplayConfig(config2).configGroup;
2309 if (configGroup1 != configGroup2) {
2310 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
2311 sendRefreshFrame(display, nullptr);
2312 const auto& [status, _] = mComposerClient->setActiveConfigWithConstraints(
2313 &display, config2, constraints);
2314 EXPECT_FALSE(status.isOk());
2315 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(
2316 status, IComposerClient::EX_SEAMLESS_NOT_ALLOWED));
2317 }
2318 });
2319 }
2320 }
2321
TEST_P(GraphicsComposerAidlCommandTest,ExpectedPresentTime_NoTimestamp)2322 TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_NoTimestamp) {
2323 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ std::nullopt));
2324 }
2325
TEST_P(GraphicsComposerAidlCommandTest,ExpectedPresentTime_0)2326 TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_0) {
2327 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ 0));
2328 }
2329
TEST_P(GraphicsComposerAidlCommandTest,ExpectedPresentTime_5)2330 TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_5) {
2331 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ 5));
2332 }
2333
TEST_P(GraphicsComposerAidlCommandTest,SetIdleTimerEnabled_Unsupported)2334 TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Unsupported) {
2335 const bool hasDisplayIdleTimerSupport =
2336 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
2337 if (!hasDisplayIdleTimerSupport) {
2338 const auto& status =
2339 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0);
2340 EXPECT_FALSE(status.isOk());
2341 EXPECT_NO_FATAL_FAILURE(
2342 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
2343 }
2344 }
2345
TEST_P(GraphicsComposerAidlCommandTest,SetIdleTimerEnabled_BadParameter)2346 TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_BadParameter) {
2347 const bool hasDisplayIdleTimerSupport =
2348 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
2349 if (!hasDisplayIdleTimerSupport) {
2350 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2351 return;
2352 }
2353
2354 const auto& status =
2355 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ -1);
2356 EXPECT_FALSE(status.isOk());
2357 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
2358 }
2359
TEST_P(GraphicsComposerAidlCommandTest,SetIdleTimerEnabled_Disable)2360 TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Disable) {
2361 const bool hasDisplayIdleTimerSupport =
2362 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
2363 if (!hasDisplayIdleTimerSupport) {
2364 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2365 return;
2366 }
2367
2368 EXPECT_TRUE(mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0).isOk());
2369 std::this_thread::sleep_for(1s);
2370 EXPECT_EQ(0, mComposerClient->getVsyncIdleCount());
2371 }
2372
TEST_P(GraphicsComposerAidlCommandTest,SetIdleTimerEnabled_Timeout_2)2373 TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Timeout_2) {
2374 const bool hasDisplayIdleTimerSupport =
2375 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
2376 if (!hasDisplayIdleTimerSupport) {
2377 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2378 return;
2379 }
2380
2381 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
2382 EXPECT_TRUE(mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0).isOk());
2383
2384 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2385 ASSERT_NE(nullptr, buffer->handle);
2386
2387 const auto layer = createOnScreenLayer();
2388 auto& writer = getWriter(getPrimaryDisplayId());
2389 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer->handle,
2390 /*acquireFence*/ -1);
2391 int32_t vsyncIdleCount = mComposerClient->getVsyncIdleCount();
2392 auto earlyVsyncIdleTime = systemTime() + std::chrono::nanoseconds(2s).count();
2393 EXPECT_TRUE(
2394 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 2000).isOk());
2395
2396 const sp<::android::Fence> presentFence =
2397 presentAndGetFence(ComposerClientWriter::kNoTimestamp);
2398 presentFence->waitForever(LOG_TAG);
2399
2400 std::this_thread::sleep_for(3s);
2401 if (vsyncIdleCount < mComposerClient->getVsyncIdleCount()) {
2402 EXPECT_GE(mComposerClient->getVsyncIdleTime(), earlyVsyncIdleTime);
2403 }
2404
2405 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
2406 }
2407
TEST_P(GraphicsComposerAidlCommandTest,SetRefreshRateChangedCallbackDebug_Unsupported)2408 TEST_P(GraphicsComposerAidlCommandTest, SetRefreshRateChangedCallbackDebug_Unsupported) {
2409 if (getInterfaceVersion() <= 1) {
2410 GTEST_SUCCEED() << "Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG is "
2411 "not supported on older version of the service";
2412 return;
2413 }
2414 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2415 auto status = mComposerClient->setRefreshRateChangedCallbackDebugEnabled(
2416 getPrimaryDisplayId(), /*enabled*/ true);
2417 EXPECT_FALSE(status.isOk());
2418 EXPECT_NO_FATAL_FAILURE(
2419 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
2420
2421 status = mComposerClient->setRefreshRateChangedCallbackDebugEnabled(getPrimaryDisplayId(),
2422 /*enabled*/ false);
2423 EXPECT_FALSE(status.isOk());
2424 EXPECT_NO_FATAL_FAILURE(
2425 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
2426 }
2427 }
2428
TEST_P(GraphicsComposerAidlCommandTest,SetRefreshRateChangedCallbackDebug_Enabled)2429 TEST_P(GraphicsComposerAidlCommandTest, SetRefreshRateChangedCallbackDebug_Enabled) {
2430 if (getInterfaceVersion() <= 1) {
2431 GTEST_SUCCEED() << "Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG is "
2432 "not supported on older version of the service";
2433 return;
2434 }
2435 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2436 GTEST_SUCCEED() << "Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG is not supported";
2437 return;
2438 }
2439
2440 const auto displayId = getPrimaryDisplayId();
2441 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2442 // Enable the callback
2443 ASSERT_TRUE(mComposerClient
2444 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2445 /*enabled*/ true)
2446 .isOk());
2447 std::this_thread::sleep_for(100ms);
2448
2449 const auto displayFilter = [displayId](auto refreshRateChangedDebugData) {
2450 return displayId == refreshRateChangedDebugData.display;
2451 };
2452
2453 // Check that we immediately got a callback
2454 EXPECT_TRUE(checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter));
2455
2456 ASSERT_TRUE(mComposerClient
2457 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2458 /*enabled*/ false)
2459 .isOk());
2460 }
2461
TEST_P(GraphicsComposerAidlCommandTest,SetRefreshRateChangedCallbackDebugEnabled_noCallbackWhenIdle)2462 TEST_P(GraphicsComposerAidlCommandTest,
2463 SetRefreshRateChangedCallbackDebugEnabled_noCallbackWhenIdle) {
2464 if (getInterfaceVersion() <= 1) {
2465 GTEST_SUCCEED() << "Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG is "
2466 "not supported on older version of the service";
2467 return;
2468 }
2469 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2470 GTEST_SUCCEED() << "Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG is not supported";
2471 return;
2472 }
2473
2474 auto display = getEditablePrimaryDisplay();
2475 const auto displayId = display.getDisplayId();
2476
2477 if (!hasDisplayCapability(displayId, DisplayCapability::DISPLAY_IDLE_TIMER)) {
2478 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2479 return;
2480 }
2481
2482 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2483 EXPECT_TRUE(mComposerClient->setPeakRefreshRateConfig(&display).isOk());
2484
2485 ASSERT_TRUE(mComposerClient->setIdleTimerEnabled(displayId, /*timeoutMs*/ 500).isOk());
2486 // Enable the callback
2487 ASSERT_TRUE(mComposerClient
2488 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2489 /*enabled*/ true)
2490 .isOk());
2491
2492 const auto displayFilter = [displayId](auto refreshRateChangedDebugData) {
2493 return displayId == refreshRateChangedDebugData.display;
2494 };
2495
2496 int retryCount = 3;
2497 do {
2498 // Wait for 1s so that we enter the idle state
2499 std::this_thread::sleep_for(1s);
2500 if (!checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter)) {
2501 // DID NOT receive a callback, we are in the idle state.
2502 break;
2503 }
2504 } while (--retryCount > 0);
2505
2506 if (retryCount == 0) {
2507 GTEST_SUCCEED() << "Unable to enter the idle mode";
2508 return;
2509 }
2510
2511 // Send the REFRESH_RATE_INDICATOR update
2512 ASSERT_NO_FATAL_FAILURE(
2513 sendBufferUpdate(createOnScreenLayer(Composition::REFRESH_RATE_INDICATOR)));
2514 std::this_thread::sleep_for(1s);
2515 EXPECT_FALSE(checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter))
2516 << "A callback should not be received for REFRESH_RATE_INDICATOR";
2517
2518 EXPECT_TRUE(mComposerClient
2519 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2520 /*enabled*/ false)
2521 .isOk());
2522 }
2523
TEST_P(GraphicsComposerAidlCommandTest,SetRefreshRateChangedCallbackDebugEnabled_SetActiveConfigWithConstraints)2524 TEST_P(GraphicsComposerAidlCommandTest,
2525 SetRefreshRateChangedCallbackDebugEnabled_SetActiveConfigWithConstraints) {
2526 if (getInterfaceVersion() <= 1) {
2527 GTEST_SUCCEED() << "Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG is "
2528 "not supported on older version of the service";
2529 return;
2530 }
2531 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2532 GTEST_SUCCEED() << "Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG is not supported";
2533 return;
2534 }
2535
2536 VsyncPeriodChangeConstraints constraints;
2537 constraints.seamlessRequired = false;
2538 constraints.desiredTimeNanos = systemTime();
2539
2540 for (VtsDisplay& display : mDisplays) {
2541 const auto displayId = display.getDisplayId();
2542 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2543
2544 // Enable the callback
2545 ASSERT_TRUE(mComposerClient
2546 ->setRefreshRateChangedCallbackDebugEnabled(displayId, /*enabled*/ true)
2547 .isOk());
2548
2549 forEachTwoConfigs(displayId, [&](int32_t config1, int32_t config2) {
2550 const int32_t vsyncPeriod1 = display.getDisplayConfig(config1).vsyncPeriod;
2551 const int32_t vsyncPeriod2 = display.getDisplayConfig(config2).vsyncPeriod;
2552
2553 if (vsyncPeriod1 == vsyncPeriod2) {
2554 return; // continue
2555 }
2556
2557 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
2558 sendRefreshFrame(display, nullptr);
2559
2560 const auto& [status, timeline] =
2561 mComposerClient->setActiveConfigWithConstraints(&display, config2, constraints);
2562 EXPECT_TRUE(status.isOk());
2563
2564 if (timeline.refreshRequired) {
2565 sendRefreshFrame(display, &timeline);
2566 }
2567
2568 const auto callbackFilter = [displayId,
2569 vsyncPeriod2](auto refreshRateChangedDebugData) {
2570 constexpr int kVsyncThreshold = 1000;
2571 return displayId == refreshRateChangedDebugData.display &&
2572 std::abs(vsyncPeriod2 - refreshRateChangedDebugData.vsyncPeriodNanos) <=
2573 kVsyncThreshold;
2574 };
2575
2576 int retryCount = 3;
2577 do {
2578 std::this_thread::sleep_for(100ms);
2579 if (checkIfCallbackRefreshRateChangedDebugEnabledReceived(callbackFilter)) {
2580 GTEST_SUCCEED() << "Received a callback successfully";
2581 break;
2582 }
2583 } while (--retryCount > 0);
2584
2585 if (retryCount == 0) {
2586 GTEST_FAIL() << "failed to get a callback for the display " << displayId
2587 << " with config " << config2;
2588 }
2589 });
2590
2591 EXPECT_TRUE(
2592 mComposerClient
2593 ->setRefreshRateChangedCallbackDebugEnabled(displayId, /*enabled*/ false)
2594 .isOk());
2595 }
2596 }
2597
2598 /*
2599 * Test that no two display configs are exactly the same.
2600 */
TEST_P(GraphicsComposerAidlTest,GetDisplayConfigNoRepetitions)2601 TEST_P(GraphicsComposerAidlTest, GetDisplayConfigNoRepetitions) {
2602 for (const auto& display : mDisplays) {
2603 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
2604 for (std::vector<int>::size_type i = 0; i < configs.size(); i++) {
2605 for (std::vector<int>::size_type j = i + 1; j < configs.size(); j++) {
2606 const auto& [widthStatus1, width1] = mComposerClient->getDisplayAttribute(
2607 display.getDisplayId(), configs[i], DisplayAttribute::WIDTH);
2608 const auto& [heightStatus1, height1] = mComposerClient->getDisplayAttribute(
2609 display.getDisplayId(), configs[i], DisplayAttribute::HEIGHT);
2610 const auto& [vsyncPeriodStatus1, vsyncPeriod1] =
2611 mComposerClient->getDisplayAttribute(display.getDisplayId(), configs[i],
2612 DisplayAttribute::VSYNC_PERIOD);
2613 const auto& [groupStatus1, group1] = mComposerClient->getDisplayAttribute(
2614 display.getDisplayId(), configs[i], DisplayAttribute::CONFIG_GROUP);
2615
2616 const auto& [widthStatus2, width2] = mComposerClient->getDisplayAttribute(
2617 display.getDisplayId(), configs[j], DisplayAttribute::WIDTH);
2618 const auto& [heightStatus2, height2] = mComposerClient->getDisplayAttribute(
2619 display.getDisplayId(), configs[j], DisplayAttribute::HEIGHT);
2620 const auto& [vsyncPeriodStatus2, vsyncPeriod2] =
2621 mComposerClient->getDisplayAttribute(display.getDisplayId(), configs[j],
2622 DisplayAttribute::VSYNC_PERIOD);
2623 const auto& [groupStatus2, group2] = mComposerClient->getDisplayAttribute(
2624 display.getDisplayId(), configs[j], DisplayAttribute::CONFIG_GROUP);
2625
2626 ASSERT_FALSE(width1 == width2 && height1 == height2 &&
2627 vsyncPeriod1 == vsyncPeriod2 && group1 == group2);
2628 }
2629 }
2630 }
2631 }
2632
2633 /**
2634 * Test Capability::SKIP_VALIDATE
2635 *
2636 * Capability::SKIP_VALIDATE has been deprecated and should not be enabled.
2637 */
TEST_P(GraphicsComposerAidlCommandTest,SkipValidateDeprecatedTest)2638 TEST_P(GraphicsComposerAidlCommandTest, SkipValidateDeprecatedTest) {
2639 if (getInterfaceVersion() <= 1) {
2640 GTEST_SUCCEED() << "HAL at version 1 or lower can contain Capability::SKIP_VALIDATE.";
2641 return;
2642 }
2643 ASSERT_FALSE(hasCapability(Capability::SKIP_VALIDATE))
2644 << "Found Capability::SKIP_VALIDATE capability.";
2645 }
2646
2647 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlCommandTest);
2648 INSTANTIATE_TEST_SUITE_P(
2649 PerInstance, GraphicsComposerAidlCommandTest,
2650 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
2651 ::android::PrintInstanceNameToString);
2652
2653 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlTest);
2654 INSTANTIATE_TEST_SUITE_P(
2655 PerInstance, GraphicsComposerAidlTest,
2656 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
2657 ::android::PrintInstanceNameToString);
2658 } // namespace
2659 } // namespace aidl::android::hardware::graphics::composer3::vts
2660
main(int argc,char ** argv)2661 int main(int argc, char** argv) {
2662 ::testing::InitGoogleTest(&argc, argv);
2663
2664 using namespace std::chrono_literals;
2665 if (!android::base::WaitForProperty("init.svc.surfaceflinger", "stopped", 10s)) {
2666 ALOGE("Failed to stop init.svc.surfaceflinger");
2667 return -1;
2668 }
2669
2670 android::ProcessState::self()->setThreadPoolMaxThreadCount(4);
2671
2672 // The binder threadpool we start will inherit sched policy and priority
2673 // of (this) creating thread. We want the binder thread pool to have
2674 // SCHED_FIFO policy and priority 1 (lowest RT priority)
2675 // Once the pool is created we reset this thread's priority back to
2676 // original.
2677 // This thread policy is based on what we do in the SurfaceFlinger while starting
2678 // the thread pool and we need to replicate that for the VTS tests.
2679 int newPriority = 0;
2680 int origPolicy = sched_getscheduler(0);
2681 struct sched_param origSchedParam;
2682
2683 int errorInPriorityModification = sched_getparam(0, &origSchedParam);
2684 if (errorInPriorityModification == 0) {
2685 int policy = SCHED_FIFO;
2686 newPriority = sched_get_priority_min(policy);
2687
2688 struct sched_param param;
2689 param.sched_priority = newPriority;
2690
2691 errorInPriorityModification = sched_setscheduler(0, policy, ¶m);
2692 }
2693
2694 // start the thread pool
2695 android::ProcessState::self()->startThreadPool();
2696
2697 // Reset current thread's policy and priority
2698 if (errorInPriorityModification == 0) {
2699 errorInPriorityModification = sched_setscheduler(0, origPolicy, &origSchedParam);
2700 } else {
2701 ALOGE("Failed to set VtsHalGraphicsComposer3_TargetTest binder threadpool priority to "
2702 "SCHED_FIFO");
2703 }
2704
2705 return RUN_ALL_TESTS();
2706 }
2707