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/OutputType.h>
26 #include <aidl/android/hardware/graphics/composer3/IComposer.h>
27 #include <android-base/properties.h>
28 #include <android/binder_process.h>
29 #include <android/hardware/graphics/composer3/ComposerClientReader.h>
30 #include <android/hardware/graphics/composer3/ComposerClientWriter.h>
31 #include <binder/ProcessState.h>
32 #include <cutils/ashmem.h>
33 #include <gmock/gmock.h>
34 #include <gtest/gtest.h>
35 #include <ui/Fence.h>
36 #include <ui/GraphicBuffer.h>
37 #include <ui/PictureProfileHandle.h>
38 #include <ui/PixelFormat.h>
39 #include <algorithm>
40 #include <iterator>
41 #include <mutex>
42 #include <numeric>
43 #include <string>
44 #include <thread>
45 #include <unordered_map>
46 #include "GraphicsComposerCallback.h"
47 #include "VtsComposerClient.h"
48
49 #undef LOG_TAG
50 #define LOG_TAG "VtsHalGraphicsComposer3_TargetTest"
51
52 using testing::Ge;
53
54 namespace aidl::android::hardware::graphics::composer3::vts {
55
56 using namespace std::chrono_literals;
57
58 using ::android::GraphicBuffer;
59 using ::android::sp;
60
61 class GraphicsComposerAidlTest : public ::testing::TestWithParam<std::string> {
62 protected:
SetUp()63 void SetUp() override {
64 mComposerClient = std::make_unique<VtsComposerClient>(GetParam());
65 ASSERT_TRUE(mComposerClient->createClient().isOk());
66
67 const auto& [status, displays] = mComposerClient->getDisplays();
68 ASSERT_TRUE(status.isOk());
69 mDisplays = displays;
70
71 // explicitly disable vsync
72 for (const auto& display : mDisplays) {
73 EXPECT_TRUE(mComposerClient->setVsync(display.getDisplayId(), false).isOk());
74 }
75 mComposerClient->setVsyncAllowed(false);
76 }
77
TearDown()78 void TearDown() override {
79 ASSERT_TRUE(mComposerClient->tearDown(nullptr));
80 mComposerClient.reset();
81 }
82
assertServiceSpecificError(const ScopedAStatus & status,int32_t serviceSpecificError)83 void assertServiceSpecificError(const ScopedAStatus& status, int32_t serviceSpecificError) {
84 ASSERT_EQ(status.getExceptionCode(), EX_SERVICE_SPECIFIC);
85 ASSERT_EQ(status.getServiceSpecificError(), serviceSpecificError);
86 }
87
Test_setContentTypeForDisplay(int64_t display,const std::vector<ContentType> & supportedContentTypes,ContentType contentType,const char * contentTypeStr)88 void Test_setContentTypeForDisplay(int64_t display,
89 const std::vector<ContentType>& supportedContentTypes,
90 ContentType contentType, const char* contentTypeStr) {
91 const bool contentTypeSupport =
92 std::find(supportedContentTypes.begin(), supportedContentTypes.end(),
93 contentType) != supportedContentTypes.end();
94
95 if (!contentTypeSupport) {
96 const auto& status = mComposerClient->setContentType(display, contentType);
97 EXPECT_FALSE(status.isOk());
98 EXPECT_NO_FATAL_FAILURE(
99 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
100 GTEST_SUCCEED() << contentTypeStr << " content type is not supported on display "
101 << std::to_string(display) << ", skipping test";
102 return;
103 }
104
105 EXPECT_TRUE(mComposerClient->setContentType(display, contentType).isOk());
106 EXPECT_TRUE(mComposerClient->setContentType(display, ContentType::NONE).isOk());
107 }
108
Test_setContentType(ContentType contentType,const char * contentTypeStr)109 void Test_setContentType(ContentType contentType, const char* contentTypeStr) {
110 for (const auto& display : mDisplays) {
111 const auto& [status, supportedContentTypes] =
112 mComposerClient->getSupportedContentTypes(display.getDisplayId());
113 EXPECT_TRUE(status.isOk());
114 Test_setContentTypeForDisplay(display.getDisplayId(), supportedContentTypes,
115 contentType, contentTypeStr);
116 }
117 }
118
hasCapability(Capability capability)119 bool hasCapability(Capability capability) {
120 const auto& [status, capabilities] = mComposerClient->getCapabilities();
121 EXPECT_TRUE(status.isOk());
122 return std::any_of(
123 capabilities.begin(), capabilities.end(),
124 [&](const Capability& activeCapability) { return activeCapability == capability; });
125 }
126
hasDisplayCapability(int64_t displayId,DisplayCapability capability)127 bool hasDisplayCapability(int64_t displayId, DisplayCapability capability) {
128 const auto& [status, capabilities] = mComposerClient->getDisplayCapabilities(displayId);
129 EXPECT_TRUE(status.isOk());
130 return std::any_of(capabilities.begin(), capabilities.end(),
131 [&](const DisplayCapability& activeCapability) {
132 return activeCapability == capability;
133 });
134 }
135
getInterfaceVersion()136 int getInterfaceVersion() {
137 const auto& [versionStatus, version] = mComposerClient->getInterfaceVersion();
138 EXPECT_TRUE(versionStatus.isOk());
139 return version;
140 }
141
getPrimaryDisplay() const142 const VtsDisplay& getPrimaryDisplay() const { return mDisplays[0]; }
143
getPrimaryDisplayId() const144 int64_t getPrimaryDisplayId() const { return getPrimaryDisplay().getDisplayId(); }
145
getInvalidDisplayId() const146 int64_t getInvalidDisplayId() const { return mComposerClient->getInvalidDisplayId(); }
147
getEditablePrimaryDisplay()148 VtsDisplay& getEditablePrimaryDisplay() { return mDisplays[0]; }
149
150 struct TestParameters {
151 nsecs_t delayForChange;
152 bool refreshMiss;
153 };
154
155 std::unique_ptr<VtsComposerClient> mComposerClient;
156 std::vector<VtsDisplay> mDisplays;
157 // use the slot count usually set by SF
158 static constexpr uint32_t kBufferSlotCount = 64;
159 };
160
TEST_P(GraphicsComposerAidlTest,GetDisplayCapabilities_BadDisplay)161 TEST_P(GraphicsComposerAidlTest, GetDisplayCapabilities_BadDisplay) {
162 const auto& [status, _] = mComposerClient->getDisplayCapabilities(getInvalidDisplayId());
163
164 EXPECT_FALSE(status.isOk());
165 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
166 }
167
TEST_P(GraphicsComposerAidlTest,GetDisplayCapabilities)168 TEST_P(GraphicsComposerAidlTest, GetDisplayCapabilities) {
169 for (const auto& display : mDisplays) {
170 const auto& [status, capabilities] =
171 mComposerClient->getDisplayCapabilities(display.getDisplayId());
172
173 EXPECT_TRUE(status.isOk());
174 }
175 }
176
TEST_P(GraphicsComposerAidlTest,DumpDebugInfo)177 TEST_P(GraphicsComposerAidlTest, DumpDebugInfo) {
178 ASSERT_TRUE(mComposerClient->dumpDebugInfo().isOk());
179 }
180
TEST_P(GraphicsComposerAidlTest,CreateClientSingleton)181 TEST_P(GraphicsComposerAidlTest, CreateClientSingleton) {
182 std::shared_ptr<IComposerClient> composerClient;
183 const auto& status = mComposerClient->createClient();
184
185 EXPECT_FALSE(status.isOk());
186 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_NO_RESOURCES));
187 }
188
TEST_P(GraphicsComposerAidlTest,GetDisplayIdentificationData)189 TEST_P(GraphicsComposerAidlTest, GetDisplayIdentificationData) {
190 const auto& [status0, displayIdentification0] =
191 mComposerClient->getDisplayIdentificationData(getPrimaryDisplayId());
192 if (!status0.isOk() && status0.getExceptionCode() == EX_SERVICE_SPECIFIC &&
193 status0.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
194 GTEST_SUCCEED() << "Display identification data not supported, skipping test";
195 return;
196 }
197 ASSERT_TRUE(status0.isOk()) << "failed to get display identification data";
198 ASSERT_FALSE(displayIdentification0.data.empty());
199
200 constexpr size_t kEdidBlockSize = 128;
201 ASSERT_TRUE(displayIdentification0.data.size() % kEdidBlockSize == 0)
202 << "EDID blob length is not a multiple of " << kEdidBlockSize;
203
204 const uint8_t kEdidHeader[] = {0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00};
205 ASSERT_TRUE(std::equal(std::begin(kEdidHeader), std::end(kEdidHeader),
206 displayIdentification0.data.begin()))
207 << "EDID blob doesn't start with the fixed EDID header";
208 ASSERT_EQ(0, std::accumulate(displayIdentification0.data.begin(),
209 displayIdentification0.data.begin() + kEdidBlockSize,
210 static_cast<uint8_t>(0)))
211 << "EDID base block doesn't checksum";
212
213 const auto& [status1, displayIdentification1] =
214 mComposerClient->getDisplayIdentificationData(getPrimaryDisplayId());
215 ASSERT_TRUE(status1.isOk());
216
217 ASSERT_EQ(displayIdentification0.port, displayIdentification1.port) << "ports are not stable";
218 ASSERT_TRUE(displayIdentification0.data.size() == displayIdentification1.data.size() &&
219 std::equal(displayIdentification0.data.begin(), displayIdentification0.data.end(),
220 displayIdentification1.data.begin()))
221 << "data is not stable";
222 }
223
TEST_P(GraphicsComposerAidlTest,GetHdrCapabilities)224 TEST_P(GraphicsComposerAidlTest, GetHdrCapabilities) {
225 const auto& [status, hdrCapabilities] =
226 mComposerClient->getHdrCapabilities(getPrimaryDisplayId());
227
228 ASSERT_TRUE(status.isOk());
229 EXPECT_TRUE(hdrCapabilities.maxLuminance >= hdrCapabilities.minLuminance);
230 }
231
TEST_P(GraphicsComposerAidlTest,GetPerFrameMetadataKeys)232 TEST_P(GraphicsComposerAidlTest, GetPerFrameMetadataKeys) {
233 const auto& [status, keys] = mComposerClient->getPerFrameMetadataKeys(getPrimaryDisplayId());
234 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
235 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
236 GTEST_SUCCEED() << "getPerFrameMetadataKeys is not supported";
237 return;
238 }
239
240 ASSERT_TRUE(status.isOk());
241 EXPECT_TRUE(keys.size() >= 0);
242 }
243
TEST_P(GraphicsComposerAidlTest,GetReadbackBufferAttributes)244 TEST_P(GraphicsComposerAidlTest, GetReadbackBufferAttributes) {
245 const auto& [status, _] = mComposerClient->getReadbackBufferAttributes(getPrimaryDisplayId());
246 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
247 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
248 GTEST_SUCCEED() << "getReadbackBufferAttributes is not supported";
249 return;
250 }
251
252 ASSERT_TRUE(status.isOk());
253 }
254
TEST_P(GraphicsComposerAidlTest,GetRenderIntents)255 TEST_P(GraphicsComposerAidlTest, GetRenderIntents) {
256 const auto& [status, modes] = mComposerClient->getColorModes(getPrimaryDisplayId());
257 EXPECT_TRUE(status.isOk());
258
259 for (auto mode : modes) {
260 const auto& [intentStatus, intents] =
261 mComposerClient->getRenderIntents(getPrimaryDisplayId(), mode);
262 EXPECT_TRUE(intentStatus.isOk());
263 bool isHdr;
264 switch (mode) {
265 case ColorMode::BT2100_PQ:
266 case ColorMode::BT2100_HLG:
267 isHdr = true;
268 break;
269 default:
270 isHdr = false;
271 break;
272 }
273 RenderIntent requiredIntent =
274 isHdr ? RenderIntent::TONE_MAP_COLORIMETRIC : RenderIntent::COLORIMETRIC;
275
276 const auto iter = std::find(intents.cbegin(), intents.cend(), requiredIntent);
277 EXPECT_NE(intents.cend(), iter);
278 }
279 }
280
TEST_P(GraphicsComposerAidlTest,GetRenderIntents_BadDisplay)281 TEST_P(GraphicsComposerAidlTest, GetRenderIntents_BadDisplay) {
282 const auto& [status, modes] = mComposerClient->getColorModes(getPrimaryDisplayId());
283 ASSERT_TRUE(status.isOk());
284
285 for (auto mode : modes) {
286 const auto& [intentStatus, _] =
287 mComposerClient->getRenderIntents(getInvalidDisplayId(), mode);
288
289 EXPECT_FALSE(intentStatus.isOk());
290 EXPECT_NO_FATAL_FAILURE(
291 assertServiceSpecificError(intentStatus, IComposerClient::EX_BAD_DISPLAY));
292 }
293 }
294
TEST_P(GraphicsComposerAidlTest,GetRenderIntents_BadParameter)295 TEST_P(GraphicsComposerAidlTest, GetRenderIntents_BadParameter) {
296 const auto& [status, _] =
297 mComposerClient->getRenderIntents(getPrimaryDisplayId(), static_cast<ColorMode>(-1));
298
299 EXPECT_FALSE(status.isOk());
300 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
301 }
302
TEST_P(GraphicsComposerAidlTest,GetColorModes)303 TEST_P(GraphicsComposerAidlTest, GetColorModes) {
304 const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
305 ASSERT_TRUE(status.isOk());
306
307 const auto native = std::find(colorModes.cbegin(), colorModes.cend(), ColorMode::NATIVE);
308 EXPECT_NE(colorModes.cend(), native);
309 }
310
TEST_P(GraphicsComposerAidlTest,GetColorMode_BadDisplay)311 TEST_P(GraphicsComposerAidlTest, GetColorMode_BadDisplay) {
312 const auto& [status, _] = mComposerClient->getColorModes(getInvalidDisplayId());
313
314 EXPECT_FALSE(status.isOk());
315 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
316 }
317
TEST_P(GraphicsComposerAidlTest,SetColorMode)318 TEST_P(GraphicsComposerAidlTest, SetColorMode) {
319 const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
320 EXPECT_TRUE(status.isOk());
321
322 for (auto mode : colorModes) {
323 const auto& [intentStatus, intents] =
324 mComposerClient->getRenderIntents(getPrimaryDisplayId(), mode);
325 EXPECT_TRUE(intentStatus.isOk()) << "failed to get render intents";
326
327 for (auto intent : intents) {
328 const auto modeStatus =
329 mComposerClient->setColorMode(getPrimaryDisplayId(), mode, intent);
330 EXPECT_TRUE(modeStatus.isOk() ||
331 (modeStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
332 IComposerClient::EX_UNSUPPORTED == modeStatus.getServiceSpecificError()))
333 << "failed to set color mode";
334 }
335 }
336
337 const auto modeStatus = mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE,
338 RenderIntent::COLORIMETRIC);
339 EXPECT_TRUE(modeStatus.isOk() ||
340 (modeStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
341 IComposerClient::EX_UNSUPPORTED == modeStatus.getServiceSpecificError()))
342 << "failed to set color mode";
343 }
344
TEST_P(GraphicsComposerAidlTest,SetColorMode_BadDisplay)345 TEST_P(GraphicsComposerAidlTest, SetColorMode_BadDisplay) {
346 const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
347 ASSERT_TRUE(status.isOk());
348
349 for (auto mode : colorModes) {
350 const auto& [intentStatus, intents] =
351 mComposerClient->getRenderIntents(getPrimaryDisplayId(), mode);
352 ASSERT_TRUE(intentStatus.isOk()) << "failed to get render intents";
353
354 for (auto intent : intents) {
355 auto const modeStatus =
356 mComposerClient->setColorMode(getInvalidDisplayId(), mode, intent);
357
358 EXPECT_FALSE(modeStatus.isOk());
359 EXPECT_NO_FATAL_FAILURE(
360 assertServiceSpecificError(modeStatus, IComposerClient::EX_BAD_DISPLAY));
361 }
362 }
363 }
364
TEST_P(GraphicsComposerAidlTest,SetColorMode_BadParameter)365 TEST_P(GraphicsComposerAidlTest, SetColorMode_BadParameter) {
366 auto status = mComposerClient->setColorMode(getPrimaryDisplayId(), static_cast<ColorMode>(-1),
367 RenderIntent::COLORIMETRIC);
368
369 EXPECT_FALSE(status.isOk());
370 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
371
372 status = mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE,
373 static_cast<RenderIntent>(-1));
374
375 EXPECT_FALSE(status.isOk());
376 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
377 }
378
TEST_P(GraphicsComposerAidlTest,GetDisplayedContentSamplingAttributes)379 TEST_P(GraphicsComposerAidlTest, GetDisplayedContentSamplingAttributes) {
380 int constexpr kInvalid = -1;
381 const auto& [status, format] =
382 mComposerClient->getDisplayedContentSamplingAttributes(getPrimaryDisplayId());
383
384 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
385 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
386 SUCCEED() << "Device does not support optional extension. Test skipped";
387 return;
388 }
389
390 ASSERT_TRUE(status.isOk());
391 EXPECT_NE(kInvalid, static_cast<int>(format.format));
392 EXPECT_NE(kInvalid, static_cast<int>(format.dataspace));
393 EXPECT_NE(kInvalid, static_cast<int>(format.componentMask));
394 };
395
TEST_P(GraphicsComposerAidlTest,SetDisplayedContentSamplingEnabled)396 TEST_P(GraphicsComposerAidlTest, SetDisplayedContentSamplingEnabled) {
397 int constexpr kMaxFrames = 10;
398 FormatColorComponent enableAllComponents = FormatColorComponent::FORMAT_COMPONENT_0;
399 auto status = mComposerClient->setDisplayedContentSamplingEnabled(
400 getPrimaryDisplayId(), /*isEnabled*/ true, enableAllComponents, kMaxFrames);
401 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
402 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
403 SUCCEED() << "Device does not support optional extension. Test skipped";
404 return;
405 }
406 EXPECT_TRUE(status.isOk());
407
408 status = mComposerClient->setDisplayedContentSamplingEnabled(
409 getPrimaryDisplayId(), /*isEnabled*/ false, enableAllComponents, kMaxFrames);
410 EXPECT_TRUE(status.isOk());
411 }
412
TEST_P(GraphicsComposerAidlTest,GetDisplayedContentSample)413 TEST_P(GraphicsComposerAidlTest, GetDisplayedContentSample) {
414 const auto& [status, displayContentSamplingAttributes] =
415 mComposerClient->getDisplayedContentSamplingAttributes(getPrimaryDisplayId());
416 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
417 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
418 SUCCEED() << "Sampling attributes aren't supported on this device, test skipped";
419 return;
420 }
421
422 int64_t constexpr kMaxFrames = 10;
423 int64_t constexpr kTimestamp = 0;
424 const auto& [sampleStatus, displayContentSample] = mComposerClient->getDisplayedContentSample(
425 getPrimaryDisplayId(), kMaxFrames, kTimestamp);
426 if (!sampleStatus.isOk() && sampleStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
427 sampleStatus.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
428 SUCCEED() << "Device does not support optional extension. Test skipped";
429 return;
430 }
431
432 EXPECT_TRUE(sampleStatus.isOk());
433 const std::vector<std::vector<int64_t>> histogram = {
434 displayContentSample.sampleComponent0, displayContentSample.sampleComponent1,
435 displayContentSample.sampleComponent2, displayContentSample.sampleComponent3};
436
437 for (size_t i = 0; i < histogram.size(); i++) {
438 const bool shouldHaveHistogram =
439 static_cast<int>(displayContentSamplingAttributes.componentMask) & (1 << i);
440 EXPECT_EQ(shouldHaveHistogram, !histogram[i].empty());
441 }
442 }
443
TEST_P(GraphicsComposerAidlTest,GetDisplayConnectionType)444 TEST_P(GraphicsComposerAidlTest, GetDisplayConnectionType) {
445 const auto& [status, type] = mComposerClient->getDisplayConnectionType(getInvalidDisplayId());
446
447 EXPECT_FALSE(status.isOk());
448 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
449
450 for (const auto& display : mDisplays) {
451 const auto& [connectionTypeStatus, _] =
452 mComposerClient->getDisplayConnectionType(display.getDisplayId());
453 EXPECT_TRUE(connectionTypeStatus.isOk());
454 }
455 }
456
TEST_P(GraphicsComposerAidlTest,GetDisplayAttribute)457 TEST_P(GraphicsComposerAidlTest, GetDisplayAttribute) {
458 for (const auto& display : mDisplays) {
459 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
460 EXPECT_TRUE(status.isOk());
461
462 for (const auto& config : configs) {
463 const std::array<DisplayAttribute, 4> requiredAttributes = {{
464 DisplayAttribute::WIDTH,
465 DisplayAttribute::HEIGHT,
466 DisplayAttribute::VSYNC_PERIOD,
467 DisplayAttribute::CONFIG_GROUP,
468 }};
469 for (const auto& attribute : requiredAttributes) {
470 const auto& [attribStatus, value] = mComposerClient->getDisplayAttribute(
471 display.getDisplayId(), config, attribute);
472 EXPECT_TRUE(attribStatus.isOk());
473 EXPECT_NE(-1, value);
474 }
475
476 const std::array<DisplayAttribute, 2> optionalAttributes = {{
477 DisplayAttribute::DPI_X,
478 DisplayAttribute::DPI_Y,
479 }};
480 for (const auto& attribute : optionalAttributes) {
481 const auto& [attribStatus, value] = mComposerClient->getDisplayAttribute(
482 display.getDisplayId(), config, attribute);
483 EXPECT_TRUE(attribStatus.isOk() ||
484 (attribStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
485 IComposerClient::EX_UNSUPPORTED ==
486 attribStatus.getServiceSpecificError()));
487 }
488 }
489 }
490 }
491
TEST_P(GraphicsComposerAidlTest,CheckConfigsAreValid)492 TEST_P(GraphicsComposerAidlTest, CheckConfigsAreValid) {
493 for (const auto& display : mDisplays) {
494 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
495 EXPECT_TRUE(status.isOk());
496
497 EXPECT_FALSE(std::any_of(configs.begin(), configs.end(), [](auto config) {
498 return config == IComposerClient::INVALID_CONFIGURATION;
499 }));
500 }
501 }
502
TEST_P(GraphicsComposerAidlTest,GetDisplayVsyncPeriod_BadDisplay)503 TEST_P(GraphicsComposerAidlTest, GetDisplayVsyncPeriod_BadDisplay) {
504 const auto& [status, vsyncPeriodNanos] =
505 mComposerClient->getDisplayVsyncPeriod(getInvalidDisplayId());
506
507 EXPECT_FALSE(status.isOk());
508 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
509 }
510
TEST_P(GraphicsComposerAidlTest,SetActiveConfigWithConstraints_BadDisplay)511 TEST_P(GraphicsComposerAidlTest, SetActiveConfigWithConstraints_BadDisplay) {
512 VsyncPeriodChangeConstraints constraints;
513 constraints.seamlessRequired = false;
514 constraints.desiredTimeNanos = systemTime();
515 auto invalidDisplay = VtsDisplay(getInvalidDisplayId());
516
517 const auto& [status, timeline] = mComposerClient->setActiveConfigWithConstraints(
518 &invalidDisplay, /*config*/ 0, constraints);
519
520 EXPECT_FALSE(status.isOk());
521 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
522 }
523
TEST_P(GraphicsComposerAidlTest,SetActiveConfigWithConstraints_BadConfig)524 TEST_P(GraphicsComposerAidlTest, SetActiveConfigWithConstraints_BadConfig) {
525 VsyncPeriodChangeConstraints constraints;
526 constraints.seamlessRequired = false;
527 constraints.desiredTimeNanos = systemTime();
528
529 for (VtsDisplay& display : mDisplays) {
530 int32_t constexpr kInvalidConfigId = IComposerClient::INVALID_CONFIGURATION;
531 const auto& [status, _] = mComposerClient->setActiveConfigWithConstraints(
532 &display, kInvalidConfigId, constraints);
533
534 EXPECT_FALSE(status.isOk());
535 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_CONFIG));
536 }
537 }
538
TEST_P(GraphicsComposerAidlTest,SetBootDisplayConfig_BadDisplay)539 TEST_P(GraphicsComposerAidlTest, SetBootDisplayConfig_BadDisplay) {
540 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
541 GTEST_SUCCEED() << "Boot Display Config not supported";
542 return;
543 }
544 const auto& status = mComposerClient->setBootDisplayConfig(getInvalidDisplayId(), /*config*/ 0);
545
546 EXPECT_FALSE(status.isOk());
547 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
548 }
549
TEST_P(GraphicsComposerAidlTest,SetBootDisplayConfig_BadConfig)550 TEST_P(GraphicsComposerAidlTest, SetBootDisplayConfig_BadConfig) {
551 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
552 GTEST_SUCCEED() << "Boot Display Config not supported";
553 return;
554 }
555 for (VtsDisplay& display : mDisplays) {
556 int32_t constexpr kInvalidConfigId = IComposerClient::INVALID_CONFIGURATION;
557 const auto& status =
558 mComposerClient->setBootDisplayConfig(display.getDisplayId(), kInvalidConfigId);
559
560 EXPECT_FALSE(status.isOk());
561 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_CONFIG));
562 }
563 }
564
TEST_P(GraphicsComposerAidlTest,SetBootDisplayConfig)565 TEST_P(GraphicsComposerAidlTest, SetBootDisplayConfig) {
566 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
567 GTEST_SUCCEED() << "Boot Display Config not supported";
568 return;
569 }
570 const auto& [status, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
571 EXPECT_TRUE(status.isOk());
572 for (const auto& config : configs) {
573 EXPECT_TRUE(mComposerClient->setBootDisplayConfig(getPrimaryDisplayId(), config).isOk());
574 }
575 }
576
TEST_P(GraphicsComposerAidlTest,ClearBootDisplayConfig_BadDisplay)577 TEST_P(GraphicsComposerAidlTest, ClearBootDisplayConfig_BadDisplay) {
578 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
579 GTEST_SUCCEED() << "Boot Display Config not supported";
580 return;
581 }
582 const auto& status = mComposerClient->clearBootDisplayConfig(getInvalidDisplayId());
583
584 EXPECT_FALSE(status.isOk());
585 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
586 }
587
TEST_P(GraphicsComposerAidlTest,ClearBootDisplayConfig)588 TEST_P(GraphicsComposerAidlTest, ClearBootDisplayConfig) {
589 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
590 GTEST_SUCCEED() << "Boot Display Config not supported";
591 return;
592 }
593 EXPECT_TRUE(mComposerClient->clearBootDisplayConfig(getPrimaryDisplayId()).isOk());
594 }
595
TEST_P(GraphicsComposerAidlTest,GetPreferredBootDisplayConfig_BadDisplay)596 TEST_P(GraphicsComposerAidlTest, GetPreferredBootDisplayConfig_BadDisplay) {
597 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
598 GTEST_SUCCEED() << "Boot Display Config not supported";
599 return;
600 }
601 const auto& [status, _] = mComposerClient->getPreferredBootDisplayConfig(getInvalidDisplayId());
602
603 EXPECT_FALSE(status.isOk());
604 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
605 }
606
TEST_P(GraphicsComposerAidlTest,GetPreferredBootDisplayConfig)607 TEST_P(GraphicsComposerAidlTest, GetPreferredBootDisplayConfig) {
608 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
609 GTEST_SUCCEED() << "Boot Display Config not supported";
610 return;
611 }
612 const auto& [status, preferredDisplayConfig] =
613 mComposerClient->getPreferredBootDisplayConfig(getPrimaryDisplayId());
614 EXPECT_TRUE(status.isOk());
615
616 const auto& [configStatus, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
617
618 EXPECT_TRUE(configStatus.isOk());
619 EXPECT_NE(configs.end(), std::find(configs.begin(), configs.end(), preferredDisplayConfig));
620 }
621
TEST_P(GraphicsComposerAidlTest,BootDisplayConfig_Unsupported)622 TEST_P(GraphicsComposerAidlTest, BootDisplayConfig_Unsupported) {
623 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
624 const auto& [configStatus, config] =
625 mComposerClient->getActiveConfig(getPrimaryDisplayId());
626 EXPECT_TRUE(configStatus.isOk());
627
628 auto status = mComposerClient->setBootDisplayConfig(getPrimaryDisplayId(), config);
629 EXPECT_FALSE(status.isOk());
630 EXPECT_NO_FATAL_FAILURE(
631 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
632
633 status = mComposerClient->getPreferredBootDisplayConfig(getPrimaryDisplayId()).first;
634 EXPECT_FALSE(status.isOk());
635 EXPECT_NO_FATAL_FAILURE(
636 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
637
638 status = mComposerClient->clearBootDisplayConfig(getPrimaryDisplayId());
639 EXPECT_FALSE(status.isOk());
640 EXPECT_NO_FATAL_FAILURE(
641 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
642 }
643 }
644
TEST_P(GraphicsComposerAidlTest,GetHdrConversionCapabilities)645 TEST_P(GraphicsComposerAidlTest, GetHdrConversionCapabilities) {
646 if (!hasCapability(Capability::HDR_OUTPUT_CONVERSION_CONFIG)) {
647 GTEST_SUCCEED() << "HDR output conversion not supported";
648 return;
649 }
650 const auto& [status, conversionCapabilities] = mComposerClient->getHdrConversionCapabilities();
651 EXPECT_TRUE(status.isOk());
652 }
653
TEST_P(GraphicsComposerAidlTest,SetHdrConversionStrategy_Passthrough)654 TEST_P(GraphicsComposerAidlTest, SetHdrConversionStrategy_Passthrough) {
655 if (!hasCapability(Capability::HDR_OUTPUT_CONVERSION_CONFIG)) {
656 GTEST_SUCCEED() << "HDR output conversion not supported";
657 return;
658 }
659 common::HdrConversionStrategy hdrConversionStrategy;
660 hdrConversionStrategy.set<common::HdrConversionStrategy::Tag::passthrough>(true);
661 const auto& [status, preferredHdrOutputType] =
662 mComposerClient->setHdrConversionStrategy(hdrConversionStrategy);
663 EXPECT_TRUE(status.isOk());
664 EXPECT_EQ(common::Hdr::INVALID, preferredHdrOutputType);
665 }
666
TEST_P(GraphicsComposerAidlTest,SetHdrConversionStrategy_Force)667 TEST_P(GraphicsComposerAidlTest, SetHdrConversionStrategy_Force) {
668 if (!hasCapability(Capability::HDR_OUTPUT_CONVERSION_CONFIG)) {
669 GTEST_SUCCEED() << "HDR output conversion not supported";
670 return;
671 }
672 const auto& [status, conversionCapabilities] = mComposerClient->getHdrConversionCapabilities();
673 const auto& [status2, hdrCapabilities] =
674 mComposerClient->getHdrCapabilities(getPrimaryDisplayId());
675 const auto& hdrTypes = hdrCapabilities.types;
676 for (auto conversionCapability : conversionCapabilities) {
677 if (conversionCapability.outputType != common::Hdr::INVALID) {
678 if (std::find(hdrTypes.begin(), hdrTypes.end(), conversionCapability.outputType) ==
679 hdrTypes.end()) {
680 continue;
681 }
682 common::HdrConversionStrategy hdrConversionStrategy;
683 hdrConversionStrategy.set<common::HdrConversionStrategy::Tag::forceHdrConversion>(
684 conversionCapability.outputType);
685 const auto& [statusSet, preferredHdrOutputType] =
686 mComposerClient->setHdrConversionStrategy(hdrConversionStrategy);
687 EXPECT_TRUE(statusSet.isOk());
688 EXPECT_EQ(common::Hdr::INVALID, preferredHdrOutputType);
689 }
690 }
691 }
692
TEST_P(GraphicsComposerAidlTest,SetHdrConversionStrategy_Auto)693 TEST_P(GraphicsComposerAidlTest, SetHdrConversionStrategy_Auto) {
694 if (!hasCapability(Capability::HDR_OUTPUT_CONVERSION_CONFIG)) {
695 GTEST_SUCCEED() << "HDR output conversion not supported";
696 return;
697 }
698 const auto& [status, conversionCapabilities] = mComposerClient->getHdrConversionCapabilities();
699 const auto& [status2, hdrCapabilities] =
700 mComposerClient->getHdrCapabilities(getPrimaryDisplayId());
701 if (hdrCapabilities.types.size() <= 0) {
702 return;
703 }
704 std::vector<aidl::android::hardware::graphics::common::Hdr> autoHdrTypes;
705 for (auto conversionCapability : conversionCapabilities) {
706 if (conversionCapability.outputType != common::Hdr::INVALID) {
707 autoHdrTypes.push_back(conversionCapability.outputType);
708 }
709 }
710 common::HdrConversionStrategy hdrConversionStrategy;
711 hdrConversionStrategy.set<common::HdrConversionStrategy::Tag::autoAllowedHdrTypes>(
712 autoHdrTypes);
713 const auto& [statusSet, preferredHdrOutputType] =
714 mComposerClient->setHdrConversionStrategy(hdrConversionStrategy);
715 EXPECT_TRUE(statusSet.isOk());
716 EXPECT_NE(common::Hdr::INVALID, preferredHdrOutputType);
717 }
718
TEST_P(GraphicsComposerAidlTest,SetAutoLowLatencyMode_BadDisplay)719 TEST_P(GraphicsComposerAidlTest, SetAutoLowLatencyMode_BadDisplay) {
720 auto status = mComposerClient->setAutoLowLatencyMode(getInvalidDisplayId(), /*isEnabled*/ true);
721 EXPECT_FALSE(status.isOk());
722 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
723
724 status = mComposerClient->setAutoLowLatencyMode(getInvalidDisplayId(), /*isEnabled*/ false);
725 EXPECT_FALSE(status.isOk());
726 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
727 }
728
TEST_P(GraphicsComposerAidlTest,SetAutoLowLatencyMode)729 TEST_P(GraphicsComposerAidlTest, SetAutoLowLatencyMode) {
730 for (const auto& display : mDisplays) {
731 const auto& [status, capabilities] =
732 mComposerClient->getDisplayCapabilities(display.getDisplayId());
733 ASSERT_TRUE(status.isOk());
734
735 const bool allmSupport =
736 std::find(capabilities.begin(), capabilities.end(),
737 DisplayCapability::AUTO_LOW_LATENCY_MODE) != capabilities.end();
738
739 if (!allmSupport) {
740 const auto& statusIsOn = mComposerClient->setAutoLowLatencyMode(display.getDisplayId(),
741 /*isEnabled*/ true);
742 EXPECT_FALSE(statusIsOn.isOk());
743 EXPECT_NO_FATAL_FAILURE(
744 assertServiceSpecificError(statusIsOn, IComposerClient::EX_UNSUPPORTED));
745 const auto& statusIsOff = mComposerClient->setAutoLowLatencyMode(display.getDisplayId(),
746 /*isEnabled*/ false);
747 EXPECT_FALSE(statusIsOff.isOk());
748 EXPECT_NO_FATAL_FAILURE(
749 assertServiceSpecificError(statusIsOff, IComposerClient::EX_UNSUPPORTED));
750 GTEST_SUCCEED() << "Auto Low Latency Mode is not supported on display "
751 << std::to_string(display.getDisplayId()) << ", skipping test";
752 return;
753 }
754
755 EXPECT_TRUE(mComposerClient->setAutoLowLatencyMode(display.getDisplayId(), true).isOk());
756 EXPECT_TRUE(mComposerClient->setAutoLowLatencyMode(display.getDisplayId(), false).isOk());
757 }
758 }
759
TEST_P(GraphicsComposerAidlTest,GetSupportedContentTypes_BadDisplay)760 TEST_P(GraphicsComposerAidlTest, GetSupportedContentTypes_BadDisplay) {
761 const auto& [status, _] = mComposerClient->getSupportedContentTypes(getInvalidDisplayId());
762
763 EXPECT_FALSE(status.isOk());
764 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
765 }
766
TEST_P(GraphicsComposerAidlTest,GetSupportedContentTypes)767 TEST_P(GraphicsComposerAidlTest, GetSupportedContentTypes) {
768 for (const auto& display : mDisplays) {
769 const auto& [status, supportedContentTypes] =
770 mComposerClient->getSupportedContentTypes(display.getDisplayId());
771 ASSERT_TRUE(status.isOk());
772
773 const bool noneSupported =
774 std::find(supportedContentTypes.begin(), supportedContentTypes.end(),
775 ContentType::NONE) != supportedContentTypes.end();
776
777 EXPECT_FALSE(noneSupported);
778 }
779 }
780
TEST_P(GraphicsComposerAidlTest,SetContentTypeNoneAlwaysAccepted)781 TEST_P(GraphicsComposerAidlTest, SetContentTypeNoneAlwaysAccepted) {
782 for (const auto& display : mDisplays) {
783 EXPECT_TRUE(
784 mComposerClient->setContentType(display.getDisplayId(), ContentType::NONE).isOk());
785 }
786 }
787
TEST_P(GraphicsComposerAidlTest,SetContentType_BadDisplay)788 TEST_P(GraphicsComposerAidlTest, SetContentType_BadDisplay) {
789 constexpr ContentType types[] = {ContentType::NONE, ContentType::GRAPHICS, ContentType::PHOTO,
790 ContentType::CINEMA, ContentType::GAME};
791 for (const auto& type : types) {
792 const auto& status = mComposerClient->setContentType(getInvalidDisplayId(), type);
793
794 EXPECT_FALSE(status.isOk());
795 EXPECT_NO_FATAL_FAILURE(
796 assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
797 }
798 }
799
TEST_P(GraphicsComposerAidlTest,SetGraphicsContentType)800 TEST_P(GraphicsComposerAidlTest, SetGraphicsContentType) {
801 Test_setContentType(ContentType::GRAPHICS, "GRAPHICS");
802 }
803
TEST_P(GraphicsComposerAidlTest,SetPhotoContentType)804 TEST_P(GraphicsComposerAidlTest, SetPhotoContentType) {
805 Test_setContentType(ContentType::PHOTO, "PHOTO");
806 }
807
TEST_P(GraphicsComposerAidlTest,SetCinemaContentType)808 TEST_P(GraphicsComposerAidlTest, SetCinemaContentType) {
809 Test_setContentType(ContentType::CINEMA, "CINEMA");
810 }
811
TEST_P(GraphicsComposerAidlTest,SetGameContentType)812 TEST_P(GraphicsComposerAidlTest, SetGameContentType) {
813 Test_setContentType(ContentType::GAME, "GAME");
814 }
815
TEST_P(GraphicsComposerAidlTest,CreateVirtualDisplay)816 TEST_P(GraphicsComposerAidlTest, CreateVirtualDisplay) {
817 const auto& [status, maxVirtualDisplayCount] = mComposerClient->getMaxVirtualDisplayCount();
818 EXPECT_TRUE(status.isOk());
819
820 if (maxVirtualDisplayCount == 0) {
821 GTEST_SUCCEED() << "no virtual display support";
822 return;
823 }
824
825 const auto& [virtualDisplayStatus, virtualDisplay] = mComposerClient->createVirtualDisplay(
826 /*width*/ 64, /*height*/ 64, common::PixelFormat::IMPLEMENTATION_DEFINED,
827 kBufferSlotCount);
828
829 ASSERT_TRUE(virtualDisplayStatus.isOk());
830 EXPECT_TRUE(mComposerClient->destroyVirtualDisplay(virtualDisplay.display).isOk());
831 }
832
TEST_P(GraphicsComposerAidlTest,DestroyVirtualDisplay_BadDisplay)833 TEST_P(GraphicsComposerAidlTest, DestroyVirtualDisplay_BadDisplay) {
834 const auto& [status, maxDisplayCount] = mComposerClient->getMaxVirtualDisplayCount();
835 EXPECT_TRUE(status.isOk());
836
837 if (maxDisplayCount == 0) {
838 GTEST_SUCCEED() << "no virtual display support";
839 return;
840 }
841
842 const auto& destroyStatus = mComposerClient->destroyVirtualDisplay(getInvalidDisplayId());
843
844 EXPECT_FALSE(destroyStatus.isOk());
845 EXPECT_NO_FATAL_FAILURE(
846 assertServiceSpecificError(destroyStatus, IComposerClient::EX_BAD_DISPLAY));
847 }
848
TEST_P(GraphicsComposerAidlTest,CreateLayer)849 TEST_P(GraphicsComposerAidlTest, CreateLayer) {
850 if (hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
851 GTEST_SKIP() << "Create layer will be tested in GraphicsComposerAidlBatchedCommandTest";
852 return;
853 }
854
855 const auto& [status, layer] =
856 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, nullptr);
857
858 EXPECT_TRUE(status.isOk());
859 EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer, nullptr).isOk());
860 }
861
TEST_P(GraphicsComposerAidlTest,CreateLayer_BadDisplay)862 TEST_P(GraphicsComposerAidlTest, CreateLayer_BadDisplay) {
863 if (hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
864 GTEST_SKIP() << "Create layer will be tested in GraphicsComposerAidlBatchedCommandTest";
865 return;
866 }
867
868 const auto& [status, _] =
869 mComposerClient->createLayer(getInvalidDisplayId(), kBufferSlotCount, nullptr);
870
871 EXPECT_FALSE(status.isOk());
872 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
873 }
874
TEST_P(GraphicsComposerAidlTest,DestroyLayer_BadDisplay)875 TEST_P(GraphicsComposerAidlTest, DestroyLayer_BadDisplay) {
876 if (hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
877 GTEST_SKIP() << "Destroy layer will be tested in GraphicsComposerAidlBatchedCommandTest";
878 return;
879 }
880
881 const auto& [status, layer] =
882 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, nullptr);
883 EXPECT_TRUE(status.isOk());
884
885 const auto& destroyStatus =
886 mComposerClient->destroyLayer(getInvalidDisplayId(), layer, nullptr);
887
888 EXPECT_FALSE(destroyStatus.isOk());
889 EXPECT_NO_FATAL_FAILURE(
890 assertServiceSpecificError(destroyStatus, IComposerClient::EX_BAD_DISPLAY));
891 ASSERT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer, nullptr).isOk());
892 }
893
TEST_P(GraphicsComposerAidlTest,DestroyLayer_BadLayerError)894 TEST_P(GraphicsComposerAidlTest, DestroyLayer_BadLayerError) {
895 if (hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
896 GTEST_SKIP() << "Destroy layer will be tested in GraphicsComposerAidlBatchedCommandTest";
897 return;
898 }
899
900 // We haven't created any layers yet, so any id should be invalid
901 const auto& status = mComposerClient->destroyLayer(getPrimaryDisplayId(), /*layer*/ 1, nullptr);
902
903 EXPECT_FALSE(status.isOk());
904 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_LAYER));
905 }
906
TEST_P(GraphicsComposerAidlTest,GetActiveConfig_BadDisplay)907 TEST_P(GraphicsComposerAidlTest, GetActiveConfig_BadDisplay) {
908 const auto& [status, _] = mComposerClient->getActiveConfig(getInvalidDisplayId());
909
910 EXPECT_FALSE(status.isOk());
911 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
912 }
913
TEST_P(GraphicsComposerAidlTest,GetDisplayConfig)914 TEST_P(GraphicsComposerAidlTest, GetDisplayConfig) {
915 const auto& [status, _] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
916 EXPECT_TRUE(status.isOk());
917 }
918
TEST_P(GraphicsComposerAidlTest,GetDisplayConfig_BadDisplay)919 TEST_P(GraphicsComposerAidlTest, GetDisplayConfig_BadDisplay) {
920 const auto& [status, _] = mComposerClient->getDisplayConfigs(getInvalidDisplayId());
921
922 EXPECT_FALSE(status.isOk());
923 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
924 }
925
TEST_P(GraphicsComposerAidlTest,GetDisplayName)926 TEST_P(GraphicsComposerAidlTest, GetDisplayName) {
927 const auto& [status, _] = mComposerClient->getDisplayName(getPrimaryDisplayId());
928 EXPECT_TRUE(status.isOk());
929 }
930
TEST_P(GraphicsComposerAidlTest,GetDisplayPhysicalOrientation_BadDisplay)931 TEST_P(GraphicsComposerAidlTest, GetDisplayPhysicalOrientation_BadDisplay) {
932 const auto& [status, _] = mComposerClient->getDisplayPhysicalOrientation(getInvalidDisplayId());
933
934 EXPECT_FALSE(status.isOk());
935 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
936 }
937
TEST_P(GraphicsComposerAidlTest,GetDisplayPhysicalOrientation)938 TEST_P(GraphicsComposerAidlTest, GetDisplayPhysicalOrientation) {
939 const auto allowedDisplayOrientations = std::array<Transform, 4>{
940 Transform::NONE,
941 Transform::ROT_90,
942 Transform::ROT_180,
943 Transform::ROT_270,
944 };
945
946 const auto& [status, displayOrientation] =
947 mComposerClient->getDisplayPhysicalOrientation(getPrimaryDisplayId());
948
949 EXPECT_TRUE(status.isOk());
950 EXPECT_NE(std::find(allowedDisplayOrientations.begin(), allowedDisplayOrientations.end(),
951 displayOrientation),
952 allowedDisplayOrientations.end());
953 }
954
TEST_P(GraphicsComposerAidlTest,SetClientTargetSlotCount)955 TEST_P(GraphicsComposerAidlTest, SetClientTargetSlotCount) {
956 EXPECT_TRUE(mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kBufferSlotCount)
957 .isOk());
958 }
959
TEST_P(GraphicsComposerAidlTest,SetActiveConfig)960 TEST_P(GraphicsComposerAidlTest, SetActiveConfig) {
961 const auto& [status, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
962 EXPECT_TRUE(status.isOk());
963
964 for (const auto& config : configs) {
965 auto display = getEditablePrimaryDisplay();
966 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config).isOk());
967 const auto& [configStatus, config1] =
968 mComposerClient->getActiveConfig(getPrimaryDisplayId());
969 EXPECT_TRUE(configStatus.isOk());
970 EXPECT_EQ(config, config1);
971 }
972 }
973
TEST_P(GraphicsComposerAidlTest,SetActiveConfigPowerCycle)974 TEST_P(GraphicsComposerAidlTest, SetActiveConfigPowerCycle) {
975 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
976 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
977
978 const auto& [status, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
979 EXPECT_TRUE(status.isOk());
980
981 for (const auto& config : configs) {
982 auto display = getEditablePrimaryDisplay();
983 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config).isOk());
984 const auto& [config1Status, config1] =
985 mComposerClient->getActiveConfig(getPrimaryDisplayId());
986 EXPECT_TRUE(config1Status.isOk());
987 EXPECT_EQ(config, config1);
988
989 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
990 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
991 const auto& [config2Status, config2] =
992 mComposerClient->getActiveConfig(getPrimaryDisplayId());
993 EXPECT_TRUE(config2Status.isOk());
994 EXPECT_EQ(config, config2);
995 }
996 }
997
TEST_P(GraphicsComposerAidlTest,SetPowerModeUnsupported)998 TEST_P(GraphicsComposerAidlTest, SetPowerModeUnsupported) {
999 const auto& [status, capabilities] =
1000 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
1001 ASSERT_TRUE(status.isOk());
1002
1003 const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
1004 DisplayCapability::DOZE) != capabilities.end();
1005 const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
1006 DisplayCapability::SUSPEND) != capabilities.end();
1007
1008 if (!isDozeSupported) {
1009 const auto& powerModeDozeStatus =
1010 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE);
1011 EXPECT_FALSE(powerModeDozeStatus.isOk());
1012 EXPECT_NO_FATAL_FAILURE(
1013 assertServiceSpecificError(powerModeDozeStatus, IComposerClient::EX_UNSUPPORTED));
1014
1015 const auto& powerModeDozeSuspendStatus =
1016 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE_SUSPEND);
1017 EXPECT_FALSE(powerModeDozeSuspendStatus.isOk());
1018 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeDozeSuspendStatus,
1019 IComposerClient::EX_UNSUPPORTED));
1020 }
1021
1022 if (!isSuspendSupported) {
1023 const auto& powerModeSuspendStatus =
1024 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON_SUSPEND);
1025 EXPECT_FALSE(powerModeSuspendStatus.isOk());
1026 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeSuspendStatus,
1027 IComposerClient::EX_UNSUPPORTED));
1028
1029 const auto& powerModeDozeSuspendStatus =
1030 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE_SUSPEND);
1031 EXPECT_FALSE(powerModeDozeSuspendStatus.isOk());
1032 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeDozeSuspendStatus,
1033 IComposerClient::EX_UNSUPPORTED));
1034 }
1035 }
1036
TEST_P(GraphicsComposerAidlTest,SetVsyncEnabled)1037 TEST_P(GraphicsComposerAidlTest, SetVsyncEnabled) {
1038 mComposerClient->setVsyncAllowed(true);
1039
1040 EXPECT_TRUE(mComposerClient->setVsync(getPrimaryDisplayId(), true).isOk());
1041 usleep(60 * 1000);
1042 EXPECT_TRUE(mComposerClient->setVsync(getPrimaryDisplayId(), false).isOk());
1043
1044 mComposerClient->setVsyncAllowed(false);
1045 }
1046
TEST_P(GraphicsComposerAidlTest,SetPowerMode)1047 TEST_P(GraphicsComposerAidlTest, SetPowerMode) {
1048 const auto& [status, capabilities] =
1049 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
1050 ASSERT_TRUE(status.isOk());
1051
1052 const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
1053 DisplayCapability::DOZE) != capabilities.end();
1054 const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
1055 DisplayCapability::SUSPEND) != capabilities.end();
1056
1057 std::vector<PowerMode> modes;
1058 modes.push_back(PowerMode::OFF);
1059 modes.push_back(PowerMode::ON);
1060
1061 if (isSuspendSupported) {
1062 modes.push_back(PowerMode::ON_SUSPEND);
1063 }
1064
1065 if (isDozeSupported) {
1066 modes.push_back(PowerMode::DOZE);
1067 }
1068
1069 if (isSuspendSupported && isDozeSupported) {
1070 modes.push_back(PowerMode::DOZE_SUSPEND);
1071 }
1072
1073 for (auto mode : modes) {
1074 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
1075 }
1076 }
1077
TEST_P(GraphicsComposerAidlTest,SetPowerModeVariations)1078 TEST_P(GraphicsComposerAidlTest, SetPowerModeVariations) {
1079 const auto& [status, capabilities] =
1080 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
1081 ASSERT_TRUE(status.isOk());
1082
1083 const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
1084 DisplayCapability::DOZE) != capabilities.end();
1085 const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
1086 DisplayCapability::SUSPEND) != capabilities.end();
1087
1088 std::vector<PowerMode> modes;
1089
1090 modes.push_back(PowerMode::OFF);
1091 modes.push_back(PowerMode::ON);
1092 modes.push_back(PowerMode::OFF);
1093 for (auto mode : modes) {
1094 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
1095 }
1096 modes.clear();
1097
1098 modes.push_back(PowerMode::OFF);
1099 modes.push_back(PowerMode::OFF);
1100 for (auto mode : modes) {
1101 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
1102 }
1103 modes.clear();
1104
1105 modes.push_back(PowerMode::ON);
1106 modes.push_back(PowerMode::ON);
1107 for (auto mode : modes) {
1108 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
1109 }
1110 modes.clear();
1111
1112 if (isSuspendSupported) {
1113 modes.push_back(PowerMode::ON_SUSPEND);
1114 modes.push_back(PowerMode::ON_SUSPEND);
1115 for (auto mode : modes) {
1116 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
1117 }
1118 modes.clear();
1119 }
1120
1121 if (isDozeSupported) {
1122 modes.push_back(PowerMode::DOZE);
1123 modes.push_back(PowerMode::DOZE);
1124 for (auto mode : modes) {
1125 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
1126 }
1127 modes.clear();
1128 }
1129
1130 if (isSuspendSupported && isDozeSupported) {
1131 modes.push_back(PowerMode::DOZE_SUSPEND);
1132 modes.push_back(PowerMode::DOZE_SUSPEND);
1133 for (auto mode : modes) {
1134 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
1135 }
1136 modes.clear();
1137 }
1138 }
1139
TEST_P(GraphicsComposerAidlTest,SetPowerMode_BadDisplay)1140 TEST_P(GraphicsComposerAidlTest, SetPowerMode_BadDisplay) {
1141 const auto& status = mComposerClient->setPowerMode(getInvalidDisplayId(), PowerMode::ON);
1142
1143 EXPECT_FALSE(status.isOk());
1144 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
1145 }
1146
TEST_P(GraphicsComposerAidlTest,SetPowerMode_BadParameter)1147 TEST_P(GraphicsComposerAidlTest, SetPowerMode_BadParameter) {
1148 const auto& status =
1149 mComposerClient->setPowerMode(getPrimaryDisplayId(), static_cast<PowerMode>(-1));
1150
1151 EXPECT_FALSE(status.isOk());
1152 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
1153 }
1154
TEST_P(GraphicsComposerAidlTest,GetDataspaceSaturationMatrix)1155 TEST_P(GraphicsComposerAidlTest, GetDataspaceSaturationMatrix) {
1156 const auto& [status, matrix] =
1157 mComposerClient->getDataspaceSaturationMatrix(common::Dataspace::SRGB_LINEAR);
1158 ASSERT_TRUE(status.isOk());
1159 ASSERT_EQ(16, matrix.size()); // matrix should not be empty if call succeeded.
1160
1161 // the last row is known
1162 EXPECT_EQ(0.0f, matrix[12]);
1163 EXPECT_EQ(0.0f, matrix[13]);
1164 EXPECT_EQ(0.0f, matrix[14]);
1165 EXPECT_EQ(1.0f, matrix[15]);
1166 }
1167
TEST_P(GraphicsComposerAidlTest,GetDataspaceSaturationMatrix_BadParameter)1168 TEST_P(GraphicsComposerAidlTest, GetDataspaceSaturationMatrix_BadParameter) {
1169 const auto& [status, matrix] =
1170 mComposerClient->getDataspaceSaturationMatrix(common::Dataspace::UNKNOWN);
1171
1172 EXPECT_FALSE(status.isOk());
1173 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
1174 }
1175
1176 /*
1177 * Test that no two display configs are exactly the same.
1178 */
TEST_P(GraphicsComposerAidlTest,GetDisplayConfigNoRepetitions)1179 TEST_P(GraphicsComposerAidlTest, GetDisplayConfigNoRepetitions) {
1180 for (const auto& display : mDisplays) {
1181 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
1182 for (std::vector<int>::size_type i = 0; i < configs.size(); i++) {
1183 for (std::vector<int>::size_type j = i + 1; j < configs.size(); j++) {
1184 const auto& [widthStatus1, width1] = mComposerClient->getDisplayAttribute(
1185 display.getDisplayId(), configs[i], DisplayAttribute::WIDTH);
1186 const auto& [heightStatus1, height1] = mComposerClient->getDisplayAttribute(
1187 display.getDisplayId(), configs[i], DisplayAttribute::HEIGHT);
1188 const auto& [vsyncPeriodStatus1, vsyncPeriod1] =
1189 mComposerClient->getDisplayAttribute(display.getDisplayId(), configs[i],
1190 DisplayAttribute::VSYNC_PERIOD);
1191 const auto& [groupStatus1, group1] = mComposerClient->getDisplayAttribute(
1192 display.getDisplayId(), configs[i], DisplayAttribute::CONFIG_GROUP);
1193
1194 const auto& [widthStatus2, width2] = mComposerClient->getDisplayAttribute(
1195 display.getDisplayId(), configs[j], DisplayAttribute::WIDTH);
1196 const auto& [heightStatus2, height2] = mComposerClient->getDisplayAttribute(
1197 display.getDisplayId(), configs[j], DisplayAttribute::HEIGHT);
1198 const auto& [vsyncPeriodStatus2, vsyncPeriod2] =
1199 mComposerClient->getDisplayAttribute(display.getDisplayId(), configs[j],
1200 DisplayAttribute::VSYNC_PERIOD);
1201 const auto& [groupStatus2, group2] = mComposerClient->getDisplayAttribute(
1202 display.getDisplayId(), configs[j], DisplayAttribute::CONFIG_GROUP);
1203
1204 ASSERT_FALSE(width1 == width2 && height1 == height2 &&
1205 vsyncPeriod1 == vsyncPeriod2 && group1 == group2);
1206 }
1207 }
1208 }
1209 }
1210
TEST_P(GraphicsComposerAidlTest,LayerLifecycleCapabilityNotSupportedOnOldVersions)1211 TEST_P(GraphicsComposerAidlTest, LayerLifecycleCapabilityNotSupportedOnOldVersions) {
1212 if (hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
1213 EXPECT_GE(getInterfaceVersion(), 3);
1214 }
1215 }
1216
1217 class GraphicsComposerAidlV2Test : public GraphicsComposerAidlTest {
1218 protected:
SetUp()1219 void SetUp() override {
1220 GraphicsComposerAidlTest::SetUp();
1221 if (getInterfaceVersion() <= 1) {
1222 GTEST_SKIP() << "Device interface version is expected to be >= 2";
1223 }
1224 }
1225 };
1226
TEST_P(GraphicsComposerAidlV2Test,GetOverlaySupport)1227 TEST_P(GraphicsComposerAidlV2Test, GetOverlaySupport) {
1228 const auto& [status, properties] = mComposerClient->getOverlaySupport();
1229 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
1230 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
1231 GTEST_SUCCEED() << "getOverlaySupport is not supported";
1232 return;
1233 }
1234
1235 ASSERT_TRUE(status.isOk());
1236 for (const auto& i : properties.combinations) {
1237 for (const auto standard : i.standards) {
1238 const auto val = static_cast<int32_t>(standard) &
1239 static_cast<int32_t>(common::Dataspace::STANDARD_MASK);
1240 ASSERT_TRUE(val == static_cast<int32_t>(standard));
1241 }
1242 for (const auto transfer : i.transfers) {
1243 const auto val = static_cast<int32_t>(transfer) &
1244 static_cast<int32_t>(common::Dataspace::TRANSFER_MASK);
1245 ASSERT_TRUE(val == static_cast<int32_t>(transfer));
1246 }
1247 for (const auto range : i.ranges) {
1248 const auto val = static_cast<int32_t>(range) &
1249 static_cast<int32_t>(common::Dataspace::RANGE_MASK);
1250 ASSERT_TRUE(val == static_cast<int32_t>(range));
1251 }
1252 }
1253 }
1254
1255 class GraphicsComposerAidlV3Test : public GraphicsComposerAidlTest {
1256 protected:
SetUp()1257 void SetUp() override {
1258 GraphicsComposerAidlTest::SetUp();
1259 if (getInterfaceVersion() <= 2) {
1260 GTEST_SKIP() << "Device interface version is expected to be >= 3";
1261 }
1262 }
1263 };
1264
TEST_P(GraphicsComposerAidlV3Test,GetDisplayConfigurations)1265 TEST_P(GraphicsComposerAidlV3Test, GetDisplayConfigurations) {
1266 for (const auto& display : mDisplays) {
1267 const auto& [status, displayConfigurations] =
1268 mComposerClient->getDisplayConfigurations(display.getDisplayId());
1269 EXPECT_TRUE(status.isOk());
1270 EXPECT_FALSE(displayConfigurations.empty());
1271
1272 const bool areAllModesARR =
1273 std::all_of(displayConfigurations.cbegin(), displayConfigurations.cend(),
1274 [](const auto& config) { return config.vrrConfig.has_value(); });
1275
1276 const bool areAllModesMRR =
1277 std::all_of(displayConfigurations.cbegin(), displayConfigurations.cend(),
1278 [](const auto& config) { return !config.vrrConfig.has_value(); });
1279
1280 EXPECT_TRUE(areAllModesARR || areAllModesMRR) << "Mixing MRR and ARR modes is not allowed";
1281
1282 for (const auto& displayConfig : displayConfigurations) {
1283 EXPECT_NE(-1, displayConfig.width);
1284 EXPECT_NE(-1, displayConfig.height);
1285 EXPECT_NE(-1, displayConfig.vsyncPeriod);
1286 EXPECT_NE(-1, displayConfig.configGroup);
1287 if (displayConfig.dpi) {
1288 EXPECT_NE(-1.f, displayConfig.dpi->x);
1289 EXPECT_NE(-1.f, displayConfig.dpi->y);
1290 }
1291 if (displayConfig.vrrConfig) {
1292 const auto& vrrConfig = *displayConfig.vrrConfig;
1293 EXPECT_GE(vrrConfig.minFrameIntervalNs, displayConfig.vsyncPeriod);
1294
1295 EXPECT_EQ(1, std::count_if(
1296 displayConfigurations.cbegin(), displayConfigurations.cend(),
1297 [displayConfig](const auto& config) {
1298 return config.configGroup == displayConfig.configGroup;
1299 }))
1300 << "There should be only one VRR mode in one ConfigGroup";
1301
1302 const auto verifyFrameIntervalIsDivisorOfVsync = [&](int32_t frameIntervalNs) {
1303 constexpr auto kThreshold = 0.05f; // 5%
1304 const auto ratio =
1305 static_cast<float>(frameIntervalNs) / displayConfig.vsyncPeriod;
1306 return ratio - std::round(ratio) <= kThreshold;
1307 };
1308
1309 EXPECT_TRUE(verifyFrameIntervalIsDivisorOfVsync(vrrConfig.minFrameIntervalNs));
1310
1311 if (vrrConfig.frameIntervalPowerHints) {
1312 const auto& frameIntervalPowerHints = *vrrConfig.frameIntervalPowerHints;
1313 EXPECT_FALSE(frameIntervalPowerHints.empty());
1314
1315 const auto minFrameInterval = *min_element(frameIntervalPowerHints.cbegin(),
1316 frameIntervalPowerHints.cend());
1317 EXPECT_LE(minFrameInterval->frameIntervalNs,
1318 VtsComposerClient::kMaxFrameIntervalNs);
1319 const auto maxFrameInterval = *max_element(frameIntervalPowerHints.cbegin(),
1320 frameIntervalPowerHints.cend());
1321 EXPECT_GE(maxFrameInterval->frameIntervalNs, vrrConfig.minFrameIntervalNs);
1322
1323 EXPECT_TRUE(std::all_of(frameIntervalPowerHints.cbegin(),
1324 frameIntervalPowerHints.cend(),
1325 [&](const auto& frameIntervalPowerHint) {
1326 return verifyFrameIntervalIsDivisorOfVsync(
1327 frameIntervalPowerHint->frameIntervalNs);
1328 }));
1329 }
1330
1331 if (vrrConfig.notifyExpectedPresentConfig) {
1332 const auto& notifyExpectedPresentConfig =
1333 *vrrConfig.notifyExpectedPresentConfig;
1334 EXPECT_GE(notifyExpectedPresentConfig.headsUpNs, 0);
1335 EXPECT_GE(notifyExpectedPresentConfig.timeoutNs, 0);
1336 }
1337 }
1338 }
1339 }
1340 }
1341
TEST_P(GraphicsComposerAidlV3Test,GetDisplayConfigsIsSubsetOfGetDisplayConfigurations)1342 TEST_P(GraphicsComposerAidlV3Test, GetDisplayConfigsIsSubsetOfGetDisplayConfigurations) {
1343 for (const auto& display : mDisplays) {
1344 const auto& [status, displayConfigurations] =
1345 mComposerClient->getDisplayConfigurations(display.getDisplayId());
1346 EXPECT_TRUE(status.isOk());
1347
1348 const auto& [legacyConfigStatus, legacyConfigs] =
1349 mComposerClient->getDisplayConfigs(display.getDisplayId());
1350 EXPECT_TRUE(legacyConfigStatus.isOk());
1351 EXPECT_FALSE(legacyConfigs.empty());
1352 EXPECT_TRUE(legacyConfigs.size() <= displayConfigurations.size());
1353
1354 for (const auto legacyConfigId : legacyConfigs) {
1355 const auto& legacyWidth = mComposerClient->getDisplayAttribute(
1356 display.getDisplayId(), legacyConfigId, DisplayAttribute::WIDTH);
1357 const auto& legacyHeight = mComposerClient->getDisplayAttribute(
1358 display.getDisplayId(), legacyConfigId, DisplayAttribute::HEIGHT);
1359 const auto& legacyVsyncPeriod = mComposerClient->getDisplayAttribute(
1360 display.getDisplayId(), legacyConfigId, DisplayAttribute::VSYNC_PERIOD);
1361 const auto& legacyConfigGroup = mComposerClient->getDisplayAttribute(
1362 display.getDisplayId(), legacyConfigId, DisplayAttribute::CONFIG_GROUP);
1363 const auto& legacyDpiX = mComposerClient->getDisplayAttribute(
1364 display.getDisplayId(), legacyConfigId, DisplayAttribute::DPI_X);
1365 const auto& legacyDpiY = mComposerClient->getDisplayAttribute(
1366 display.getDisplayId(), legacyConfigId, DisplayAttribute::DPI_Y);
1367
1368 EXPECT_TRUE(legacyWidth.first.isOk() && legacyHeight.first.isOk() &&
1369 legacyVsyncPeriod.first.isOk() && legacyConfigGroup.first.isOk());
1370
1371 EXPECT_TRUE(std::any_of(
1372 displayConfigurations.begin(), displayConfigurations.end(),
1373 [&](const auto& displayConfiguration) {
1374 const bool requiredAttributesPredicate =
1375 displayConfiguration.configId == legacyConfigId &&
1376 displayConfiguration.width == legacyWidth.second &&
1377 displayConfiguration.height == legacyHeight.second &&
1378 displayConfiguration.vsyncPeriod == legacyVsyncPeriod.second &&
1379 displayConfiguration.configGroup == legacyConfigGroup.second;
1380
1381 if (!requiredAttributesPredicate) {
1382 // Required attributes did not match
1383 return false;
1384 }
1385
1386 // Check optional attributes
1387 const auto& [legacyDpiXStatus, legacyDpiXValue] = legacyDpiX;
1388 const auto& [legacyDpiYStatus, legacyDpiYValue] = legacyDpiY;
1389 if (displayConfiguration.dpi) {
1390 if (!legacyDpiXStatus.isOk() || !legacyDpiYStatus.isOk()) {
1391 // getDisplayAttribute failed for optional attributes
1392 return false;
1393 }
1394
1395 // DPI values in DisplayConfigurations are not scaled (* 1000.f)
1396 // the way they are in the legacy DisplayConfigs.
1397 constexpr float kEpsilon = 0.001f;
1398 return std::abs(displayConfiguration.dpi->x -
1399 legacyDpiXValue / 1000.f) < kEpsilon &&
1400 std::abs(displayConfiguration.dpi->y -
1401 legacyDpiYValue / 1000.f) < kEpsilon;
1402 } else {
1403 return !legacyDpiXStatus.isOk() && !legacyDpiYStatus.isOk() &&
1404 EX_SERVICE_SPECIFIC == legacyDpiXStatus.getExceptionCode() &&
1405 EX_SERVICE_SPECIFIC == legacyDpiYStatus.getExceptionCode() &&
1406 IComposerClient::EX_UNSUPPORTED ==
1407 legacyDpiXStatus.getServiceSpecificError() &&
1408 IComposerClient::EX_UNSUPPORTED ==
1409 legacyDpiYStatus.getServiceSpecificError();
1410 }
1411 }));
1412 }
1413 }
1414 }
1415
1416 // Tests for Command.
1417 class GraphicsComposerAidlCommandTest : public GraphicsComposerAidlTest {
1418 protected:
TearDown()1419 void TearDown() override {
1420 ASSERT_FALSE(mDisplays.empty());
1421 ASSERT_TRUE(mReader.takeErrors().empty());
1422 ASSERT_TRUE(mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty());
1423
1424 ASSERT_TRUE(mComposerClient->tearDown(&getWriter(getPrimaryDisplayId())));
1425 ASSERT_NO_FATAL_FAILURE(GraphicsComposerAidlTest::TearDown());
1426 }
1427
execute()1428 void execute() {
1429 std::vector<CommandResultPayload> payloads;
1430 for (auto& [_, writer] : mWriters) {
1431 executeInternal(writer, payloads);
1432 }
1433 mReader.parse(std::move(payloads));
1434 }
1435
execute(ComposerClientWriter & writer,ComposerClientReader & reader)1436 void execute(ComposerClientWriter& writer, ComposerClientReader& reader) {
1437 std::vector<CommandResultPayload> payloads;
1438 executeInternal(writer, payloads);
1439 reader.parse(std::move(payloads));
1440 }
1441
toTimePoint(nsecs_t time)1442 static inline auto toTimePoint(nsecs_t time) {
1443 return std::chrono::time_point<std::chrono::steady_clock>(std::chrono::nanoseconds(time));
1444 }
1445
forEachTwoConfigs(int64_t display,std::function<void (int32_t,int32_t)> func)1446 void forEachTwoConfigs(int64_t display, std::function<void(int32_t, int32_t)> func) {
1447 const auto& [status, displayConfigs] = mComposerClient->getDisplayConfigs(display);
1448 ASSERT_TRUE(status.isOk());
1449 for (const int32_t config1 : displayConfigs) {
1450 for (const int32_t config2 : displayConfigs) {
1451 if (config1 != config2) {
1452 func(config1, config2);
1453 }
1454 }
1455 }
1456 }
1457
waitForVsyncPeriodChange(int64_t display,const VsyncPeriodChangeTimeline & timeline,int64_t desiredTimeNanos,int64_t oldPeriodNanos,int64_t newPeriodNanos)1458 void waitForVsyncPeriodChange(int64_t display, const VsyncPeriodChangeTimeline& timeline,
1459 int64_t desiredTimeNanos, int64_t oldPeriodNanos,
1460 int64_t newPeriodNanos) {
1461 const auto kChangeDeadline = toTimePoint(timeline.newVsyncAppliedTimeNanos) + 100ms;
1462 while (std::chrono::steady_clock::now() <= kChangeDeadline) {
1463 const auto& [status, vsyncPeriodNanos] =
1464 mComposerClient->getDisplayVsyncPeriod(display);
1465 EXPECT_TRUE(status.isOk());
1466 if (systemTime() <= desiredTimeNanos) {
1467 EXPECT_EQ(vsyncPeriodNanos, oldPeriodNanos);
1468 } else if (vsyncPeriodNanos == newPeriodNanos) {
1469 break;
1470 }
1471 std::this_thread::sleep_for(std::chrono::nanoseconds(oldPeriodNanos));
1472 }
1473 }
1474
checkIfCallbackRefreshRateChangedDebugEnabledReceived(std::function<bool (RefreshRateChangedDebugData)> filter)1475 bool checkIfCallbackRefreshRateChangedDebugEnabledReceived(
1476 std::function<bool(RefreshRateChangedDebugData)> filter) {
1477 const auto list = mComposerClient->takeListOfRefreshRateChangedDebugData();
1478 return std::any_of(list.begin(), list.end(), [&](auto refreshRateChangedDebugData) {
1479 return filter(refreshRateChangedDebugData);
1480 });
1481 }
1482
allocate(uint32_t width,uint32_t height,::android::PixelFormat pixelFormat)1483 sp<GraphicBuffer> allocate(uint32_t width, uint32_t height,
1484 ::android::PixelFormat pixelFormat) {
1485 return sp<GraphicBuffer>::make(
1486 width, height, pixelFormat, /*layerCount*/ 1U,
1487 static_cast<uint64_t>(common::BufferUsage::CPU_WRITE_OFTEN) |
1488 static_cast<uint64_t>(common::BufferUsage::CPU_READ_OFTEN) |
1489 static_cast<uint64_t>(common::BufferUsage::COMPOSER_OVERLAY),
1490 "VtsHalGraphicsComposer3_TargetTest");
1491 }
1492
allocate(::android::PixelFormat pixelFormat)1493 sp<GraphicBuffer> allocate(::android::PixelFormat pixelFormat) {
1494 return allocate(static_cast<uint32_t>(getPrimaryDisplay().getDisplayWidth()),
1495 static_cast<uint32_t>(getPrimaryDisplay().getDisplayHeight()), pixelFormat);
1496 }
1497
sendRefreshFrame(const VtsDisplay & display,const VsyncPeriodChangeTimeline * timeline)1498 void sendRefreshFrame(const VtsDisplay& display, const VsyncPeriodChangeTimeline* timeline) {
1499 if (timeline != nullptr) {
1500 // Refresh time should be before newVsyncAppliedTimeNanos
1501 EXPECT_LT(timeline->refreshTimeNanos, timeline->newVsyncAppliedTimeNanos);
1502
1503 std::this_thread::sleep_until(toTimePoint(timeline->refreshTimeNanos));
1504 }
1505
1506 EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::ON).isOk());
1507 EXPECT_TRUE(mComposerClient
1508 ->setColorMode(display.getDisplayId(), ColorMode::NATIVE,
1509 RenderIntent::COLORIMETRIC)
1510 .isOk());
1511
1512 auto& writer = getWriter(display.getDisplayId());
1513 const auto& [status, layer] =
1514 mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
1515 EXPECT_TRUE(status.isOk());
1516 {
1517 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1518 ASSERT_NE(nullptr, buffer);
1519 ASSERT_EQ(::android::OK, buffer->initCheck());
1520 ASSERT_NE(nullptr, buffer->handle);
1521
1522 configureLayer(display, layer, Composition::DEVICE, display.getFrameRect(),
1523 display.getCrop());
1524 writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, buffer->handle,
1525 /*acquireFence*/ -1);
1526 writer.setLayerDataspace(display.getDisplayId(), layer, common::Dataspace::UNKNOWN);
1527
1528 writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp,
1529 VtsComposerClient::kNoFrameIntervalNs);
1530 execute();
1531 ASSERT_TRUE(mReader.takeErrors().empty());
1532
1533 writer.presentDisplay(display.getDisplayId());
1534 execute();
1535 ASSERT_TRUE(mReader.takeErrors().empty());
1536 }
1537
1538 {
1539 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1540 ASSERT_NE(nullptr, buffer->handle);
1541
1542 writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, buffer->handle,
1543 /*acquireFence*/ -1);
1544 writer.setLayerSurfaceDamage(display.getDisplayId(), layer,
1545 std::vector<Rect>(1, {0, 0, 10, 10}));
1546 writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp,
1547 VtsComposerClient::kNoFrameIntervalNs);
1548 execute();
1549 ASSERT_TRUE(mReader.takeErrors().empty());
1550
1551 writer.presentDisplay(display.getDisplayId());
1552 execute();
1553 }
1554
1555 EXPECT_TRUE(mComposerClient->destroyLayer(display.getDisplayId(), layer, &writer).isOk());
1556 }
1557
presentAndGetFence(std::optional<ClockMonotonicTimestamp> expectedPresentTime,std::optional<int64_t> displayIdOpt={},int32_t frameIntervalNs=VtsComposerClient::kNoFrameIntervalNs)1558 sp<::android::Fence> presentAndGetFence(
1559 std::optional<ClockMonotonicTimestamp> expectedPresentTime,
1560 std::optional<int64_t> displayIdOpt = {},
1561 int32_t frameIntervalNs = VtsComposerClient::kNoFrameIntervalNs) {
1562 const auto displayId = displayIdOpt.value_or(getPrimaryDisplayId());
1563 auto& writer = getWriter(displayId);
1564 writer.validateDisplay(displayId, expectedPresentTime, frameIntervalNs);
1565 execute();
1566 EXPECT_TRUE(mReader.takeErrors().empty());
1567
1568 writer.presentDisplay(displayId);
1569 execute();
1570 EXPECT_TRUE(mReader.takeErrors().empty());
1571
1572 auto presentFence = mReader.takePresentFence(displayId);
1573 // take ownership
1574 const int fenceOwner = presentFence.get();
1575 *presentFence.getR() = -1;
1576 EXPECT_NE(-1, fenceOwner);
1577 return sp<::android::Fence>::make(fenceOwner);
1578 }
1579
getVsyncPeriod()1580 int32_t getVsyncPeriod() {
1581 const auto& [status, activeConfig] =
1582 mComposerClient->getActiveConfig(getPrimaryDisplayId());
1583 EXPECT_TRUE(status.isOk());
1584
1585 const auto& [vsyncPeriodStatus, vsyncPeriod] = mComposerClient->getDisplayAttribute(
1586 getPrimaryDisplayId(), activeConfig, DisplayAttribute::VSYNC_PERIOD);
1587 EXPECT_TRUE(vsyncPeriodStatus.isOk());
1588 return vsyncPeriod;
1589 }
1590
createOnScreenLayer(const VtsDisplay & display,Composition composition=Composition::DEVICE)1591 int64_t createOnScreenLayer(const VtsDisplay& display,
1592 Composition composition = Composition::DEVICE) {
1593 auto& writer = getWriter(display.getDisplayId());
1594 const auto& [status, layer] =
1595 mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
1596 EXPECT_TRUE(status.isOk());
1597 Rect displayFrame{0, 0, display.getDisplayWidth(), display.getDisplayHeight()};
1598 FRect cropRect{0, 0, (float)display.getDisplayWidth(), (float)display.getDisplayHeight()};
1599 configureLayer(display, layer, composition, displayFrame, cropRect);
1600
1601 writer.setLayerDataspace(display.getDisplayId(), layer, common::Dataspace::UNKNOWN);
1602 return layer;
1603 }
1604
sendBufferUpdate(int64_t layer)1605 void sendBufferUpdate(int64_t layer) {
1606 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1607 ASSERT_NE(nullptr, buffer->handle);
1608
1609 auto& writer = getWriter(getPrimaryDisplayId());
1610 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer->handle,
1611 /*acquireFence*/ -1);
1612
1613 const sp<::android::Fence> presentFence =
1614 presentAndGetFence(ComposerClientWriter::kNoTimestamp);
1615 presentFence->waitForever(LOG_TAG);
1616 }
1617
hasDisplayCapability(int64_t display,DisplayCapability cap)1618 bool hasDisplayCapability(int64_t display, DisplayCapability cap) {
1619 const auto& [status, capabilities] = mComposerClient->getDisplayCapabilities(display);
1620 EXPECT_TRUE(status.isOk());
1621
1622 return std::find(capabilities.begin(), capabilities.end(), cap) != capabilities.end();
1623 }
1624
Test_setActiveConfigWithConstraints(const TestParameters & params)1625 void Test_setActiveConfigWithConstraints(const TestParameters& params) {
1626 for (VtsDisplay& display : mDisplays) {
1627 forEachTwoConfigs(display.getDisplayId(), [&](int32_t config1, int32_t config2) {
1628 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
1629 sendRefreshFrame(display, nullptr);
1630
1631 const auto displayConfig1 = display.getDisplayConfig(config1);
1632 int32_t vsyncPeriod1 = displayConfig1.vsyncPeriod;
1633 int32_t configGroup1 = displayConfig1.configGroup;
1634
1635 const auto displayConfig2 = display.getDisplayConfig(config2);
1636 int32_t vsyncPeriod2 = displayConfig2.vsyncPeriod;
1637 int32_t configGroup2 = displayConfig2.configGroup;
1638
1639 if (vsyncPeriod1 == vsyncPeriod2) {
1640 return; // continue
1641 }
1642
1643 if ((!displayConfig1.vrrConfigOpt && displayConfig2.vrrConfigOpt) ||
1644 (displayConfig1.vrrConfigOpt && !displayConfig2.vrrConfigOpt)) {
1645 // switching between vrr to non-vrr modes
1646 return; // continue
1647 }
1648
1649 // We don't allow delayed change when changing config groups
1650 if (params.delayForChange > 0 && configGroup1 != configGroup2) {
1651 return; // continue
1652 }
1653
1654 VsyncPeriodChangeConstraints constraints = {
1655 .desiredTimeNanos = systemTime() + params.delayForChange,
1656 .seamlessRequired = false};
1657 const auto& [status, timeline] = mComposerClient->setActiveConfigWithConstraints(
1658 &display, config2, constraints);
1659 EXPECT_TRUE(status.isOk());
1660
1661 EXPECT_TRUE(timeline.newVsyncAppliedTimeNanos >= constraints.desiredTimeNanos);
1662 // Refresh rate should change within a reasonable time
1663 constexpr std::chrono::nanoseconds kReasonableTimeForChange = 1s; // 1 second
1664 EXPECT_TRUE(timeline.newVsyncAppliedTimeNanos - constraints.desiredTimeNanos <=
1665 kReasonableTimeForChange.count());
1666
1667 if (timeline.refreshRequired) {
1668 if (params.refreshMiss) {
1669 // Miss the refresh frame on purpose to make sure the implementation sends a
1670 // callback
1671 std::this_thread::sleep_until(toTimePoint(timeline.refreshTimeNanos) +
1672 100ms);
1673 }
1674 sendRefreshFrame(display, &timeline);
1675 }
1676 waitForVsyncPeriodChange(display.getDisplayId(), timeline,
1677 constraints.desiredTimeNanos, vsyncPeriod1, vsyncPeriod2);
1678
1679 // At this point the refresh rate should have changed already, however in rare
1680 // cases the implementation might have missed the deadline. In this case a new
1681 // timeline should have been provided.
1682 auto newTimeline = mComposerClient->takeLastVsyncPeriodChangeTimeline();
1683 if (timeline.refreshRequired && params.refreshMiss) {
1684 EXPECT_TRUE(newTimeline.has_value());
1685 }
1686
1687 if (newTimeline.has_value()) {
1688 if (newTimeline->refreshRequired) {
1689 sendRefreshFrame(display, &newTimeline.value());
1690 }
1691 waitForVsyncPeriodChange(display.getDisplayId(), newTimeline.value(),
1692 constraints.desiredTimeNanos, vsyncPeriod1,
1693 vsyncPeriod2);
1694 }
1695
1696 const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanos] =
1697 mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
1698 EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
1699 EXPECT_EQ(vsyncPeriodNanos, vsyncPeriod2);
1700 });
1701 }
1702 }
1703
Test_expectedPresentTime(std::optional<int> framesDelay)1704 void Test_expectedPresentTime(std::optional<int> framesDelay) {
1705 if (hasCapability(Capability::PRESENT_FENCE_IS_NOT_RELIABLE)) {
1706 GTEST_SUCCEED() << "Device has unreliable present fences capability, skipping";
1707 return;
1708 }
1709
1710 ASSERT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
1711
1712 const auto vsyncPeriod = getVsyncPeriod();
1713
1714 const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1715 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1716 ASSERT_NE(nullptr, buffer1);
1717 ASSERT_NE(nullptr, buffer2);
1718
1719 const auto layer = createOnScreenLayer(getPrimaryDisplay());
1720 auto& writer = getWriter(getPrimaryDisplayId());
1721 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer1->handle,
1722 /*acquireFence*/ -1);
1723 const sp<::android::Fence> presentFence1 =
1724 presentAndGetFence(ComposerClientWriter::kNoTimestamp);
1725 presentFence1->waitForever(LOG_TAG);
1726
1727 auto expectedPresentTime = presentFence1->getSignalTime() + vsyncPeriod;
1728 if (framesDelay.has_value()) {
1729 expectedPresentTime += *framesDelay * vsyncPeriod;
1730 }
1731
1732 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer2->handle,
1733 /*acquireFence*/ -1);
1734 const auto setExpectedPresentTime = [&]() -> std::optional<ClockMonotonicTimestamp> {
1735 if (!framesDelay.has_value()) {
1736 return ComposerClientWriter::kNoTimestamp;
1737 } else if (*framesDelay == 0) {
1738 return ClockMonotonicTimestamp{0};
1739 }
1740 return ClockMonotonicTimestamp{expectedPresentTime};
1741 }();
1742
1743 const sp<::android::Fence> presentFence2 = presentAndGetFence(setExpectedPresentTime);
1744 presentFence2->waitForever(LOG_TAG);
1745
1746 const auto actualPresentTime = presentFence2->getSignalTime();
1747 EXPECT_GE(actualPresentTime, expectedPresentTime - vsyncPeriod / 2);
1748
1749 ASSERT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
1750 }
1751
forEachNotifyExpectedPresentConfig(std::function<void (VtsDisplay &,const DisplayConfiguration &)> func)1752 void forEachNotifyExpectedPresentConfig(
1753 std::function<void(VtsDisplay&, const DisplayConfiguration&)> func) {
1754 for (VtsDisplay& display : mDisplays) {
1755 const auto displayId = display.getDisplayId();
1756 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
1757 const auto& [status, displayConfigurations] =
1758 mComposerClient->getDisplayConfigurations(displayId);
1759 EXPECT_TRUE(status.isOk());
1760 EXPECT_FALSE(displayConfigurations.empty());
1761 for (const auto& config : displayConfigurations) {
1762 if (config.vrrConfig && config.vrrConfig->notifyExpectedPresentConfig) {
1763 const auto [vsyncPeriodStatus, oldVsyncPeriod] =
1764 mComposerClient->getDisplayVsyncPeriod(displayId);
1765 ASSERT_TRUE(vsyncPeriodStatus.isOk());
1766 const auto& [timelineStatus, timeline] =
1767 mComposerClient->setActiveConfigWithConstraints(
1768 &display, config.configId,
1769 VsyncPeriodChangeConstraints{.seamlessRequired = false});
1770 ASSERT_TRUE(timelineStatus.isOk());
1771 if (timeline.refreshRequired) {
1772 sendRefreshFrame(display, &timeline);
1773 }
1774 waitForVsyncPeriodChange(displayId, timeline, systemTime(), oldVsyncPeriod,
1775 config.vsyncPeriod);
1776 func(display, config);
1777 }
1778 }
1779 EXPECT_TRUE(
1780 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
1781 }
1782 }
1783
configureLayer(const VtsDisplay & display,int64_t layer,Composition composition,const Rect & displayFrame,const FRect & cropRect)1784 void configureLayer(const VtsDisplay& display, int64_t layer, Composition composition,
1785 const Rect& displayFrame, const FRect& cropRect) {
1786 auto& writer = getWriter(display.getDisplayId());
1787 writer.setLayerCompositionType(display.getDisplayId(), layer, composition);
1788 writer.setLayerDisplayFrame(display.getDisplayId(), layer, displayFrame);
1789 writer.setLayerPlaneAlpha(display.getDisplayId(), layer, /*alpha*/ 1);
1790 writer.setLayerSourceCrop(display.getDisplayId(), layer, cropRect);
1791 writer.setLayerTransform(display.getDisplayId(), layer, static_cast<Transform>(0));
1792 writer.setLayerVisibleRegion(display.getDisplayId(), layer,
1793 std::vector<Rect>(1, displayFrame));
1794 writer.setLayerZOrder(display.getDisplayId(), layer, /*z*/ 10);
1795 writer.setLayerBlendMode(display.getDisplayId(), layer, BlendMode::NONE);
1796 writer.setLayerSurfaceDamage(display.getDisplayId(), layer,
1797 std::vector<Rect>(1, displayFrame));
1798 }
1799 // clang-format off
1800 const std::array<float, 16> kIdentity = {{
1801 1.0f, 0.0f, 0.0f, 0.0f,
1802 0.0f, 1.0f, 0.0f, 0.0f,
1803 0.0f, 0.0f, 1.0f, 0.0f,
1804 0.0f, 0.0f, 0.0f, 1.0f,
1805 }};
1806 // clang-format on
1807
getWriter(int64_t display)1808 ComposerClientWriter& getWriter(int64_t display) {
1809 std::lock_guard guard{mWritersMutex};
1810 auto [it, _] = mWriters.try_emplace(display, display);
1811 return it->second;
1812 }
1813
1814 ComposerClientReader mReader;
1815
1816 private:
executeInternal(ComposerClientWriter & writer,std::vector<CommandResultPayload> & payloads)1817 void executeInternal(ComposerClientWriter& writer,
1818 std::vector<CommandResultPayload>& payloads) {
1819 auto commands = writer.takePendingCommands();
1820 if (commands.empty()) {
1821 return;
1822 }
1823
1824 auto [status, results] = mComposerClient->executeCommands(commands);
1825 ASSERT_TRUE(status.isOk()) << "executeCommands failed " << status.getDescription();
1826
1827 payloads.reserve(payloads.size() + results.size());
1828 payloads.insert(payloads.end(), std::make_move_iterator(results.begin()),
1829 std::make_move_iterator(results.end()));
1830 }
1831
1832 // Guards access to the map itself. Callers must ensure not to attempt to
1833 // - modify the same writer from multiple threads
1834 // - insert a new writer into the map during concurrent access, which would invalidate
1835 // references from other threads
1836 std::mutex mWritersMutex;
1837 std::unordered_map<int64_t, ComposerClientWriter> mWriters GUARDED_BY(mWritersMutex);
1838 };
1839
TEST_P(GraphicsComposerAidlCommandTest,SetColorTransform)1840 TEST_P(GraphicsComposerAidlCommandTest, SetColorTransform) {
1841 auto& writer = getWriter(getPrimaryDisplayId());
1842 writer.setColorTransform(getPrimaryDisplayId(), kIdentity.data());
1843 execute();
1844 }
1845
TEST_P(GraphicsComposerAidlCommandTest,SetLayerColorTransform)1846 TEST_P(GraphicsComposerAidlCommandTest, SetLayerColorTransform) {
1847 auto& writer = getWriter(getPrimaryDisplayId());
1848 const auto& [status, layer] =
1849 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
1850 EXPECT_TRUE(status.isOk());
1851 writer.setLayerColorTransform(getPrimaryDisplayId(), layer, kIdentity.data());
1852 execute();
1853
1854 const auto errors = mReader.takeErrors();
1855 if (errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_UNSUPPORTED) {
1856 GTEST_SUCCEED() << "setLayerColorTransform is not supported";
1857 return;
1858 }
1859 }
1860
TEST_P(GraphicsComposerAidlCommandTest,SetDisplayBrightness)1861 TEST_P(GraphicsComposerAidlCommandTest, SetDisplayBrightness) {
1862 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
1863 const auto& [status, capabilities] =
1864 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
1865 ASSERT_TRUE(status.isOk());
1866 bool brightnessSupport = std::find(capabilities.begin(), capabilities.end(),
1867 DisplayCapability::BRIGHTNESS) != capabilities.end();
1868 auto& writer = getWriter(getPrimaryDisplayId());
1869 if (!brightnessSupport) {
1870 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.5f, -1.f);
1871 execute();
1872 const auto errors = mReader.takeErrors();
1873 ASSERT_EQ(1, errors.size());
1874 EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, errors[0].errorCode);
1875 GTEST_SUCCEED() << "SetDisplayBrightness is not supported";
1876 return;
1877 }
1878
1879 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.0f, -1.f);
1880 execute();
1881 EXPECT_TRUE(mReader.takeErrors().empty());
1882
1883 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.5f, -1.f);
1884 execute();
1885 EXPECT_TRUE(mReader.takeErrors().empty());
1886
1887 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 1.0f, -1.f);
1888 execute();
1889 EXPECT_TRUE(mReader.takeErrors().empty());
1890
1891 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ -1.0f, -1.f);
1892 execute();
1893 EXPECT_TRUE(mReader.takeErrors().empty());
1894
1895 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 2.0f, -1.f);
1896 execute();
1897 {
1898 const auto errors = mReader.takeErrors();
1899 ASSERT_EQ(1, errors.size());
1900 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
1901 }
1902
1903 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ -2.0f, -1.f);
1904 execute();
1905 {
1906 const auto errors = mReader.takeErrors();
1907 ASSERT_EQ(1, errors.size());
1908 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
1909 }
1910 }
1911
TEST_P(GraphicsComposerAidlCommandTest,SetClientTarget)1912 TEST_P(GraphicsComposerAidlCommandTest, SetClientTarget) {
1913 EXPECT_TRUE(mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kBufferSlotCount)
1914 .isOk());
1915
1916 auto& writer = getWriter(getPrimaryDisplayId());
1917 writer.setClientTarget(getPrimaryDisplayId(), /*slot*/ 0, nullptr, /*acquireFence*/ -1,
1918 Dataspace::UNKNOWN, std::vector<Rect>(), 1.0f);
1919
1920 execute();
1921 }
1922
TEST_P(GraphicsComposerAidlCommandTest,SetOutputBuffer)1923 TEST_P(GraphicsComposerAidlCommandTest, SetOutputBuffer) {
1924 const auto& [status, virtualDisplayCount] = mComposerClient->getMaxVirtualDisplayCount();
1925 EXPECT_TRUE(status.isOk());
1926 if (virtualDisplayCount == 0) {
1927 GTEST_SUCCEED() << "no virtual display support";
1928 return;
1929 }
1930
1931 const auto& [displayStatus, display] = mComposerClient->createVirtualDisplay(
1932 /*width*/ 64, /*height*/ 64, common::PixelFormat::IMPLEMENTATION_DEFINED,
1933 kBufferSlotCount);
1934 EXPECT_TRUE(displayStatus.isOk());
1935
1936 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1937 const auto handle = buffer->handle;
1938 auto& writer = getWriter(display.display);
1939 writer.setOutputBuffer(display.display, /*slot*/ 0, handle, /*releaseFence*/ -1);
1940 execute();
1941 }
1942
TEST_P(GraphicsComposerAidlCommandTest,ValidDisplay)1943 TEST_P(GraphicsComposerAidlCommandTest, ValidDisplay) {
1944 auto& writer = getWriter(getPrimaryDisplayId());
1945 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
1946 VtsComposerClient::kNoFrameIntervalNs);
1947 execute();
1948 }
1949
TEST_P(GraphicsComposerAidlCommandTest,AcceptDisplayChanges)1950 TEST_P(GraphicsComposerAidlCommandTest, AcceptDisplayChanges) {
1951 auto& writer = getWriter(getPrimaryDisplayId());
1952 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
1953 VtsComposerClient::kNoFrameIntervalNs);
1954 writer.acceptDisplayChanges(getPrimaryDisplayId());
1955 execute();
1956 }
1957
TEST_P(GraphicsComposerAidlCommandTest,PresentDisplay)1958 TEST_P(GraphicsComposerAidlCommandTest, PresentDisplay) {
1959 auto& writer = getWriter(getPrimaryDisplayId());
1960 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
1961 VtsComposerClient::kNoFrameIntervalNs);
1962 writer.presentDisplay(getPrimaryDisplayId());
1963 execute();
1964 }
1965
1966 /**
1967 * Test IComposerClient::Command::PRESENT_DISPLAY
1968 *
1969 * Test that IComposerClient::Command::PRESENT_DISPLAY works without
1970 * additional call to validateDisplay when only the layer buffer handle and
1971 * surface damage have been set
1972 */
TEST_P(GraphicsComposerAidlCommandTest,PresentDisplayNoLayerStateChanges)1973 TEST_P(GraphicsComposerAidlCommandTest, PresentDisplayNoLayerStateChanges) {
1974 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
1975
1976 const auto& [renderIntentsStatus, renderIntents] =
1977 mComposerClient->getRenderIntents(getPrimaryDisplayId(), ColorMode::NATIVE);
1978 EXPECT_TRUE(renderIntentsStatus.isOk());
1979 auto& writer = getWriter(getPrimaryDisplayId());
1980 for (auto intent : renderIntents) {
1981 EXPECT_TRUE(mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE, intent)
1982 .isOk());
1983
1984 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1985 const auto handle = buffer->handle;
1986 ASSERT_NE(nullptr, handle);
1987
1988 const auto& [layerStatus, layer] =
1989 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
1990 EXPECT_TRUE(layerStatus.isOk());
1991
1992 Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
1993 getPrimaryDisplay().getDisplayHeight()};
1994 FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
1995 (float)getPrimaryDisplay().getDisplayHeight()};
1996 configureLayer(getPrimaryDisplay(), layer, Composition::CURSOR, displayFrame, cropRect);
1997 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle,
1998 /*acquireFence*/ -1);
1999 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
2000 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
2001 VtsComposerClient::kNoFrameIntervalNs);
2002 execute();
2003 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
2004 GTEST_SUCCEED() << "Composition change requested, skipping test";
2005 return;
2006 }
2007
2008 ASSERT_TRUE(mReader.takeErrors().empty());
2009 writer.presentDisplay(getPrimaryDisplayId());
2010 execute();
2011 ASSERT_TRUE(mReader.takeErrors().empty());
2012
2013 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2014 const auto handle2 = buffer2->handle;
2015 ASSERT_NE(nullptr, handle2);
2016 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle2,
2017 /*acquireFence*/ -1);
2018 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer,
2019 std::vector<Rect>(1, {0, 0, 10, 10}));
2020 writer.presentDisplay(getPrimaryDisplayId());
2021 execute();
2022 }
2023 }
2024
TEST_P(GraphicsComposerAidlCommandTest,SetLayerCursorPosition)2025 TEST_P(GraphicsComposerAidlCommandTest, SetLayerCursorPosition) {
2026 auto& writer = getWriter(getPrimaryDisplayId());
2027 const auto& [layerStatus, layer] =
2028 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
2029 EXPECT_TRUE(layerStatus.isOk());
2030
2031 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2032 const auto handle = buffer->handle;
2033 ASSERT_NE(nullptr, handle);
2034
2035 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle, /*acquireFence*/ -1);
2036
2037 Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
2038 getPrimaryDisplay().getDisplayHeight()};
2039 FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
2040 (float)getPrimaryDisplay().getDisplayHeight()};
2041 configureLayer(getPrimaryDisplay(), layer, Composition::CURSOR, displayFrame, cropRect);
2042 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
2043 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
2044 VtsComposerClient::kNoFrameIntervalNs);
2045
2046 execute();
2047
2048 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
2049 GTEST_SUCCEED() << "Composition change requested, skipping test";
2050 return;
2051 }
2052 writer.presentDisplay(getPrimaryDisplayId());
2053 ASSERT_TRUE(mReader.takeErrors().empty());
2054
2055 writer.setLayerCursorPosition(getPrimaryDisplayId(), layer, /*x*/ 1, /*y*/ 1);
2056 execute();
2057
2058 writer.setLayerCursorPosition(getPrimaryDisplayId(), layer, /*x*/ 0, /*y*/ 0);
2059 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
2060 VtsComposerClient::kNoFrameIntervalNs);
2061 writer.presentDisplay(getPrimaryDisplayId());
2062 execute();
2063 }
2064
TEST_P(GraphicsComposerAidlCommandTest,SetLayerBuffer)2065 TEST_P(GraphicsComposerAidlCommandTest, SetLayerBuffer) {
2066 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2067 const auto handle = buffer->handle;
2068 ASSERT_NE(nullptr, handle);
2069
2070 auto& writer = getWriter(getPrimaryDisplayId());
2071 const auto& [layerStatus, layer] =
2072 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
2073 EXPECT_TRUE(layerStatus.isOk());
2074 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle, /*acquireFence*/ -1);
2075 execute();
2076 ASSERT_TRUE(mReader.takeErrors().empty());
2077 }
2078
TEST_P(GraphicsComposerAidlCommandTest,SetLayerBufferMultipleTimes)2079 TEST_P(GraphicsComposerAidlCommandTest, SetLayerBufferMultipleTimes) {
2080 auto& writer = getWriter(getPrimaryDisplayId());
2081 const auto& [layerStatus, layer] =
2082 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
2083 EXPECT_TRUE(layerStatus.isOk());
2084
2085 // Setup 3 buffers in the buffer cache, with the last buffer being active. Then, emulate the
2086 // Android platform code that clears all 3 buffer slots by setting all but the active buffer
2087 // slot to a placeholder buffer, and then restoring the active buffer.
2088
2089 // This is used on HALs that don't support setLayerBufferSlotsToClear (version <= 3.1).
2090
2091 const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2092 ASSERT_NE(nullptr, buffer1);
2093 const auto handle1 = buffer1->handle;
2094 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle1, /*acquireFence*/ -1);
2095 execute();
2096 ASSERT_TRUE(mReader.takeErrors().empty());
2097
2098 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2099 ASSERT_NE(nullptr, buffer2);
2100 const auto handle2 = buffer2->handle;
2101 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 1, handle2, /*acquireFence*/ -1);
2102 execute();
2103 ASSERT_TRUE(mReader.takeErrors().empty());
2104
2105 const auto buffer3 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2106 ASSERT_NE(nullptr, buffer3);
2107 const auto handle3 = buffer3->handle;
2108 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 2, handle3, /*acquireFence*/ -1);
2109 execute();
2110 ASSERT_TRUE(mReader.takeErrors().empty());
2111
2112 // Older versions of the HAL clear all but the active buffer slot with a placeholder buffer,
2113 // and then restoring the current active buffer at the end
2114 auto clearSlotBuffer = allocate(1u, 1u, ::android::PIXEL_FORMAT_RGB_888);
2115 ASSERT_NE(nullptr, clearSlotBuffer);
2116 auto clearSlotBufferHandle = clearSlotBuffer->handle;
2117
2118 // clear buffer slots 0 and 1 with new layer commands... and then...
2119 writer.setLayerBufferWithNewCommand(getPrimaryDisplayId(), layer, /* slot */ 0,
2120 clearSlotBufferHandle, /*acquireFence*/ -1);
2121 writer.setLayerBufferWithNewCommand(getPrimaryDisplayId(), layer, /* slot */ 1,
2122 clearSlotBufferHandle, /*acquireFence*/ -1);
2123 // ...reset the layer buffer to the current active buffer slot with a final new command
2124 writer.setLayerBufferWithNewCommand(getPrimaryDisplayId(), layer, /*slot*/ 2, nullptr,
2125 /*acquireFence*/ -1);
2126 execute();
2127 ASSERT_TRUE(mReader.takeErrors().empty());
2128 }
2129
TEST_P(GraphicsComposerAidlCommandTest,SetLayerSurfaceDamage)2130 TEST_P(GraphicsComposerAidlCommandTest, SetLayerSurfaceDamage) {
2131 auto& writer = getWriter(getPrimaryDisplayId());
2132 const auto& [layerStatus, layer] =
2133 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
2134 EXPECT_TRUE(layerStatus.isOk());
2135
2136 Rect empty{0, 0, 0, 0};
2137 Rect unit{0, 0, 1, 1};
2138
2139 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
2140 execute();
2141 ASSERT_TRUE(mReader.takeErrors().empty());
2142
2143 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
2144 execute();
2145 ASSERT_TRUE(mReader.takeErrors().empty());
2146
2147 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>());
2148 execute();
2149 ASSERT_TRUE(mReader.takeErrors().empty());
2150 }
2151
TEST_P(GraphicsComposerAidlCommandTest,SetLayerBlockingRegion)2152 TEST_P(GraphicsComposerAidlCommandTest, SetLayerBlockingRegion) {
2153 auto& writer = getWriter(getPrimaryDisplayId());
2154 const auto& [layerStatus, layer] =
2155 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
2156 EXPECT_TRUE(layerStatus.isOk());
2157
2158 Rect empty{0, 0, 0, 0};
2159 Rect unit{0, 0, 1, 1};
2160
2161 writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
2162 execute();
2163 ASSERT_TRUE(mReader.takeErrors().empty());
2164
2165 writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
2166 execute();
2167 ASSERT_TRUE(mReader.takeErrors().empty());
2168
2169 writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>());
2170 execute();
2171 ASSERT_TRUE(mReader.takeErrors().empty());
2172 }
2173
TEST_P(GraphicsComposerAidlCommandTest,SetLayerBlendMode)2174 TEST_P(GraphicsComposerAidlCommandTest, SetLayerBlendMode) {
2175 auto& writer = getWriter(getPrimaryDisplayId());
2176 const auto& [layerStatus, layer] =
2177 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
2178 EXPECT_TRUE(layerStatus.isOk());
2179
2180 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::NONE);
2181 execute();
2182 ASSERT_TRUE(mReader.takeErrors().empty());
2183
2184 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::PREMULTIPLIED);
2185 execute();
2186 ASSERT_TRUE(mReader.takeErrors().empty());
2187
2188 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::COVERAGE);
2189 execute();
2190 ASSERT_TRUE(mReader.takeErrors().empty());
2191 }
2192
TEST_P(GraphicsComposerAidlCommandTest,SetLayerColor)2193 TEST_P(GraphicsComposerAidlCommandTest, SetLayerColor) {
2194 auto& writer = getWriter(getPrimaryDisplayId());
2195 const auto& [layerStatus, layer] =
2196 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
2197 EXPECT_TRUE(layerStatus.isOk());
2198
2199 writer.setLayerColor(getPrimaryDisplayId(), layer, Color{1.0f, 1.0f, 1.0f, 1.0f});
2200 execute();
2201 ASSERT_TRUE(mReader.takeErrors().empty());
2202
2203 writer.setLayerColor(getPrimaryDisplayId(), layer, Color{0.0f, 0.0f, 0.0f, 0.0f});
2204 execute();
2205 ASSERT_TRUE(mReader.takeErrors().empty());
2206 }
2207
TEST_P(GraphicsComposerAidlCommandTest,SetLayerCompositionType)2208 TEST_P(GraphicsComposerAidlCommandTest, SetLayerCompositionType) {
2209 auto& writer = getWriter(getPrimaryDisplayId());
2210 const auto& [layerStatus, layer] =
2211 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
2212 EXPECT_TRUE(layerStatus.isOk());
2213
2214 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::CLIENT);
2215 execute();
2216 ASSERT_TRUE(mReader.takeErrors().empty());
2217
2218 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::DEVICE);
2219 execute();
2220 ASSERT_TRUE(mReader.takeErrors().empty());
2221
2222 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::SOLID_COLOR);
2223 execute();
2224 ASSERT_TRUE(mReader.takeErrors().empty());
2225
2226 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::CURSOR);
2227 execute();
2228 }
2229
TEST_P(GraphicsComposerAidlCommandTest,DisplayDecoration)2230 TEST_P(GraphicsComposerAidlCommandTest, DisplayDecoration) {
2231 for (VtsDisplay& display : mDisplays) {
2232 const auto displayId = display.getDisplayId();
2233 auto& writer = getWriter(displayId);
2234 const auto [layerStatus, layer] =
2235 mComposerClient->createLayer(displayId, kBufferSlotCount, &writer);
2236 ASSERT_TRUE(layerStatus.isOk());
2237
2238 const auto [error, support] = mComposerClient->getDisplayDecorationSupport(displayId);
2239
2240 const auto format = (error.isOk() && support) ? support->format
2241 : aidl::android::hardware::graphics::common::PixelFormat::RGBA_8888;
2242 const auto decorBuffer = allocate(static_cast<::android::PixelFormat>(format));
2243 ASSERT_NE(nullptr, decorBuffer);
2244 if (::android::OK != decorBuffer->initCheck()) {
2245 if (support) {
2246 FAIL() << "Device advertised display decoration support with format "
2247 << aidl::android::hardware::graphics::common::toString(format)
2248 << " but failed to allocate it!";
2249 } else {
2250 FAIL() << "Device advertised NO display decoration support, but it should "
2251 << "still be able to allocate "
2252 << aidl::android::hardware::graphics::common::toString(format);
2253 }
2254 }
2255
2256 configureLayer(display, layer, Composition::DISPLAY_DECORATION, display.getFrameRect(),
2257 display.getCrop());
2258 writer.setLayerBuffer(displayId, layer, /*slot*/ 0, decorBuffer->handle,
2259 /*acquireFence*/ -1);
2260 writer.validateDisplay(displayId, ComposerClientWriter::kNoTimestamp,
2261 VtsComposerClient::kNoFrameIntervalNs);
2262 execute();
2263 if (support) {
2264 ASSERT_TRUE(mReader.takeErrors().empty());
2265 } else {
2266 const auto errors = mReader.takeErrors();
2267 ASSERT_EQ(1, errors.size());
2268 EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, errors[0].errorCode);
2269 }
2270 EXPECT_TRUE(mComposerClient->destroyLayer(displayId, layer, &writer).isOk());
2271 }
2272 }
2273
TEST_P(GraphicsComposerAidlCommandTest,SetLayerDataspace)2274 TEST_P(GraphicsComposerAidlCommandTest, SetLayerDataspace) {
2275 auto& writer = getWriter(getPrimaryDisplayId());
2276 const auto& [layerStatus, layer] =
2277 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
2278 EXPECT_TRUE(layerStatus.isOk());
2279
2280 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
2281 execute();
2282 }
2283
TEST_P(GraphicsComposerAidlCommandTest,SetLayerDisplayFrame)2284 TEST_P(GraphicsComposerAidlCommandTest, SetLayerDisplayFrame) {
2285 auto& writer = getWriter(getPrimaryDisplayId());
2286 const auto& [layerStatus, layer] =
2287 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
2288 EXPECT_TRUE(layerStatus.isOk());
2289
2290 writer.setLayerDisplayFrame(getPrimaryDisplayId(), layer, Rect{0, 0, 1, 1});
2291 execute();
2292 }
2293
TEST_P(GraphicsComposerAidlCommandTest,SetLayerPlaneAlpha)2294 TEST_P(GraphicsComposerAidlCommandTest, SetLayerPlaneAlpha) {
2295 auto& writer = getWriter(getPrimaryDisplayId());
2296 const auto& [layerStatus, layer] =
2297 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
2298 EXPECT_TRUE(layerStatus.isOk());
2299
2300 writer.setLayerPlaneAlpha(getPrimaryDisplayId(), layer, /*alpha*/ 0.0f);
2301 execute();
2302 ASSERT_TRUE(mReader.takeErrors().empty());
2303
2304 writer.setLayerPlaneAlpha(getPrimaryDisplayId(), layer, /*alpha*/ 1.0f);
2305 execute();
2306 ASSERT_TRUE(mReader.takeErrors().empty());
2307 }
2308
TEST_P(GraphicsComposerAidlCommandTest,SetLayerSidebandStream)2309 TEST_P(GraphicsComposerAidlCommandTest, SetLayerSidebandStream) {
2310 if (!hasCapability(Capability::SIDEBAND_STREAM)) {
2311 GTEST_SUCCEED() << "no sideband stream support";
2312 return;
2313 }
2314
2315 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2316 const auto handle = buffer->handle;
2317 ASSERT_NE(nullptr, handle);
2318
2319 auto& writer = getWriter(getPrimaryDisplayId());
2320 const auto& [layerStatus, layer] =
2321 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
2322 EXPECT_TRUE(layerStatus.isOk());
2323
2324 writer.setLayerSidebandStream(getPrimaryDisplayId(), layer, handle);
2325 execute();
2326 }
2327
TEST_P(GraphicsComposerAidlCommandTest,SetLayerSourceCrop)2328 TEST_P(GraphicsComposerAidlCommandTest, SetLayerSourceCrop) {
2329 auto& writer = getWriter(getPrimaryDisplayId());
2330 const auto& [layerStatus, layer] =
2331 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
2332 EXPECT_TRUE(layerStatus.isOk());
2333
2334 writer.setLayerSourceCrop(getPrimaryDisplayId(), layer, FRect{0.0f, 0.0f, 1.0f, 1.0f});
2335 execute();
2336 }
2337
TEST_P(GraphicsComposerAidlCommandTest,SetLayerTransform)2338 TEST_P(GraphicsComposerAidlCommandTest, SetLayerTransform) {
2339 auto& writer = getWriter(getPrimaryDisplayId());
2340 const auto& [layerStatus, layer] =
2341 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
2342 EXPECT_TRUE(layerStatus.isOk());
2343
2344 writer.setLayerTransform(getPrimaryDisplayId(), layer, static_cast<Transform>(0));
2345 execute();
2346 ASSERT_TRUE(mReader.takeErrors().empty());
2347
2348 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::FLIP_H);
2349 execute();
2350 ASSERT_TRUE(mReader.takeErrors().empty());
2351
2352 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::FLIP_V);
2353 execute();
2354 ASSERT_TRUE(mReader.takeErrors().empty());
2355
2356 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_90);
2357 execute();
2358 ASSERT_TRUE(mReader.takeErrors().empty());
2359
2360 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_180);
2361 execute();
2362 ASSERT_TRUE(mReader.takeErrors().empty());
2363
2364 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_270);
2365 execute();
2366 ASSERT_TRUE(mReader.takeErrors().empty());
2367
2368 writer.setLayerTransform(getPrimaryDisplayId(), layer,
2369 static_cast<Transform>(static_cast<int>(Transform::FLIP_H) |
2370 static_cast<int>(Transform::ROT_90)));
2371 execute();
2372 ASSERT_TRUE(mReader.takeErrors().empty());
2373
2374 writer.setLayerTransform(getPrimaryDisplayId(), layer,
2375 static_cast<Transform>(static_cast<int>(Transform::FLIP_V) |
2376 static_cast<int>(Transform::ROT_90)));
2377 execute();
2378 ASSERT_TRUE(mReader.takeErrors().empty());
2379 }
2380
TEST_P(GraphicsComposerAidlCommandTest,SetLayerVisibleRegion)2381 TEST_P(GraphicsComposerAidlCommandTest, SetLayerVisibleRegion) {
2382 auto& writer = getWriter(getPrimaryDisplayId());
2383 const auto& [layerStatus, layer] =
2384 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
2385 EXPECT_TRUE(layerStatus.isOk());
2386
2387 Rect empty{0, 0, 0, 0};
2388 Rect unit{0, 0, 1, 1};
2389
2390 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
2391 execute();
2392 ASSERT_TRUE(mReader.takeErrors().empty());
2393
2394 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
2395 execute();
2396 ASSERT_TRUE(mReader.takeErrors().empty());
2397
2398 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>());
2399 execute();
2400 ASSERT_TRUE(mReader.takeErrors().empty());
2401 }
2402
TEST_P(GraphicsComposerAidlCommandTest,SetLayerZOrder)2403 TEST_P(GraphicsComposerAidlCommandTest, SetLayerZOrder) {
2404 auto& writer = getWriter(getPrimaryDisplayId());
2405
2406 const auto& [layerStatus, layer] =
2407 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
2408 EXPECT_TRUE(layerStatus.isOk());
2409
2410 writer.setLayerZOrder(getPrimaryDisplayId(), layer, /*z*/ 10);
2411 execute();
2412 ASSERT_TRUE(mReader.takeErrors().empty());
2413
2414 writer.setLayerZOrder(getPrimaryDisplayId(), layer, /*z*/ 0);
2415 execute();
2416 ASSERT_TRUE(mReader.takeErrors().empty());
2417 }
2418
TEST_P(GraphicsComposerAidlCommandTest,SetLayerPerFrameMetadata)2419 TEST_P(GraphicsComposerAidlCommandTest, SetLayerPerFrameMetadata) {
2420 auto& writer = getWriter(getPrimaryDisplayId());
2421 const auto& [layerStatus, layer] =
2422 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
2423 EXPECT_TRUE(layerStatus.isOk());
2424
2425 /**
2426 * DISPLAY_P3 is a color space that uses the DCI_P3 primaries,
2427 * the D65 white point and the SRGB transfer functions.
2428 * Rendering Intent: Colorimetric
2429 * Primaries:
2430 * x y
2431 * green 0.265 0.690
2432 * blue 0.150 0.060
2433 * red 0.680 0.320
2434 * white (D65) 0.3127 0.3290
2435 */
2436
2437 std::vector<PerFrameMetadata> aidlMetadata;
2438 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X, 0.680f});
2439 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y, 0.320f});
2440 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X, 0.265f});
2441 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y, 0.690f});
2442 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X, 0.150f});
2443 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y, 0.060f});
2444 aidlMetadata.push_back({PerFrameMetadataKey::WHITE_POINT_X, 0.3127f});
2445 aidlMetadata.push_back({PerFrameMetadataKey::WHITE_POINT_Y, 0.3290f});
2446 aidlMetadata.push_back({PerFrameMetadataKey::MAX_LUMINANCE, 100.0f});
2447 aidlMetadata.push_back({PerFrameMetadataKey::MIN_LUMINANCE, 0.1f});
2448 aidlMetadata.push_back({PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL, 78.0});
2449 aidlMetadata.push_back({PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL, 62.0});
2450 writer.setLayerPerFrameMetadata(getPrimaryDisplayId(), layer, aidlMetadata);
2451 execute();
2452
2453 const auto errors = mReader.takeErrors();
2454 if (errors.size() == 1 && errors[0].errorCode == EX_UNSUPPORTED_OPERATION) {
2455 GTEST_SUCCEED() << "SetLayerPerFrameMetadata is not supported";
2456 EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer, &writer).isOk());
2457 return;
2458 }
2459
2460 EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer, &writer).isOk());
2461 }
2462
TEST_P(GraphicsComposerAidlCommandTest,setLayerBrightness)2463 TEST_P(GraphicsComposerAidlCommandTest, setLayerBrightness) {
2464 auto& writer = getWriter(getPrimaryDisplayId());
2465
2466 const auto& [layerStatus, layer] =
2467 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
2468
2469 writer.setLayerBrightness(getPrimaryDisplayId(), layer, 0.2f);
2470 execute();
2471 ASSERT_TRUE(mReader.takeErrors().empty());
2472
2473 writer.setLayerBrightness(getPrimaryDisplayId(), layer, 1.f);
2474 execute();
2475 ASSERT_TRUE(mReader.takeErrors().empty());
2476
2477 writer.setLayerBrightness(getPrimaryDisplayId(), layer, 0.f);
2478 execute();
2479 ASSERT_TRUE(mReader.takeErrors().empty());
2480
2481 writer.setLayerBrightness(getPrimaryDisplayId(), layer, -1.f);
2482 execute();
2483 {
2484 const auto errors = mReader.takeErrors();
2485 ASSERT_EQ(1, errors.size());
2486 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
2487 }
2488
2489 writer.setLayerBrightness(getPrimaryDisplayId(), layer, std::nanf(""));
2490 execute();
2491 {
2492 const auto errors = mReader.takeErrors();
2493 ASSERT_EQ(1, errors.size());
2494 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
2495 }
2496 }
2497
TEST_P(GraphicsComposerAidlCommandTest,SetActiveConfigWithConstraints)2498 TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints) {
2499 Test_setActiveConfigWithConstraints({.delayForChange = 0, .refreshMiss = false});
2500 }
2501
TEST_P(GraphicsComposerAidlCommandTest,SetActiveConfigWithConstraints_Delayed)2502 TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_Delayed) {
2503 Test_setActiveConfigWithConstraints({.delayForChange = 300'000'000, // 300ms
2504 .refreshMiss = false});
2505 }
2506
TEST_P(GraphicsComposerAidlCommandTest,SetActiveConfigWithConstraints_MissRefresh)2507 TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_MissRefresh) {
2508 Test_setActiveConfigWithConstraints({.delayForChange = 0, .refreshMiss = true});
2509 }
2510
TEST_P(GraphicsComposerAidlCommandTest,GetDisplayVsyncPeriod)2511 TEST_P(GraphicsComposerAidlCommandTest, GetDisplayVsyncPeriod) {
2512 for (VtsDisplay& display : mDisplays) {
2513 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
2514 EXPECT_TRUE(status.isOk());
2515
2516 for (int32_t config : configs) {
2517 int32_t expectedVsyncPeriodNanos = display.getDisplayConfig(config).vsyncPeriod;
2518
2519 VsyncPeriodChangeConstraints constraints;
2520
2521 constraints.desiredTimeNanos = systemTime();
2522 constraints.seamlessRequired = false;
2523
2524 const auto& [timelineStatus, timeline] =
2525 mComposerClient->setActiveConfigWithConstraints(&display, config, constraints);
2526 EXPECT_TRUE(timelineStatus.isOk());
2527
2528 if (timeline.refreshRequired) {
2529 sendRefreshFrame(display, &timeline);
2530 }
2531 waitForVsyncPeriodChange(display.getDisplayId(), timeline, constraints.desiredTimeNanos,
2532 /*odPeriodNanos*/ 0, expectedVsyncPeriodNanos);
2533
2534 int32_t vsyncPeriodNanos;
2535 int retryCount = 100;
2536 do {
2537 std::this_thread::sleep_for(10ms);
2538 const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanosValue] =
2539 mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
2540
2541 EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
2542 vsyncPeriodNanos = vsyncPeriodNanosValue;
2543 --retryCount;
2544 } while (vsyncPeriodNanos != expectedVsyncPeriodNanos && retryCount > 0);
2545
2546 EXPECT_EQ(vsyncPeriodNanos, expectedVsyncPeriodNanos);
2547
2548 // Make sure that the vsync period stays the same if the active config is not
2549 // changed.
2550 auto timeout = 1ms;
2551 for (int i = 0; i < 10; i++) {
2552 std::this_thread::sleep_for(timeout);
2553 timeout *= 2;
2554 vsyncPeriodNanos = 0;
2555 const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanosValue] =
2556 mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
2557
2558 EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
2559 vsyncPeriodNanos = vsyncPeriodNanosValue;
2560 EXPECT_EQ(vsyncPeriodNanos, expectedVsyncPeriodNanos);
2561 }
2562 }
2563 }
2564 }
2565
TEST_P(GraphicsComposerAidlCommandTest,SetActiveConfigWithConstraints_SeamlessNotAllowed)2566 TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_SeamlessNotAllowed) {
2567 VsyncPeriodChangeConstraints constraints;
2568 constraints.seamlessRequired = true;
2569 constraints.desiredTimeNanos = systemTime();
2570
2571 for (VtsDisplay& display : mDisplays) {
2572 forEachTwoConfigs(display.getDisplayId(), [&](int32_t config1, int32_t config2) {
2573 int32_t configGroup1 = display.getDisplayConfig(config1).configGroup;
2574 int32_t configGroup2 = display.getDisplayConfig(config2).configGroup;
2575 if (configGroup1 != configGroup2) {
2576 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
2577 sendRefreshFrame(display, nullptr);
2578 const auto& [status, _] = mComposerClient->setActiveConfigWithConstraints(
2579 &display, config2, constraints);
2580 EXPECT_FALSE(status.isOk());
2581 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(
2582 status, IComposerClient::EX_SEAMLESS_NOT_ALLOWED));
2583 }
2584 });
2585 }
2586 }
2587
TEST_P(GraphicsComposerAidlCommandTest,ExpectedPresentTime_NoTimestamp)2588 TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_NoTimestamp) {
2589 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ std::nullopt));
2590 }
2591
TEST_P(GraphicsComposerAidlCommandTest,ExpectedPresentTime_0)2592 TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_0) {
2593 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ 0));
2594 }
2595
TEST_P(GraphicsComposerAidlCommandTest,ExpectedPresentTime_5)2596 TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_5) {
2597 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ 5));
2598 }
2599
TEST_P(GraphicsComposerAidlCommandTest,SetIdleTimerEnabled_Unsupported)2600 TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Unsupported) {
2601 const bool hasDisplayIdleTimerSupport =
2602 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
2603 if (!hasDisplayIdleTimerSupport) {
2604 const auto& status =
2605 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0);
2606 EXPECT_FALSE(status.isOk());
2607 EXPECT_NO_FATAL_FAILURE(
2608 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
2609 }
2610 }
2611
TEST_P(GraphicsComposerAidlCommandTest,SetIdleTimerEnabled_BadParameter)2612 TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_BadParameter) {
2613 const bool hasDisplayIdleTimerSupport =
2614 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
2615 if (!hasDisplayIdleTimerSupport) {
2616 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2617 return;
2618 }
2619
2620 const auto& status =
2621 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ -1);
2622 EXPECT_FALSE(status.isOk());
2623 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
2624 }
2625
TEST_P(GraphicsComposerAidlCommandTest,SetIdleTimerEnabled_Disable)2626 TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Disable) {
2627 const bool hasDisplayIdleTimerSupport =
2628 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
2629 if (!hasDisplayIdleTimerSupport) {
2630 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2631 return;
2632 }
2633
2634 EXPECT_TRUE(mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0).isOk());
2635 std::this_thread::sleep_for(1s);
2636 EXPECT_EQ(0, mComposerClient->getVsyncIdleCount());
2637 }
2638
TEST_P(GraphicsComposerAidlCommandTest,SetIdleTimerEnabled_Timeout_2)2639 TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Timeout_2) {
2640 const bool hasDisplayIdleTimerSupport =
2641 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
2642 if (!hasDisplayIdleTimerSupport) {
2643 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2644 return;
2645 }
2646
2647 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
2648 EXPECT_TRUE(mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0).isOk());
2649
2650 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2651 ASSERT_NE(nullptr, buffer->handle);
2652
2653 const auto layer = createOnScreenLayer(getPrimaryDisplay());
2654 auto& writer = getWriter(getPrimaryDisplayId());
2655 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer->handle,
2656 /*acquireFence*/ -1);
2657 int32_t vsyncIdleCount = mComposerClient->getVsyncIdleCount();
2658 auto earlyVsyncIdleTime = systemTime() + std::chrono::nanoseconds(2s).count();
2659 EXPECT_TRUE(
2660 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 2000).isOk());
2661
2662 const sp<::android::Fence> presentFence =
2663 presentAndGetFence(ComposerClientWriter::kNoTimestamp);
2664 presentFence->waitForever(LOG_TAG);
2665
2666 std::this_thread::sleep_for(3s);
2667 if (vsyncIdleCount < mComposerClient->getVsyncIdleCount()) {
2668 EXPECT_GE(mComposerClient->getVsyncIdleTime(), earlyVsyncIdleTime);
2669 }
2670
2671 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
2672 }
2673
2674 class GraphicsComposerAidlCommandV2Test : public GraphicsComposerAidlCommandTest {
2675 protected:
SetUp()2676 void SetUp() override {
2677 GraphicsComposerAidlTest::SetUp();
2678 if (getInterfaceVersion() <= 1) {
2679 GTEST_SKIP() << "Device interface version is expected to be >= 2";
2680 }
2681 }
2682 };
2683 /**
2684 * Test Capability::SKIP_VALIDATE
2685 *
2686 * Capability::SKIP_VALIDATE has been deprecated and should not be enabled.
2687 */
TEST_P(GraphicsComposerAidlCommandV2Test,SkipValidateDeprecatedTest)2688 TEST_P(GraphicsComposerAidlCommandV2Test, SkipValidateDeprecatedTest) {
2689 #pragma clang diagnostic push
2690 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
2691 ASSERT_FALSE(hasCapability(Capability::SKIP_VALIDATE))
2692 << "Found Capability::SKIP_VALIDATE capability.";
2693 #pragma clang diagnostic pop
2694 }
2695
TEST_P(GraphicsComposerAidlCommandV2Test,SetLayerBufferSlotsToClear)2696 TEST_P(GraphicsComposerAidlCommandV2Test, SetLayerBufferSlotsToClear) {
2697 auto& writer = getWriter(getPrimaryDisplayId());
2698 // Older HAL versions use a backwards compatible way of clearing buffer slots
2699 // HAL at version 1 or lower does not have LayerCommand::bufferSlotsToClear
2700 const auto& [layerStatus, layer] =
2701 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
2702 EXPECT_TRUE(layerStatus.isOk());
2703
2704 // setup 3 buffers in the buffer cache, with the last buffer being active
2705 // then emulate the Android platform code that clears all 3 buffer slots
2706
2707 const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2708 ASSERT_NE(nullptr, buffer1);
2709 const auto handle1 = buffer1->handle;
2710 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle1, /*acquireFence*/ -1);
2711 execute();
2712 ASSERT_TRUE(mReader.takeErrors().empty());
2713
2714 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2715 ASSERT_NE(nullptr, buffer2);
2716 const auto handle2 = buffer2->handle;
2717 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 1, handle2, /*acquireFence*/ -1);
2718 execute();
2719 ASSERT_TRUE(mReader.takeErrors().empty());
2720
2721 const auto buffer3 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2722 ASSERT_NE(nullptr, buffer3);
2723 const auto handle3 = buffer3->handle;
2724 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 2, handle3, /*acquireFence*/ -1);
2725 execute();
2726 ASSERT_TRUE(mReader.takeErrors().empty());
2727
2728 // Ensure we can clear all 3 buffer slots, even the active buffer - it is assumed the
2729 // current active buffer's slot will be cleared, but still remain the active buffer and no
2730 // errors will occur.
2731 writer.setLayerBufferSlotsToClear(getPrimaryDisplayId(), layer, {0, 1, 2});
2732 execute();
2733 ASSERT_TRUE(mReader.takeErrors().empty());
2734 }
2735
TEST_P(GraphicsComposerAidlCommandV2Test,SetRefreshRateChangedCallbackDebug_Unsupported)2736 TEST_P(GraphicsComposerAidlCommandV2Test, SetRefreshRateChangedCallbackDebug_Unsupported) {
2737 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2738 auto status = mComposerClient->setRefreshRateChangedCallbackDebugEnabled(
2739 getPrimaryDisplayId(), /*enabled*/ true);
2740 EXPECT_FALSE(status.isOk());
2741 EXPECT_NO_FATAL_FAILURE(
2742 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
2743
2744 status = mComposerClient->setRefreshRateChangedCallbackDebugEnabled(getPrimaryDisplayId(),
2745 /*enabled*/ false);
2746 EXPECT_FALSE(status.isOk());
2747 EXPECT_NO_FATAL_FAILURE(
2748 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
2749 }
2750 }
2751
TEST_P(GraphicsComposerAidlCommandV2Test,SetRefreshRateChangedCallbackDebug_Enabled)2752 TEST_P(GraphicsComposerAidlCommandV2Test, SetRefreshRateChangedCallbackDebug_Enabled) {
2753 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2754 GTEST_SUCCEED() << "Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG is not supported";
2755 return;
2756 }
2757
2758 for (VtsDisplay& display : mDisplays) {
2759 const auto displayId = display.getDisplayId();
2760 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2761 // Enable the callback
2762 ASSERT_TRUE(mComposerClient
2763 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2764 /*enabled*/ true)
2765 .isOk());
2766 std::this_thread::sleep_for(100ms);
2767
2768 const auto [status, configId] = mComposerClient->getActiveConfig(display.getDisplayId());
2769 EXPECT_TRUE(status.isOk());
2770
2771 const auto displayFilter = [&](auto refreshRateChangedDebugData) {
2772 bool nonVrrRateMatching = true;
2773 if (std::optional<VrrConfig> vrrConfigOpt =
2774 display.getDisplayConfig(configId).vrrConfigOpt;
2775 getInterfaceVersion() >= 3 && !vrrConfigOpt) {
2776 nonVrrRateMatching = refreshRateChangedDebugData.refreshPeriodNanos ==
2777 refreshRateChangedDebugData.vsyncPeriodNanos;
2778 }
2779 const bool isDisplaySame =
2780 display.getDisplayId() == refreshRateChangedDebugData.display;
2781 return nonVrrRateMatching && isDisplaySame;
2782 };
2783
2784 // Check that we immediately got a callback
2785 EXPECT_TRUE(checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter));
2786
2787 ASSERT_TRUE(mComposerClient
2788 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2789 /*enabled*/ false)
2790 .isOk());
2791 }
2792 }
2793
TEST_P(GraphicsComposerAidlCommandV2Test,SetRefreshRateChangedCallbackDebugEnabled_noCallbackWhenIdle)2794 TEST_P(GraphicsComposerAidlCommandV2Test,
2795 SetRefreshRateChangedCallbackDebugEnabled_noCallbackWhenIdle) {
2796 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2797 GTEST_SUCCEED() << "Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG is not supported";
2798 return;
2799 }
2800
2801 auto display = getEditablePrimaryDisplay();
2802 const auto displayId = display.getDisplayId();
2803
2804 if (!hasDisplayCapability(displayId, DisplayCapability::DISPLAY_IDLE_TIMER)) {
2805 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2806 return;
2807 }
2808
2809 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2810 EXPECT_TRUE(mComposerClient->setPeakRefreshRateConfig(&display).isOk());
2811
2812 ASSERT_TRUE(mComposerClient->setIdleTimerEnabled(displayId, /*timeoutMs*/ 500).isOk());
2813 // Enable the callback
2814 ASSERT_TRUE(mComposerClient
2815 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2816 /*enabled*/ true)
2817 .isOk());
2818
2819 const auto displayFilter = [displayId](auto refreshRateChangedDebugData) {
2820 return displayId == refreshRateChangedDebugData.display;
2821 };
2822
2823 int retryCount = 3;
2824 do {
2825 // Wait for 1s so that we enter the idle state
2826 std::this_thread::sleep_for(1s);
2827 if (!checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter)) {
2828 // DID NOT receive a callback, we are in the idle state.
2829 break;
2830 }
2831 } while (--retryCount > 0);
2832
2833 if (retryCount == 0) {
2834 GTEST_SUCCEED() << "Unable to enter the idle mode";
2835 return;
2836 }
2837
2838 // Send the REFRESH_RATE_INDICATOR update
2839 ASSERT_NO_FATAL_FAILURE(sendBufferUpdate(
2840 createOnScreenLayer(getPrimaryDisplay(), Composition::REFRESH_RATE_INDICATOR)));
2841 std::this_thread::sleep_for(1s);
2842 EXPECT_FALSE(checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter))
2843 << "A callback should not be received for REFRESH_RATE_INDICATOR";
2844
2845 EXPECT_TRUE(mComposerClient
2846 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2847 /*enabled*/ false)
2848 .isOk());
2849 }
2850
TEST_P(GraphicsComposerAidlCommandV2Test,SetRefreshRateChangedCallbackDebugEnabled_SetActiveConfigWithConstraints)2851 TEST_P(GraphicsComposerAidlCommandV2Test,
2852 SetRefreshRateChangedCallbackDebugEnabled_SetActiveConfigWithConstraints) {
2853 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2854 GTEST_SUCCEED() << "Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG is not supported";
2855 return;
2856 }
2857
2858 VsyncPeriodChangeConstraints constraints;
2859 constraints.seamlessRequired = false;
2860 constraints.desiredTimeNanos = systemTime();
2861
2862 for (VtsDisplay& display : mDisplays) {
2863 const auto displayId = display.getDisplayId();
2864 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2865
2866 // Enable the callback
2867 ASSERT_TRUE(mComposerClient
2868 ->setRefreshRateChangedCallbackDebugEnabled(displayId, /*enabled*/ true)
2869 .isOk());
2870
2871 forEachTwoConfigs(displayId, [&](int32_t config1, int32_t config2) {
2872 if (display.isRateSameBetweenConfigs(config1, config2)) {
2873 return; // continue
2874 }
2875
2876 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
2877 sendRefreshFrame(display, nullptr);
2878
2879 const auto& [status, timeline] =
2880 mComposerClient->setActiveConfigWithConstraints(&display, config2, constraints);
2881 EXPECT_TRUE(status.isOk());
2882
2883 if (timeline.refreshRequired) {
2884 sendRefreshFrame(display, &timeline);
2885 }
2886
2887 const int32_t vsyncPeriod2 = display.getDisplayConfig(config2).vsyncPeriod;
2888 const auto callbackFilter = [displayId,
2889 vsyncPeriod2](auto refreshRateChangedDebugData) {
2890 constexpr int kVsyncThreshold = 1000;
2891 return displayId == refreshRateChangedDebugData.display &&
2892 std::abs(vsyncPeriod2 - refreshRateChangedDebugData.vsyncPeriodNanos) <=
2893 kVsyncThreshold;
2894 };
2895
2896 int retryCount = 3;
2897 do {
2898 std::this_thread::sleep_for(100ms);
2899 if (checkIfCallbackRefreshRateChangedDebugEnabledReceived(callbackFilter)) {
2900 GTEST_SUCCEED() << "Received a callback successfully";
2901 break;
2902 }
2903 } while (--retryCount > 0);
2904
2905 if (retryCount == 0) {
2906 GTEST_FAIL() << "Failed to get a callback for Display " << displayId
2907 << " switching from " << display.printConfig(config1)
2908 << " to " << display.printConfig(config2);
2909 }
2910 });
2911
2912 EXPECT_TRUE(
2913 mComposerClient
2914 ->setRefreshRateChangedCallbackDebugEnabled(displayId, /*enabled*/ false)
2915 .isOk());
2916 }
2917 }
2918
TEST_P(GraphicsComposerAidlCommandTest,MultiThreadedPresent)2919 TEST_P(GraphicsComposerAidlCommandTest, MultiThreadedPresent) {
2920 std::vector<VtsDisplay*> displays;
2921 for (auto& display : mDisplays) {
2922 if (hasDisplayCapability(display.getDisplayId(),
2923 DisplayCapability::MULTI_THREADED_PRESENT)) {
2924 displays.push_back(&display);
2925 }
2926 }
2927
2928 const size_t numDisplays = displays.size();
2929 if (numDisplays <= 1u) {
2930 GTEST_SKIP();
2931 }
2932
2933 // When multi-threaded, use a reader per display. As with mWriters, this mutex
2934 // guards access to the map.
2935 std::mutex readersMutex;
2936 std::unordered_map<int64_t, ComposerClientReader> readers;
2937 std::vector<std::thread> threads;
2938 threads.reserve(numDisplays);
2939
2940 // Each display will have a layer to present. This maps from the display to
2941 // the layer, so we can properly destroy each layer at the end.
2942 std::unordered_map<int64_t, int64_t> layers;
2943
2944 for (auto* const display : displays) {
2945 const int64_t displayId = display->getDisplayId();
2946
2947 // Ensure that all writers and readers have been added to their respective
2948 // maps initially, so that the following loop never modifies the maps. The
2949 // maps are accessed from different threads, and if the maps were modified,
2950 // this would invalidate their iterators, and therefore references to the
2951 // writers and readers.
2952 auto& writer = getWriter(displayId);
2953 {
2954 std::lock_guard guard{readersMutex};
2955 readers.try_emplace(displayId, displayId);
2956 }
2957
2958 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2959
2960 const auto& [status, layer] =
2961 mComposerClient->createLayer(displayId, kBufferSlotCount, &writer);
2962 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2963 ASSERT_NE(nullptr, buffer);
2964 ASSERT_EQ(::android::OK, buffer->initCheck());
2965 ASSERT_NE(nullptr, buffer->handle);
2966
2967 configureLayer(*display, layer, Composition::DEVICE, display->getFrameRect(),
2968 display->getCrop());
2969 writer.setLayerBuffer(displayId, layer, /*slot*/ 0, buffer->handle,
2970 /*acquireFence*/ -1);
2971 writer.setLayerDataspace(displayId, layer, common::Dataspace::UNKNOWN);
2972 layers.try_emplace(displayId, layer);
2973 }
2974
2975 for (auto* const display : displays) {
2976 const int64_t displayId = display->getDisplayId();
2977 auto& writer = getWriter(displayId);
2978 std::unique_lock lock{readersMutex};
2979 auto& reader = readers.at(displayId);
2980 lock.unlock();
2981
2982 writer.validateDisplay(displayId, ComposerClientWriter::kNoTimestamp,
2983 VtsComposerClient::kNoFrameIntervalNs);
2984 execute(writer, reader);
2985
2986 threads.emplace_back([this, displayId, &readers, &readersMutex]() {
2987 auto& writer = getWriter(displayId);
2988 std::unique_lock lock{readersMutex};
2989 ComposerClientReader& reader = readers.at(displayId);
2990 lock.unlock();
2991
2992 writer.presentDisplay(displayId);
2993 execute(writer, reader);
2994 ASSERT_TRUE(reader.takeErrors().empty());
2995
2996 auto presentFence = reader.takePresentFence(displayId);
2997 // take ownership
2998 const int fenceOwner = presentFence.get();
2999 *presentFence.getR() = -1;
3000 EXPECT_NE(-1, fenceOwner);
3001 const auto presentFence2 = sp<::android::Fence>::make(fenceOwner);
3002 presentFence2->waitForever(LOG_TAG);
3003 });
3004 }
3005
3006 for (auto& thread : threads) {
3007 thread.join();
3008 }
3009
3010 for (auto& [displayId, layer] : layers) {
3011 auto& writer = getWriter(displayId);
3012 EXPECT_TRUE(mComposerClient->destroyLayer(displayId, layer, &writer).isOk());
3013 }
3014
3015 std::lock_guard guard{readersMutex};
3016 for (auto& [displayId, reader] : readers) {
3017 ASSERT_TRUE(reader.takeErrors().empty());
3018 ASSERT_TRUE(reader.takeChangedCompositionTypes(displayId).empty());
3019 }
3020 }
3021
3022 class GraphicsComposerAidlCommandV3Test : public GraphicsComposerAidlCommandTest {
3023 protected:
SetUp()3024 void SetUp() override {
3025 GraphicsComposerAidlTest::SetUp();
3026 if (getInterfaceVersion() <= 2) {
3027 GTEST_SKIP() << "Device interface version is expected to be >= 3";
3028 }
3029 }
3030 };
3031
TEST_P(GraphicsComposerAidlCommandV3Test,CreateBatchedCommand)3032 TEST_P(GraphicsComposerAidlCommandV3Test, CreateBatchedCommand) {
3033 if (!hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
3034 GTEST_SKIP() << "LAYER_LIFECYCLE_BATCH_COMMAND not supported by the implementation";
3035 return;
3036 }
3037 auto& writer = getWriter(getPrimaryDisplayId());
3038 const auto& [status, layer] =
3039 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
3040 EXPECT_TRUE(status.isOk());
3041 execute();
3042 ASSERT_TRUE(mReader.takeErrors().empty());
3043 }
3044
TEST_P(GraphicsComposerAidlCommandV3Test,CreateBatchedCommand_BadDisplay)3045 TEST_P(GraphicsComposerAidlCommandV3Test, CreateBatchedCommand_BadDisplay) {
3046 if (!hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
3047 GTEST_SKIP() << "LAYER_LIFECYCLE_BATCH_COMMAND not supported by the implementation";
3048 return;
3049 }
3050 auto& writer = getWriter(getInvalidDisplayId());
3051 int64_t layer = 5;
3052 writer.setLayerLifecycleBatchCommandType(getInvalidDisplayId(), layer,
3053 LayerLifecycleBatchCommandType::CREATE);
3054 writer.setNewBufferSlotCount(getInvalidDisplayId(), layer, 1);
3055 execute();
3056
3057 const auto errors = mReader.takeErrors();
3058 ASSERT_TRUE(errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_BAD_DISPLAY);
3059 }
3060
TEST_P(GraphicsComposerAidlCommandV3Test,DestroyBatchedCommand)3061 TEST_P(GraphicsComposerAidlCommandV3Test, DestroyBatchedCommand) {
3062 if (!hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
3063 GTEST_SKIP() << "LAYER_LIFECYCLE_BATCH_COMMAND not supported by the implementation";
3064 return;
3065 }
3066 auto& writer = getWriter(getPrimaryDisplayId());
3067 const auto& [status, layer] =
3068 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
3069 EXPECT_TRUE(status.isOk());
3070 execute();
3071 ASSERT_TRUE(mReader.takeErrors().empty());
3072 EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer, &writer).isOk());
3073 execute();
3074 ASSERT_TRUE(mReader.takeErrors().empty());
3075 }
3076
TEST_P(GraphicsComposerAidlCommandV3Test,DestroyBatchedCommand_BadDisplay)3077 TEST_P(GraphicsComposerAidlCommandV3Test, DestroyBatchedCommand_BadDisplay) {
3078 if (!hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
3079 GTEST_SKIP() << "LAYER_LIFECYCLE_BATCH_COMMAND not supported by the implementation";
3080 return;
3081 }
3082 auto& writer = getWriter(getPrimaryDisplayId());
3083 const auto& [status, layer] =
3084 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
3085
3086 EXPECT_TRUE(status.isOk());
3087 execute();
3088 ASSERT_TRUE(mReader.takeErrors().empty());
3089
3090 auto& invalid_writer = getWriter(getInvalidDisplayId());
3091 invalid_writer.setLayerLifecycleBatchCommandType(getInvalidDisplayId(), layer,
3092 LayerLifecycleBatchCommandType::DESTROY);
3093 execute();
3094 const auto errors = mReader.takeErrors();
3095 ASSERT_TRUE(errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_BAD_DISPLAY);
3096 }
3097
TEST_P(GraphicsComposerAidlCommandV3Test,NoCreateDestroyBatchedCommandIncorrectLayer)3098 TEST_P(GraphicsComposerAidlCommandV3Test, NoCreateDestroyBatchedCommandIncorrectLayer) {
3099 if (!hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
3100 GTEST_SKIP() << "LAYER_LIFECYCLE_BATCH_COMMAND not supported by the implementation";
3101 return;
3102 }
3103
3104 auto& writer = getWriter(getPrimaryDisplayId());
3105 int64_t layer = 5;
3106 writer.setLayerLifecycleBatchCommandType(getPrimaryDisplayId(), layer,
3107 LayerLifecycleBatchCommandType::DESTROY);
3108 execute();
3109 const auto errors = mReader.takeErrors();
3110 ASSERT_TRUE(errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_BAD_LAYER);
3111 }
3112
TEST_P(GraphicsComposerAidlCommandV3Test,notifyExpectedPresentTimeout)3113 TEST_P(GraphicsComposerAidlCommandV3Test, notifyExpectedPresentTimeout) {
3114 if (hasCapability(Capability::PRESENT_FENCE_IS_NOT_RELIABLE)) {
3115 GTEST_SUCCEED() << "Device has unreliable present fences capability, skipping";
3116 return;
3117 }
3118 forEachNotifyExpectedPresentConfig([&](VtsDisplay& display,
3119 const DisplayConfiguration& config) {
3120 const auto displayId = display.getDisplayId();
3121 auto minFrameIntervalNs = config.vrrConfig->minFrameIntervalNs;
3122 const auto timeoutNs = config.vrrConfig->notifyExpectedPresentConfig->timeoutNs;
3123
3124 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
3125 ASSERT_NE(nullptr, buffer);
3126 const auto layer = createOnScreenLayer(display);
3127 auto& writer = getWriter(displayId);
3128 writer.setLayerBuffer(displayId, layer, /*slot*/ 0, buffer->handle,
3129 /*acquireFence*/ -1);
3130 sp<::android::Fence> presentFence = presentAndGetFence(ComposerClientWriter::kNoTimestamp,
3131 displayId, minFrameIntervalNs);
3132 presentFence->waitForever(LOG_TAG);
3133 auto lastPresentTimeNs = presentFence->getSignalTime();
3134
3135 // Frame presents 30ms after timeout
3136 const auto timeout = static_cast<const std::chrono::nanoseconds>(timeoutNs);
3137 const auto vsyncPeriod = config.vsyncPeriod;
3138 int32_t frameAfterTimeoutNs =
3139 vsyncPeriod * static_cast<int32_t>((timeout + 30ms).count() / vsyncPeriod);
3140 auto expectedPresentTimestamp =
3141 ClockMonotonicTimestamp{lastPresentTimeNs + frameAfterTimeoutNs};
3142 std::this_thread::sleep_for(timeout);
3143 mComposerClient->notifyExpectedPresent(displayId, expectedPresentTimestamp,
3144 minFrameIntervalNs);
3145 presentFence = presentAndGetFence(expectedPresentTimestamp, displayId, minFrameIntervalNs);
3146 presentFence->waitForever(LOG_TAG);
3147 lastPresentTimeNs = presentFence->getSignalTime();
3148 ASSERT_GE(lastPresentTimeNs, expectedPresentTimestamp.timestampNanos - vsyncPeriod / 2);
3149 mComposerClient->destroyLayer(displayId, layer, &writer);
3150 });
3151 }
3152
TEST_P(GraphicsComposerAidlCommandV3Test,notifyExpectedPresentFrameIntervalChange)3153 TEST_P(GraphicsComposerAidlCommandV3Test, notifyExpectedPresentFrameIntervalChange) {
3154 if (hasCapability(Capability::PRESENT_FENCE_IS_NOT_RELIABLE)) {
3155 GTEST_SUCCEED() << "Device has unreliable present fences capability, skipping";
3156 return;
3157 }
3158 forEachNotifyExpectedPresentConfig([&](VtsDisplay& display,
3159 const DisplayConfiguration& config) {
3160 const auto displayId = display.getDisplayId();
3161 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
3162 ASSERT_NE(nullptr, buffer);
3163 const auto layer = createOnScreenLayer(display);
3164 auto& writer = getWriter(displayId);
3165 writer.setLayerBuffer(displayId, layer, /*slot*/ 0, buffer->handle,
3166 /*acquireFence*/ -1);
3167 auto minFrameIntervalNs = config.vrrConfig->minFrameIntervalNs;
3168 sp<::android::Fence> presentFence = presentAndGetFence(ComposerClientWriter::kNoTimestamp,
3169 displayId, minFrameIntervalNs);
3170 presentFence->waitForever(LOG_TAG);
3171 auto lastPresentTimeNs = presentFence->getSignalTime();
3172
3173 auto vsyncPeriod = config.vsyncPeriod;
3174 int32_t highestDivisor = VtsComposerClient::kMaxFrameIntervalNs / vsyncPeriod;
3175 int32_t lowestDivisor = minFrameIntervalNs / vsyncPeriod;
3176 const auto headsUpNs = config.vrrConfig->notifyExpectedPresentConfig->headsUpNs;
3177 float totalDivisorsPassed = 0.f;
3178 for (int divisor = lowestDivisor; divisor <= highestDivisor; divisor++) {
3179 const auto frameIntervalNs = vsyncPeriod * divisor;
3180 const auto frameAfterHeadsUp = frameIntervalNs * (headsUpNs / frameIntervalNs);
3181 auto presentTime = lastPresentTimeNs + frameIntervalNs + frameAfterHeadsUp;
3182 const auto expectedPresentTimestamp = ClockMonotonicTimestamp{presentTime};
3183 ASSERT_TRUE(mComposerClient
3184 ->notifyExpectedPresent(displayId, expectedPresentTimestamp,
3185 frameIntervalNs)
3186 .isOk());
3187 presentFence = presentAndGetFence(expectedPresentTimestamp, displayId, frameIntervalNs);
3188 presentFence->waitForever(LOG_TAG);
3189 lastPresentTimeNs = presentFence->getSignalTime();
3190 if (lastPresentTimeNs >= expectedPresentTimestamp.timestampNanos - vsyncPeriod / 2) {
3191 ++totalDivisorsPassed;
3192 }
3193 }
3194 EXPECT_TRUE(totalDivisorsPassed >
3195 (static_cast<float>(highestDivisor - lowestDivisor)) * 0.75f);
3196 mComposerClient->destroyLayer(displayId, layer, &writer);
3197 });
3198 }
3199
TEST_P(GraphicsComposerAidlCommandV3Test,frameIntervalChangeAtPresentFrame)3200 TEST_P(GraphicsComposerAidlCommandV3Test, frameIntervalChangeAtPresentFrame) {
3201 if (hasCapability(Capability::PRESENT_FENCE_IS_NOT_RELIABLE)) {
3202 GTEST_SUCCEED() << "Device has unreliable present fences capability, skipping";
3203 return;
3204 }
3205 forEachNotifyExpectedPresentConfig([&](VtsDisplay& display,
3206 const DisplayConfiguration& config) {
3207 const auto displayId = display.getDisplayId();
3208 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
3209 ASSERT_NE(nullptr, buffer);
3210 const auto layer = createOnScreenLayer(display);
3211 auto& writer = getWriter(displayId);
3212 writer.setLayerBuffer(displayId, layer, /*slot*/ 0, buffer->handle,
3213 /*acquireFence*/ -1);
3214 auto minFrameIntervalNs = config.vrrConfig->minFrameIntervalNs;
3215
3216 auto vsyncPeriod = config.vsyncPeriod;
3217 int32_t highestDivisor = VtsComposerClient::kMaxFrameIntervalNs / vsyncPeriod;
3218 int32_t lowestDivisor = minFrameIntervalNs / vsyncPeriod;
3219 const auto headsUpNs = config.vrrConfig->notifyExpectedPresentConfig->headsUpNs;
3220 float totalDivisorsPassed = 0.f;
3221 int divisor = lowestDivisor;
3222 auto frameIntervalNs = vsyncPeriod * divisor;
3223 sp<::android::Fence> presentFence =
3224 presentAndGetFence(ComposerClientWriter::kNoTimestamp, displayId, frameIntervalNs);
3225 presentFence->waitForever(LOG_TAG);
3226 auto lastPresentTimeNs = presentFence->getSignalTime();
3227 do {
3228 frameIntervalNs = vsyncPeriod * divisor;
3229 ++divisor;
3230 const auto nextFrameIntervalNs = vsyncPeriod * divisor;
3231 const auto frameAfterHeadsUp = frameIntervalNs * (headsUpNs / frameIntervalNs);
3232 auto presentTime = lastPresentTimeNs + frameIntervalNs + frameAfterHeadsUp;
3233 const auto expectedPresentTimestamp = ClockMonotonicTimestamp{presentTime};
3234 presentFence =
3235 presentAndGetFence(expectedPresentTimestamp, displayId, nextFrameIntervalNs);
3236 presentFence->waitForever(LOG_TAG);
3237 lastPresentTimeNs = presentFence->getSignalTime();
3238 if (lastPresentTimeNs >= expectedPresentTimestamp.timestampNanos - vsyncPeriod / 2) {
3239 ++totalDivisorsPassed;
3240 }
3241 } while (divisor < highestDivisor);
3242 EXPECT_TRUE(totalDivisorsPassed >
3243 (static_cast<float>(highestDivisor - lowestDivisor)) * 0.75f);
3244 mComposerClient->destroyLayer(displayId, layer, &writer);
3245 });
3246 }
3247
3248 class GraphicsComposerAidlCommandV4Test : public GraphicsComposerAidlCommandTest {
3249 protected:
SetUp()3250 void SetUp() override {
3251 GraphicsComposerAidlTest::SetUp();
3252 if (getInterfaceVersion() <= 3) {
3253 GTEST_SKIP() << "Device interface version is expected to be >= 4";
3254 }
3255 }
3256 };
3257
TEST_P(GraphicsComposerAidlCommandV4Test,getMaxLayerPictureProfiles_success)3258 TEST_P(GraphicsComposerAidlCommandV4Test, getMaxLayerPictureProfiles_success) {
3259 for (auto& display : mDisplays) {
3260 int64_t displayId = display.getDisplayId();
3261 if (!hasDisplayCapability(displayId, DisplayCapability::PICTURE_PROCESSING)) {
3262 continue;
3263 }
3264 const auto& [status, maxProfiles] =
3265 mComposerClient->getMaxLayerPictureProfiles(displayId);
3266 EXPECT_TRUE(status.isOk());
3267 EXPECT_THAT(maxProfiles, Ge(0));
3268 }
3269 }
3270
TEST_P(GraphicsComposerAidlCommandV4Test,getMaxLayerPictureProfiles_unsupported)3271 TEST_P(GraphicsComposerAidlCommandV4Test, getMaxLayerPictureProfiles_unsupported) {
3272 for (auto& display : mDisplays) {
3273 int64_t displayId = display.getDisplayId();
3274 if (hasDisplayCapability(displayId, DisplayCapability::PICTURE_PROCESSING)) {
3275 continue;
3276 }
3277 const auto& [status, maxProfiles] =
3278 mComposerClient->getMaxLayerPictureProfiles(displayId);
3279 EXPECT_FALSE(status.isOk());
3280 EXPECT_NO_FATAL_FAILURE(
3281 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
3282 }
3283 }
3284
TEST_P(GraphicsComposerAidlCommandV4Test,setDisplayPictureProfileId_success)3285 TEST_P(GraphicsComposerAidlCommandV4Test, setDisplayPictureProfileId_success) {
3286 for (auto& display : mDisplays) {
3287 int64_t displayId = display.getDisplayId();
3288 if (!hasDisplayCapability(displayId, DisplayCapability::PICTURE_PROCESSING)) {
3289 continue;
3290 }
3291
3292 auto& writer = getWriter(displayId);
3293 const auto layer = createOnScreenLayer(display);
3294 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
3295 ASSERT_NE(nullptr, buffer->handle);
3296 // TODO(b/337330263): Lookup profile IDs from MediaQualityManager
3297 writer.setDisplayPictureProfileId(displayId, PictureProfileId(1));
3298 writer.setLayerBuffer(displayId, layer, /*slot*/ 0, buffer->handle,
3299 /*acquireFence*/ -1);
3300 execute();
3301 ASSERT_TRUE(mReader.takeErrors().empty());
3302 }
3303 }
3304
TEST_P(GraphicsComposerAidlCommandV4Test,setLayerPictureProfileId_success)3305 TEST_P(GraphicsComposerAidlCommandV4Test, setLayerPictureProfileId_success) {
3306 for (auto& display : mDisplays) {
3307 int64_t displayId = display.getDisplayId();
3308 if (!hasDisplayCapability(displayId, DisplayCapability::PICTURE_PROCESSING)) {
3309 continue;
3310 }
3311 const auto& [status, maxProfiles] = mComposerClient->getMaxLayerPictureProfiles(displayId);
3312 EXPECT_TRUE(status.isOk());
3313 if (maxProfiles == 0) {
3314 continue;
3315 }
3316
3317 auto& writer = getWriter(displayId);
3318 const auto layer = createOnScreenLayer(display);
3319 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
3320 ASSERT_NE(nullptr, buffer->handle);
3321 writer.setLayerBuffer(displayId, layer, /*slot*/ 0, buffer->handle,
3322 /*acquireFence*/ -1);
3323 // TODO(b/337330263): Lookup profile IDs from MediaQualityManager
3324 writer.setLayerPictureProfileId(displayId, layer, PictureProfileId(1));
3325 execute();
3326 ASSERT_TRUE(mReader.takeErrors().empty());
3327 }
3328 }
3329
TEST_P(GraphicsComposerAidlCommandV4Test,setLayerPictureProfileId_failsWithTooManyProfiles)3330 TEST_P(GraphicsComposerAidlCommandV4Test, setLayerPictureProfileId_failsWithTooManyProfiles) {
3331 for (auto& display : mDisplays) {
3332 int64_t displayId = display.getDisplayId();
3333 if (!hasDisplayCapability(displayId, DisplayCapability::PICTURE_PROCESSING)) {
3334 continue;
3335 }
3336 const auto& [status, maxProfiles] = mComposerClient->getMaxLayerPictureProfiles(displayId);
3337 EXPECT_TRUE(status.isOk());
3338 if (maxProfiles == 0) {
3339 continue;
3340 }
3341
3342 auto& writer = getWriter(displayId);
3343 for (int profileId = 1; profileId <= maxProfiles + 1; ++profileId) {
3344 const auto layer = createOnScreenLayer(display);
3345 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
3346 ASSERT_NE(nullptr, buffer->handle);
3347 writer.setLayerBuffer(displayId, layer, /*slot*/ 0, buffer->handle,
3348 /*acquireFence*/ -1);
3349 // TODO(b/337330263): Lookup profile IDs from MediaQualityManager
3350 writer.setLayerPictureProfileId(displayId, layer, PictureProfileId(profileId));
3351 }
3352 execute();
3353 const auto errors = mReader.takeErrors();
3354 ASSERT_TRUE(errors.size() == 1 &&
3355 errors[0].errorCode == IComposerClient::EX_PICTURE_PROFILE_MAX_EXCEEDED);
3356 }
3357 }
3358
TEST_P(GraphicsComposerAidlCommandV4Test,SetUnsupportedLayerLuts)3359 TEST_P(GraphicsComposerAidlCommandV4Test, SetUnsupportedLayerLuts) {
3360 auto& writer = getWriter(getPrimaryDisplayId());
3361 const auto& [layerStatus, layer] =
3362 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
3363 EXPECT_TRUE(layerStatus.isOk());
3364 const auto& [status, properties] = mComposerClient->getOverlaySupport();
3365 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
3366 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
3367 GTEST_SUCCEED() << "getOverlaySupport is not supported";
3368 return;
3369 }
3370 ASSERT_TRUE(status.isOk());
3371
3372 // TODO (b/362319189): add Lut VTS enforcement
3373 if (!properties.lutProperties) {
3374 int32_t size = 7;
3375 size_t bufferSize = static_cast<size_t>(size) * sizeof(float);
3376 int32_t fd = ashmem_create_region("lut_shared_mem", bufferSize);
3377 void* ptr = mmap(nullptr, bufferSize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
3378 std::vector<float> buffers = {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f};
3379 memcpy(ptr, buffers.data(), bufferSize);
3380 munmap(ptr, bufferSize);
3381 Luts luts;
3382 luts.offsets = {0};
3383 luts.lutProperties = {
3384 {LutProperties::Dimension::ONE_D, size, {LutProperties::SamplingKey::RGB}}};
3385 luts.pfd = ndk::ScopedFileDescriptor(fd);
3386
3387 writer.setLayerLuts(getPrimaryDisplayId(), layer, luts);
3388 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
3389 VtsComposerClient::kNoFrameIntervalNs);
3390 execute();
3391 // change to client composition
3392 ASSERT_FALSE(mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty());
3393 ASSERT_TRUE(mReader.takeErrors().empty());
3394 }
3395 }
3396
TEST_P(GraphicsComposerAidlCommandV4Test,GetDisplayConfigurations_hasHdrType)3397 TEST_P(GraphicsComposerAidlCommandV4Test, GetDisplayConfigurations_hasHdrType) {
3398 for (const auto& display : mDisplays) {
3399 const auto& [status, displayConfigurations] =
3400 mComposerClient->getDisplayConfigurations(display.getDisplayId());
3401 EXPECT_TRUE(status.isOk());
3402 EXPECT_FALSE(displayConfigurations.empty());
3403
3404 for (const auto& displayConfig : displayConfigurations) {
3405 EXPECT_NE(displayConfig.hdrOutputType, OutputType::INVALID);
3406 }
3407 }
3408 }
3409
3410 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlCommandTest);
3411 INSTANTIATE_TEST_SUITE_P(
3412 PerInstance, GraphicsComposerAidlCommandTest,
3413 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
3414 ::android::PrintInstanceNameToString);
3415 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlTest);
3416 INSTANTIATE_TEST_SUITE_P(
3417 PerInstance, GraphicsComposerAidlTest,
3418 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
3419 ::android::PrintInstanceNameToString);
3420 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlV2Test);
3421 INSTANTIATE_TEST_SUITE_P(
3422 PerInstance, GraphicsComposerAidlV2Test,
3423 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
3424 ::android::PrintInstanceNameToString);
3425 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlV3Test);
3426 INSTANTIATE_TEST_SUITE_P(
3427 PerInstance, GraphicsComposerAidlV3Test,
3428 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
3429 ::android::PrintInstanceNameToString);
3430 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlCommandV2Test);
3431 INSTANTIATE_TEST_SUITE_P(
3432 PerInstance, GraphicsComposerAidlCommandV2Test,
3433 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
3434 ::android::PrintInstanceNameToString);
3435 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlCommandV3Test);
3436 INSTANTIATE_TEST_SUITE_P(
3437 PerInstance, GraphicsComposerAidlCommandV3Test,
3438 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
3439 ::android::PrintInstanceNameToString);
3440 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlCommandV4Test);
3441 INSTANTIATE_TEST_SUITE_P(
3442 PerInstance, GraphicsComposerAidlCommandV4Test,
3443 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
3444 ::android::PrintInstanceNameToString);
3445 } // namespace aidl::android::hardware::graphics::composer3::vts
3446
main(int argc,char ** argv)3447 int main(int argc, char** argv) {
3448 ::testing::InitGoogleTest(&argc, argv);
3449
3450 using namespace std::chrono_literals;
3451 if (!android::base::WaitForProperty("init.svc.surfaceflinger", "stopped", 10s)) {
3452 ALOGE("Failed to stop init.svc.surfaceflinger");
3453 return -1;
3454 }
3455
3456 android::ProcessState::self()->setThreadPoolMaxThreadCount(4);
3457
3458 // The binder threadpool we start will inherit sched policy and priority
3459 // of (this) creating thread. We want the binder thread pool to have
3460 // SCHED_FIFO policy and priority 1 (lowest RT priority)
3461 // Once the pool is created we reset this thread's priority back to
3462 // original.
3463 // This thread policy is based on what we do in the SurfaceFlinger while starting
3464 // the thread pool and we need to replicate that for the VTS tests.
3465 int newPriority = 0;
3466 int origPolicy = sched_getscheduler(0);
3467 struct sched_param origSchedParam;
3468
3469 int errorInPriorityModification = sched_getparam(0, &origSchedParam);
3470 if (errorInPriorityModification == 0) {
3471 int policy = SCHED_FIFO;
3472 newPriority = sched_get_priority_min(policy);
3473
3474 struct sched_param param;
3475 param.sched_priority = newPriority;
3476
3477 errorInPriorityModification = sched_setscheduler(0, policy, ¶m);
3478 }
3479
3480 // start the thread pool
3481 android::ProcessState::self()->startThreadPool();
3482
3483 // Reset current thread's policy and priority
3484 if (errorInPriorityModification == 0) {
3485 errorInPriorityModification = sched_setscheduler(0, origPolicy, &origSchedParam);
3486 } else {
3487 ALOGE("Failed to set VtsHalGraphicsComposer3_TargetTest binder threadpool priority to "
3488 "SCHED_FIFO");
3489 }
3490
3491 return RUN_ALL_TESTS();
3492 }
3493