1 /*
2 * Copyright (C) 2016 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 #define LOG_TAG "graphics_composer_hidl_hal_test"
18
19 #include <android-base/logging.h>
20 #include <android-base/properties.h>
21 #include <composer-vts/2.1/ComposerVts.h>
22 #include <composer-vts/2.1/GraphicsComposerCallback.h>
23 #include <composer-vts/2.1/TestCommandReader.h>
24 #include <gtest/gtest.h>
25 #include <hardware/hwcomposer2.h>
26 #include <hidl/GtestPrinter.h>
27 #include <hidl/ServiceManagement.h>
28 #include <mapper-vts/2.0/MapperVts.h>
29 #include <mapper-vts/3.0/MapperVts.h>
30 #include <mapper-vts/4.0/MapperVts.h>
31
32 #include <unistd.h>
33
34 #include <algorithm>
35 #include <array>
36 #include <memory>
37 #include <mutex>
38 #include <unordered_set>
39 #include <vector>
40
41 namespace android {
42 namespace hardware {
43 namespace graphics {
44 namespace composer {
45 namespace V2_1 {
46 namespace vts {
47 namespace {
48
49 using android::hardware::graphics::common::V1_0::BufferUsage;
50 using android::hardware::graphics::common::V1_0::ColorMode;
51 using android::hardware::graphics::common::V1_0::ColorTransform;
52 using android::hardware::graphics::common::V1_0::Dataspace;
53 using android::hardware::graphics::common::V1_0::PixelFormat;
54 using android::hardware::graphics::common::V1_0::Transform;
55 using GrallocError = android::hardware::graphics::mapper::V2_0::Error;
56
57 class GraphicsComposerHidlTest : public ::testing::TestWithParam<std::string> {
58 protected:
SetUp()59 void SetUp() override {
60 ASSERT_NO_FATAL_FAILURE(
61 mComposer = std::make_unique<Composer>(IComposer::getService(GetParam())));
62 ASSERT_NO_FATAL_FAILURE(mComposerClient = mComposer->createClient());
63
64 mComposerCallback = new GraphicsComposerCallback;
65 mComposerClient->registerCallback(mComposerCallback);
66
67 // assume the first display is primary and is never removed
68 mPrimaryDisplay = waitForFirstDisplay();
69
70 // explicitly disable vsync
71 mComposerClient->setVsyncEnabled(mPrimaryDisplay, false);
72 mComposerCallback->setVsyncAllowed(false);
73
74 mInvalidDisplayId = GetInvalidDisplayId();
75
76 // Although 0 could be an invalid display, a return value of 0
77 // from GetInvalidDisplayId means all other ids are in use, a condition which
78 // we are assuming a device will never have
79 ASSERT_NE(0, mInvalidDisplayId);
80 }
81
TearDown()82 void TearDown() override {
83 if (mComposerCallback != nullptr) {
84 EXPECT_EQ(0, mComposerCallback->getInvalidHotplugCount());
85 EXPECT_EQ(0, mComposerCallback->getInvalidRefreshCount());
86 EXPECT_EQ(0, mComposerCallback->getInvalidVsyncCount());
87 }
88 }
89
90 // returns an invalid display id (one that has not been registered to a
91 // display. Currently assuming that a device will never have close to
92 // std::numeric_limit<uint64_t>::max() displays registered while running tests
GetInvalidDisplayId()93 Display GetInvalidDisplayId() {
94 std::vector<Display> validDisplays = mComposerCallback->getDisplays();
95
96 uint64_t id = std::numeric_limits<uint64_t>::max();
97 while (id > 0) {
98 if (std::find(validDisplays.begin(), validDisplays.end(), id) == validDisplays.end()) {
99 return id;
100 }
101 id--;
102 }
103
104 return 0;
105 }
106
107 // use the slot count usually set by SF
108 static constexpr uint32_t kBufferSlotCount = 64;
109
110 std::unique_ptr<Composer> mComposer;
111 std::unique_ptr<ComposerClient> mComposerClient;
112 sp<GraphicsComposerCallback> mComposerCallback;
113 // the first display and is assumed never to be removed
114 Display mPrimaryDisplay;
115 Display mInvalidDisplayId;
116
117 private:
waitForFirstDisplay()118 Display waitForFirstDisplay() {
119 while (true) {
120 std::vector<Display> displays = mComposerCallback->getDisplays();
121 if (displays.empty()) {
122 usleep(5 * 1000);
123 continue;
124 }
125
126 return displays[0];
127 }
128 }
129 };
130
131 /**
132 * Test IComposer::getCapabilities.
133 *
134 * Test that IComposer::getCapabilities returns no invalid capabilities.
135 */
TEST_P(GraphicsComposerHidlTest,GetCapabilities)136 TEST_P(GraphicsComposerHidlTest, GetCapabilities) {
137 auto capabilities = mComposer->getCapabilities();
138 ASSERT_EQ(capabilities.end(),
139 std::find(capabilities.begin(), capabilities.end(), IComposer::Capability::INVALID));
140 }
141
142 /**
143 * Test IComposer::dumpDebugInfo.
144 */
TEST_P(GraphicsComposerHidlTest,DumpDebugInfo)145 TEST_P(GraphicsComposerHidlTest, DumpDebugInfo) {
146 mComposer->dumpDebugInfo();
147 }
148
149 /**
150 * Test IComposer::createClient.
151 *
152 * Test that IComposerClient is a singleton.
153 */
TEST_P(GraphicsComposerHidlTest,CreateClientSingleton)154 TEST_P(GraphicsComposerHidlTest, CreateClientSingleton) {
155 mComposer->getRaw()->createClient(
156 [&](const auto& tmpError, const auto&) { EXPECT_EQ(Error::NO_RESOURCES, tmpError); });
157 }
158
159 /**
160 * Test IComposerClient::createVirtualDisplay and
161 * IComposerClient::destroyVirtualDisplay.
162 *
163 * Test that virtual displays can be created and has the correct display type.
164 */
TEST_P(GraphicsComposerHidlTest,CreateVirtualDisplay)165 TEST_P(GraphicsComposerHidlTest, CreateVirtualDisplay) {
166 if (mComposerClient->getMaxVirtualDisplayCount() == 0) {
167 GTEST_SUCCEED() << "no virtual display support";
168 return;
169 }
170
171 Display display;
172 PixelFormat format;
173 ASSERT_NO_FATAL_FAILURE(
174 display = mComposerClient->createVirtualDisplay(64, 64, PixelFormat::IMPLEMENTATION_DEFINED,
175 kBufferSlotCount, &format));
176
177 // test display type
178 IComposerClient::DisplayType type = mComposerClient->getDisplayType(display);
179 EXPECT_EQ(IComposerClient::DisplayType::VIRTUAL, type);
180
181 mComposerClient->destroyVirtualDisplay(display);
182 }
183
184 /**
185 * Test IComposerClient::destroyVirtualDisplay
186 *
187 * Test that passing a bad display handle to destroyVirtualDisplay
188 * returns a BAD_DISPLAY error
189 */
TEST_P(GraphicsComposerHidlTest,DestroyVirtualDisplayBadDisplay)190 TEST_P(GraphicsComposerHidlTest, DestroyVirtualDisplayBadDisplay) {
191 if (mComposerClient->getMaxVirtualDisplayCount() == 0) {
192 GTEST_SUCCEED() << "no virtual display support";
193 return;
194 }
195
196 Error error = mComposerClient->getRaw()->destroyVirtualDisplay(mInvalidDisplayId);
197 ASSERT_EQ(Error::BAD_DISPLAY, error);
198 }
199
200 /**
201 * Test IComposerClient::createLayer and IComposerClient::destroyLayer.
202 *
203 * Test that layers can be created and destroyed.
204 */
TEST_P(GraphicsComposerHidlTest,CreateLayer)205 TEST_P(GraphicsComposerHidlTest, CreateLayer) {
206 Layer layer;
207 ASSERT_NO_FATAL_FAILURE(layer =
208 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
209
210 mComposerClient->destroyLayer(mPrimaryDisplay, layer);
211 }
212
213 /**
214 * Test IComposerClient::createLayer
215 *
216 * Test that passing in an invalid display handle to createLayer returns
217 * BAD_DISPLAY.
218 */
TEST_P(GraphicsComposerHidlTest,CreateLayerBadDisplay)219 TEST_P(GraphicsComposerHidlTest, CreateLayerBadDisplay) {
220 Error error;
221 mComposerClient->getRaw()->createLayer(
222 mInvalidDisplayId, kBufferSlotCount,
223 [&](const auto& tmpOutError, const auto&) { error = tmpOutError; });
224 ASSERT_EQ(Error::BAD_DISPLAY, error);
225 }
226
227 /**
228 * Test IComposerClient::destroyLayer
229 *
230 * Test that passing in an invalid display handle to destroyLayer returns
231 * BAD_DISPLAY
232 */
TEST_P(GraphicsComposerHidlTest,DestroyLayerBadDisplay)233 TEST_P(GraphicsComposerHidlTest, DestroyLayerBadDisplay) {
234 Error error;
235 Layer layer;
236 ASSERT_NO_FATAL_FAILURE(layer =
237 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
238
239 error = mComposerClient->getRaw()->destroyLayer(mInvalidDisplayId, layer);
240
241 EXPECT_EQ(Error::BAD_DISPLAY, error);
242
243 ASSERT_NO_FATAL_FAILURE(mComposerClient->destroyLayer(mPrimaryDisplay, layer));
244 }
245
246 /**
247 * Test IComposerClient::destroyLayer
248 *
249 * Test that passing in an invalid layer handle to destroyLayer returns
250 * BAD_LAYER
251 */
TEST_P(GraphicsComposerHidlTest,DestroyLayerBadLayerError)252 TEST_P(GraphicsComposerHidlTest, DestroyLayerBadLayerError) {
253 // We haven't created any layers yet, so any id should be invalid
254 Error error = mComposerClient->getRaw()->destroyLayer(mPrimaryDisplay, 1);
255
256 EXPECT_EQ(Error::BAD_LAYER, error);
257 }
258
259 /**
260 * Test IComposerClient::getActiveConfig
261 *
262 * Test that passing in a bad display handle to getActiveConfig generates a
263 * BAD_DISPLAY error
264 */
TEST_P(GraphicsComposerHidlTest,GetActiveConfigBadDisplay)265 TEST_P(GraphicsComposerHidlTest, GetActiveConfigBadDisplay) {
266 Error error;
267 mComposerClient->getRaw()->getActiveConfig(
268 mInvalidDisplayId, [&](const auto& tmpOutError, const auto&) { error = tmpOutError; });
269 ASSERT_EQ(Error::BAD_DISPLAY, error);
270 }
271
272 /**
273 * Test IComposerClient::getDisplayConfigs
274 *
275 * Test IComposerClient::getDisplayConfigs returns no error
276 * when passed in a valid display
277 */
TEST_P(GraphicsComposerHidlTest,GetDisplayConfig)278 TEST_P(GraphicsComposerHidlTest, GetDisplayConfig) {
279 std::vector<Config> configs;
280 ASSERT_NO_FATAL_FAILURE(configs = mComposerClient->getDisplayConfigs(mPrimaryDisplay));
281 }
282
283 /**
284 * Test IComposerClient::getDisplayConfigs
285 *
286 * Test IComposerClient::getDisplayConfigs returns BAD_DISPLAY
287 * when passed in an invalid display handle
288 */
TEST_P(GraphicsComposerHidlTest,GetDisplayConfigBadDisplay)289 TEST_P(GraphicsComposerHidlTest, GetDisplayConfigBadDisplay) {
290 Error error;
291 mComposerClient->getRaw()->getDisplayConfigs(
292 mInvalidDisplayId, [&](const auto& tmpOutError, const auto&) { error = tmpOutError; });
293 ASSERT_EQ(Error::BAD_DISPLAY, error);
294 }
295
296 /**
297 * Test IComposerClient::getDisplayName.
298 */
TEST_P(GraphicsComposerHidlTest,GetDisplayName)299 TEST_P(GraphicsComposerHidlTest, GetDisplayName) {
300 mComposerClient->getDisplayName(mPrimaryDisplay);
301 }
302
303 /**
304 * Test IComposerClient::getDisplayType.
305 *
306 * Test that IComposerClient::getDisplayType returns the correct display type
307 * for the primary display.
308 */
TEST_P(GraphicsComposerHidlTest,GetDisplayType)309 TEST_P(GraphicsComposerHidlTest, GetDisplayType) {
310 ASSERT_EQ(IComposerClient::DisplayType::PHYSICAL,
311 mComposerClient->getDisplayType(mPrimaryDisplay));
312 }
313
314 /**
315 * Test IComposerClient::getClientTargetSupport.
316 *
317 * Test that IComposerClient::getClientTargetSupport returns true for the
318 * required client targets.
319 */
TEST_P(GraphicsComposerHidlTest,GetClientTargetSupport)320 TEST_P(GraphicsComposerHidlTest, GetClientTargetSupport) {
321 std::vector<Config> configs = mComposerClient->getDisplayConfigs(mPrimaryDisplay);
322 for (auto config : configs) {
323 int32_t width = mComposerClient->getDisplayAttribute(mPrimaryDisplay, config,
324 IComposerClient::Attribute::WIDTH);
325 int32_t height = mComposerClient->getDisplayAttribute(mPrimaryDisplay, config,
326 IComposerClient::Attribute::HEIGHT);
327 ASSERT_LT(0, width);
328 ASSERT_LT(0, height);
329
330 mComposerClient->setActiveConfig(mPrimaryDisplay, config);
331
332 ASSERT_TRUE(mComposerClient->getClientTargetSupport(
333 mPrimaryDisplay, width, height, PixelFormat::RGBA_8888, Dataspace::UNKNOWN));
334 }
335 }
336
337 /**
338 * Test IComposerClient::getClientTargetSupport
339 *
340 * Test that IComposerClient::getClientTargetSupport returns BAD_DISPLAY when
341 * passed an invalid display handle
342 */
TEST_P(GraphicsComposerHidlTest,GetClientTargetSupportBadDisplay)343 TEST_P(GraphicsComposerHidlTest, GetClientTargetSupportBadDisplay) {
344 std::vector<Config> configs = mComposerClient->getDisplayConfigs(mPrimaryDisplay);
345 for (auto config : configs) {
346 int32_t width = mComposerClient->getDisplayAttribute(mPrimaryDisplay, config,
347 IComposerClient::Attribute::WIDTH);
348 int32_t height = mComposerClient->getDisplayAttribute(mPrimaryDisplay, config,
349 IComposerClient::Attribute::HEIGHT);
350 ASSERT_LT(0, width);
351 ASSERT_LT(0, height);
352
353 mComposerClient->setActiveConfig(mPrimaryDisplay, config);
354
355 Error error = mComposerClient->getRaw()->getClientTargetSupport(
356 mInvalidDisplayId, width, height, PixelFormat::RGBA_8888, Dataspace::UNKNOWN);
357 EXPECT_EQ(Error::BAD_DISPLAY, error);
358 }
359 }
360
361 /**
362 * Test IComposerClient::getDisplayAttribute.
363 *
364 * Test that IComposerClient::getDisplayAttribute succeeds for the required
365 * formats, and succeeds or fails correctly for optional attributes.
366 */
TEST_P(GraphicsComposerHidlTest,GetDisplayAttribute)367 TEST_P(GraphicsComposerHidlTest, GetDisplayAttribute) {
368 std::vector<Config> configs = mComposerClient->getDisplayConfigs(mPrimaryDisplay);
369 for (auto config : configs) {
370 const std::array<IComposerClient::Attribute, 3> requiredAttributes = {{
371 IComposerClient::Attribute::WIDTH, IComposerClient::Attribute::HEIGHT,
372 IComposerClient::Attribute::VSYNC_PERIOD,
373 }};
374 for (auto attribute : requiredAttributes) {
375 mComposerClient->getDisplayAttribute(mPrimaryDisplay, config, attribute);
376 }
377
378 const std::array<IComposerClient::Attribute, 2> optionalAttributes = {{
379 IComposerClient::Attribute::DPI_X, IComposerClient::Attribute::DPI_Y,
380 }};
381 for (auto attribute : optionalAttributes) {
382 mComposerClient->getRaw()->getDisplayAttribute(
383 mPrimaryDisplay, config, attribute, [&](const auto& tmpError, const auto&) {
384 EXPECT_TRUE(tmpError == Error::NONE || tmpError == Error::UNSUPPORTED);
385 });
386 }
387 }
388 }
389
390 /**
391 * Test IComposerClient::getHdrCapabilities.
392 */
TEST_P(GraphicsComposerHidlTest,GetHdrCapabilities)393 TEST_P(GraphicsComposerHidlTest, GetHdrCapabilities) {
394 float maxLuminance;
395 float maxAverageLuminance;
396 float minLuminance;
397 mComposerClient->getHdrCapabilities(mPrimaryDisplay, &maxLuminance, &maxAverageLuminance,
398 &minLuminance);
399 }
400
401 /**
402 * Test IComposerClient::setClientTargetSlotCount.
403 */
TEST_P(GraphicsComposerHidlTest,SetClientTargetSlotCount)404 TEST_P(GraphicsComposerHidlTest, SetClientTargetSlotCount) {
405 mComposerClient->setClientTargetSlotCount(mPrimaryDisplay, kBufferSlotCount);
406 }
407
408 /**
409 * Test IComposerClient::setActiveConfig.
410 *
411 * Test that IComposerClient::setActiveConfig succeeds for all display
412 * configs.
413 */
TEST_P(GraphicsComposerHidlTest,SetActiveConfig)414 TEST_P(GraphicsComposerHidlTest, SetActiveConfig) {
415 std::vector<Config> configs = mComposerClient->getDisplayConfigs(mPrimaryDisplay);
416 for (auto config : configs) {
417 mComposerClient->setActiveConfig(mPrimaryDisplay, config);
418 ASSERT_EQ(config, mComposerClient->getActiveConfig(mPrimaryDisplay));
419 }
420 }
421
422 /**
423 * Test IComposerClient::setActiveConfig
424 *
425 * Test that config set during IComposerClient::setActiveConfig is maintained
426 * during a display on/off power cycle
427 */
TEST_P(GraphicsComposerHidlTest,SetActiveConfigPowerCycle)428 TEST_P(GraphicsComposerHidlTest, SetActiveConfigPowerCycle) {
429 ASSERT_NO_FATAL_FAILURE(
430 mComposerClient->setPowerMode(mPrimaryDisplay, IComposerClient::PowerMode::OFF));
431 ASSERT_NO_FATAL_FAILURE(
432 mComposerClient->setPowerMode(mPrimaryDisplay, IComposerClient::PowerMode::ON));
433
434 std::vector<Config> configs = mComposerClient->getDisplayConfigs(mPrimaryDisplay);
435 for (auto config : configs) {
436 mComposerClient->setActiveConfig(mPrimaryDisplay, config);
437 ASSERT_EQ(config, mComposerClient->getActiveConfig(mPrimaryDisplay));
438
439 ASSERT_NO_FATAL_FAILURE(
440 mComposerClient->setPowerMode(mPrimaryDisplay, IComposerClient::PowerMode::OFF));
441 ASSERT_NO_FATAL_FAILURE(
442 mComposerClient->setPowerMode(mPrimaryDisplay, IComposerClient::PowerMode::ON));
443 ASSERT_EQ(config, mComposerClient->getActiveConfig(mPrimaryDisplay));
444 }
445 }
446
447 /**
448 * Test IComposerClient::getColorMode
449 *
450 * Test that IComposerClient::getColorMode always returns ColorMode::NATIVE
451 */
TEST_P(GraphicsComposerHidlTest,GetColorModes)452 TEST_P(GraphicsComposerHidlTest, GetColorModes) {
453 std::vector<ColorMode> modes = mComposerClient->getColorModes(mPrimaryDisplay);
454 auto nativeModeLocation = std::find(modes.begin(), modes.end(), ColorMode::NATIVE);
455
456 ASSERT_NE(modes.end(), nativeModeLocation);
457 }
458
459 /**
460 * Test IComposerClient::setColorMode.
461 *
462 * Test that IComposerClient::setColorMode succeeds for all color modes.
463 */
TEST_P(GraphicsComposerHidlTest,SetColorMode)464 TEST_P(GraphicsComposerHidlTest, SetColorMode) {
465 std::unordered_set<ColorMode> validModes;
466 for (auto mode : hidl_enum_range<ColorMode>()) {
467 validModes.insert(mode);
468 }
469
470 std::vector<ColorMode> modes = mComposerClient->getColorModes(mPrimaryDisplay);
471 for (auto mode : modes) {
472 if (validModes.count(mode)) {
473 mComposerClient->setColorMode(mPrimaryDisplay, mode);
474 }
475 }
476 }
477
478 /**
479 * Test IComposerClient::setColorMode
480 *
481 * Test that IComposerClient::setColorMode returns BAD_DISPLAY for
482 * an invalid display handle
483 */
TEST_P(GraphicsComposerHidlTest,SetColorModeBadDisplay)484 TEST_P(GraphicsComposerHidlTest, SetColorModeBadDisplay) {
485 std::vector<ColorMode> modes = mComposerClient->getColorModes(mPrimaryDisplay);
486 for (auto mode : modes) {
487 Error error = mComposerClient->getRaw()->setColorMode(mInvalidDisplayId, mode);
488 EXPECT_EQ(Error::BAD_DISPLAY, error);
489 }
490 }
491
492 /**
493 * Test IComposerClient::setColorMode
494 *
495 * Test that IComposerClient::setColorMode returns BAD_PARAMETER when passed in
496 * an invalid color mode
497 */
TEST_P(GraphicsComposerHidlTest,SetColorModeBadParameter)498 TEST_P(GraphicsComposerHidlTest, SetColorModeBadParameter) {
499 Error error =
500 mComposerClient->getRaw()->setColorMode(mPrimaryDisplay, static_cast<ColorMode>(-1));
501 ASSERT_EQ(Error::BAD_PARAMETER, error);
502 }
503
504 /**
505 * Test IComposerClient::getDozeSupport
506 *
507 * Test that IComposerClient::getDozeSupport returns
508 * BAD_DISPLAY when passed an invalid display handle
509 */
TEST_P(GraphicsComposerHidlTest,GetDozeSupportBadDisplay)510 TEST_P(GraphicsComposerHidlTest, GetDozeSupportBadDisplay) {
511 Error error;
512 mComposerClient->getRaw()->getDozeSupport(
513 mInvalidDisplayId, [&](const auto& tmpOutError, const auto&) { error = tmpOutError; });
514 ASSERT_EQ(Error::BAD_DISPLAY, error);
515 }
516
517 /**
518 * Test IComposerClient::setPowerMode.
519 *
520 * Test that IComposerClient::setPowerMode succeeds for all power modes.
521 */
TEST_P(GraphicsComposerHidlTest,SetPowerMode)522 TEST_P(GraphicsComposerHidlTest, SetPowerMode) {
523 std::vector<IComposerClient::PowerMode> modes;
524 modes.push_back(IComposerClient::PowerMode::OFF);
525
526 if (mComposerClient->getDozeSupport(mPrimaryDisplay)) {
527 modes.push_back(IComposerClient::PowerMode::DOZE);
528 modes.push_back(IComposerClient::PowerMode::DOZE_SUSPEND);
529 }
530
531 // push ON last
532 modes.push_back(IComposerClient::PowerMode::ON);
533
534 for (auto mode : modes) {
535 mComposerClient->setPowerMode(mPrimaryDisplay, mode);
536 }
537 }
538
539 /**
540 * Test IComposerClient::setPowerMode
541 *
542 * Test IComposerClient::setPowerMode succeeds with different
543 * orderings of power modes
544 */
TEST_P(GraphicsComposerHidlTest,SetPowerModeVariations)545 TEST_P(GraphicsComposerHidlTest, SetPowerModeVariations) {
546 std::vector<IComposerClient::PowerMode> modes;
547 modes.push_back(IComposerClient::PowerMode::OFF);
548 modes.push_back(IComposerClient::PowerMode::ON);
549 modes.push_back(IComposerClient::PowerMode::OFF);
550 for (auto mode : modes) {
551 ASSERT_NO_FATAL_FAILURE(mComposerClient->setPowerMode(mPrimaryDisplay, mode));
552 }
553
554 modes.clear();
555
556 modes.push_back(IComposerClient::PowerMode::OFF);
557 modes.push_back(IComposerClient::PowerMode::OFF);
558 for (auto mode : modes) {
559 ASSERT_NO_FATAL_FAILURE(mComposerClient->setPowerMode(mPrimaryDisplay, mode));
560 }
561
562 modes.clear();
563 if (mComposerClient->getDozeSupport(mPrimaryDisplay)) {
564 modes.push_back(IComposerClient::PowerMode::DOZE);
565 modes.push_back(IComposerClient::PowerMode::DOZE);
566
567 for (auto mode : modes) {
568 ASSERT_NO_FATAL_FAILURE(mComposerClient->setPowerMode(mPrimaryDisplay, mode));
569 }
570
571 modes.clear();
572
573 modes.push_back(IComposerClient::PowerMode::DOZE_SUSPEND);
574 modes.push_back(IComposerClient::PowerMode::DOZE_SUSPEND);
575
576 for (auto mode : modes) {
577 ASSERT_NO_FATAL_FAILURE(mComposerClient->setPowerMode(mPrimaryDisplay, mode));
578 }
579 }
580
581 modes.clear();
582
583 modes.push_back(IComposerClient::PowerMode::ON);
584 modes.push_back(IComposerClient::PowerMode::ON);
585 for (auto mode : modes) {
586 ASSERT_NO_FATAL_FAILURE(mComposerClient->setPowerMode(mPrimaryDisplay, mode));
587 }
588 }
589
590 /**
591 * Test IComposerClient::setPowerMode
592 *
593 * Test IComposerClient::setPowerMode returns BAD_DISPLAY when passed an invalid
594 * display handle
595 */
TEST_P(GraphicsComposerHidlTest,SetPowerModeBadDisplay)596 TEST_P(GraphicsComposerHidlTest, SetPowerModeBadDisplay) {
597 Error error =
598 mComposerClient->getRaw()->setPowerMode(mInvalidDisplayId, IComposerClient::PowerMode::ON);
599 ASSERT_EQ(Error::BAD_DISPLAY, error);
600 }
601
602 /**
603 * Test IComposerClient::setPowerMode
604 *
605 * Test that IComposerClient::setPowerMode returns UNSUPPORTED when passed DOZE
606 * or DOZE_SUSPEND on devices that do not support DOZE/DOZE_SUSPEND
607 */
TEST_P(GraphicsComposerHidlTest,SetPowerModeUnsupported)608 TEST_P(GraphicsComposerHidlTest, SetPowerModeUnsupported) {
609 if (!mComposerClient->getDozeSupport(mPrimaryDisplay)) {
610 Error error = mComposerClient->getRaw()->setPowerMode(mPrimaryDisplay,
611 IComposerClient::PowerMode::DOZE);
612 EXPECT_EQ(Error::UNSUPPORTED, error);
613
614 error = mComposerClient->getRaw()->setPowerMode(mPrimaryDisplay,
615 IComposerClient::PowerMode::DOZE_SUSPEND);
616 EXPECT_EQ(Error::UNSUPPORTED, error);
617 }
618 }
619
620 /**
621 * Test IComposerClient::setPowerMode
622 *
623 * Tests that IComposerClient::setPowerMode returns BAD_PARAMETER when passed an invalid
624 * PowerMode
625 */
TEST_P(GraphicsComposerHidlTest,SetPowerModeBadParameter)626 TEST_P(GraphicsComposerHidlTest, SetPowerModeBadParameter) {
627 Error error = mComposerClient->getRaw()->setPowerMode(
628 mPrimaryDisplay, static_cast<IComposerClient::PowerMode>(-1));
629 ASSERT_EQ(Error::BAD_PARAMETER, error);
630 }
631
632 /**
633 * Test IComposerClient::setVsyncEnabled.
634 *
635 * Test that IComposerClient::setVsyncEnabled succeeds and there is no
636 * spurious vsync events.
637 */
TEST_P(GraphicsComposerHidlTest,SetVsyncEnabled)638 TEST_P(GraphicsComposerHidlTest, SetVsyncEnabled) {
639 mComposerCallback->setVsyncAllowed(true);
640
641 mComposerClient->setVsyncEnabled(mPrimaryDisplay, true);
642 usleep(60 * 1000);
643 mComposerClient->setVsyncEnabled(mPrimaryDisplay, false);
644
645 mComposerCallback->setVsyncAllowed(false);
646 }
647
648 // Tests for IComposerClient::Command.
649 class GraphicsComposerHidlCommandTest : public GraphicsComposerHidlTest {
650 protected:
SetUp()651 void SetUp() override {
652 ASSERT_NO_FATAL_FAILURE(GraphicsComposerHidlTest::SetUp());
653
654 ASSERT_NO_FATAL_FAILURE(mGralloc = std::make_unique<Gralloc>());
655 Config activeConfig = mComposerClient->getActiveConfig(mPrimaryDisplay);
656 mDisplayWidth = mComposerClient->getDisplayAttribute(mPrimaryDisplay, activeConfig,
657 IComposerClient::Attribute::WIDTH);
658 mDisplayHeight = mComposerClient->getDisplayAttribute(mPrimaryDisplay, activeConfig,
659 IComposerClient::Attribute::HEIGHT);
660 mWriter = std::make_unique<CommandWriterBase>(1024);
661 mReader = std::make_unique<TestCommandReader>();
662 }
663
TearDown()664 void TearDown() override {
665 ASSERT_EQ(0, mReader->mErrors.size());
666 ASSERT_NO_FATAL_FAILURE(GraphicsComposerHidlTest::TearDown());
667 }
668
allocate()669 NativeHandleWrapper allocate() { return allocate(mDisplayWidth, mDisplayHeight); }
670
allocate(uint32_t width,uint32_t height)671 NativeHandleWrapper allocate(uint32_t width, uint32_t height) {
672 uint64_t usage =
673 static_cast<uint64_t>(BufferUsage::CPU_WRITE_OFTEN | BufferUsage::CPU_READ_OFTEN |
674 BufferUsage::COMPOSER_OVERLAY);
675 return mGralloc->allocate(width, height, 1, PixelFormat::RGBA_8888, usage);
676 }
677
execute()678 void execute() { mComposerClient->execute(mReader.get(), mWriter.get()); }
679
680 std::unique_ptr<CommandWriterBase> mWriter;
681 std::unique_ptr<TestCommandReader> mReader;
682 int32_t mDisplayWidth;
683 int32_t mDisplayHeight;
684
685 private:
686 std::unique_ptr<Gralloc> mGralloc;
687 };
688
689 /**
690 * Test IComposerClient::Command::SET_COLOR_TRANSFORM.
691 */
TEST_P(GraphicsComposerHidlCommandTest,SET_COLOR_TRANSFORM)692 TEST_P(GraphicsComposerHidlCommandTest, SET_COLOR_TRANSFORM) {
693 const std::array<float, 16> identity = {{
694 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f,
695 1.0f,
696 }};
697
698 mWriter->selectDisplay(mPrimaryDisplay);
699 mWriter->setColorTransform(identity.data(), ColorTransform::IDENTITY);
700
701 execute();
702 }
703
704 /**
705 * Test IComposerClient::Command::SET_CLIENT_TARGET.
706 */
TEST_P(GraphicsComposerHidlCommandTest,SET_CLIENT_TARGET)707 TEST_P(GraphicsComposerHidlCommandTest, SET_CLIENT_TARGET) {
708 mComposerClient->setClientTargetSlotCount(mPrimaryDisplay, kBufferSlotCount);
709
710 mWriter->selectDisplay(mPrimaryDisplay);
711 mWriter->setClientTarget(0, nullptr, -1, Dataspace::UNKNOWN,
712 std::vector<IComposerClient::Rect>());
713
714 execute();
715 }
716
717 /**
718 * Test IComposerClient::Command::SET_OUTPUT_BUFFER.
719 */
TEST_P(GraphicsComposerHidlCommandTest,SET_OUTPUT_BUFFER)720 TEST_P(GraphicsComposerHidlCommandTest, SET_OUTPUT_BUFFER) {
721 if (mComposerClient->getMaxVirtualDisplayCount() == 0) {
722 GTEST_SUCCEED() << "no virtual display support";
723 return;
724 }
725
726 Display display;
727 PixelFormat format;
728 ASSERT_NO_FATAL_FAILURE(
729 display = mComposerClient->createVirtualDisplay(64, 64, PixelFormat::IMPLEMENTATION_DEFINED,
730 kBufferSlotCount, &format));
731
732 std::unique_ptr<NativeHandleWrapper> handle;
733 ASSERT_NO_FATAL_FAILURE(handle.reset(new NativeHandleWrapper(allocate())));
734
735 mWriter->selectDisplay(display);
736 mWriter->setOutputBuffer(0, handle->get(), -1);
737 execute();
738 }
739
740 /**
741 * Test IComposerClient::Command::VALIDATE_DISPLAY.
742 */
TEST_P(GraphicsComposerHidlCommandTest,VALIDATE_DISPLAY)743 TEST_P(GraphicsComposerHidlCommandTest, VALIDATE_DISPLAY) {
744 mWriter->selectDisplay(mPrimaryDisplay);
745 mWriter->validateDisplay();
746 execute();
747 }
748
749 /**
750 * Test IComposerClient::Command::ACCEPT_DISPLAY_CHANGES.
751 */
TEST_P(GraphicsComposerHidlCommandTest,ACCEPT_DISPLAY_CHANGES)752 TEST_P(GraphicsComposerHidlCommandTest, ACCEPT_DISPLAY_CHANGES) {
753 mWriter->selectDisplay(mPrimaryDisplay);
754 mWriter->validateDisplay();
755 mWriter->acceptDisplayChanges();
756 execute();
757 }
758
759 /**
760 * Test IComposerClient::Command::PRESENT_DISPLAY.
761 */
TEST_P(GraphicsComposerHidlCommandTest,PRESENT_DISPLAY)762 TEST_P(GraphicsComposerHidlCommandTest, PRESENT_DISPLAY) {
763 mWriter->selectDisplay(mPrimaryDisplay);
764 mWriter->validateDisplay();
765 mWriter->presentDisplay();
766 execute();
767 }
768
769 /**
770 * Test IComposerClient::Command::PRESENT_DISPLAY
771 *
772 * Test that IComposerClient::Command::PRESENT_DISPLAY works without
773 * additional call to validateDisplay when only the layer buffer handle and
774 * surface damage have been set
775 */
TEST_P(GraphicsComposerHidlCommandTest,PRESENT_DISPLAY_NO_LAYER_STATE_CHANGES)776 TEST_P(GraphicsComposerHidlCommandTest, PRESENT_DISPLAY_NO_LAYER_STATE_CHANGES) {
777 if (!mComposer->hasCapability(
778 static_cast<IComposer::Capability>(HWC2_CAPABILITY_SKIP_VALIDATE))) {
779 std::cout << "Device does not have skip validate capability, skipping" << std::endl;
780 GTEST_SUCCEED();
781 return;
782 }
783 mWriter->selectDisplay(mPrimaryDisplay);
784 mComposerClient->setPowerMode(mPrimaryDisplay, IComposerClient::PowerMode::ON);
785 mComposerClient->setColorMode(mPrimaryDisplay, ColorMode::NATIVE);
786
787 auto handle = allocate();
788 ASSERT_NE(nullptr, handle.get());
789
790 IComposerClient::Rect displayFrame{0, 0, mDisplayWidth, mDisplayHeight};
791
792 Layer layer;
793 ASSERT_NO_FATAL_FAILURE(layer =
794 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
795 mWriter->selectLayer(layer);
796 mWriter->setLayerCompositionType(IComposerClient::Composition::DEVICE);
797 mWriter->setLayerDisplayFrame(displayFrame);
798 mWriter->setLayerPlaneAlpha(1);
799 mWriter->setLayerSourceCrop({0, 0, (float)mDisplayWidth, (float)mDisplayHeight});
800 mWriter->setLayerTransform(static_cast<Transform>(0));
801 mWriter->setLayerVisibleRegion(std::vector<IComposerClient::Rect>(1, displayFrame));
802 mWriter->setLayerZOrder(10);
803 mWriter->setLayerBlendMode(IComposerClient::BlendMode::NONE);
804 mWriter->setLayerSurfaceDamage(std::vector<IComposerClient::Rect>(1, displayFrame));
805 mWriter->setLayerBuffer(0, handle.get(), -1);
806 mWriter->setLayerDataspace(Dataspace::UNKNOWN);
807
808 mWriter->validateDisplay();
809 execute();
810 if (mReader->mCompositionChanges.size() != 0) {
811 GTEST_SUCCEED() << "Composition change requested, skipping test";
812 return;
813 }
814
815 ASSERT_EQ(0, mReader->mErrors.size());
816 mWriter->presentDisplay();
817 execute();
818 ASSERT_EQ(0, mReader->mErrors.size());
819
820 mWriter->selectLayer(layer);
821 auto handle2 = allocate();
822 ASSERT_NE(nullptr, handle2.get());
823 mWriter->setLayerBuffer(0, handle2.get(), -1);
824 mWriter->setLayerSurfaceDamage(std::vector<IComposerClient::Rect>(1, {0, 0, 10, 10}));
825 mWriter->presentDisplay();
826 execute();
827 }
828
829 /**
830 * Test IComposerClient::Command::SET_LAYER_CURSOR_POSITION.
831 */
TEST_P(GraphicsComposerHidlCommandTest,SET_LAYER_CURSOR_POSITION)832 TEST_P(GraphicsComposerHidlCommandTest, SET_LAYER_CURSOR_POSITION) {
833 Layer layer;
834 ASSERT_NO_FATAL_FAILURE(layer =
835 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
836
837 auto handle = allocate();
838 ASSERT_NE(nullptr, handle.get());
839 IComposerClient::Rect displayFrame{0, 0, mDisplayWidth, mDisplayHeight};
840
841 mWriter->selectDisplay(mPrimaryDisplay);
842 mWriter->selectLayer(layer);
843 mWriter->setLayerBuffer(0, handle.get(), -1);
844 mWriter->setLayerCompositionType(IComposerClient::Composition::CURSOR);
845 mWriter->setLayerDisplayFrame(displayFrame);
846 mWriter->setLayerPlaneAlpha(1);
847 mWriter->setLayerSourceCrop({0, 0, (float)mDisplayWidth, (float)mDisplayHeight});
848 mWriter->setLayerTransform(static_cast<Transform>(0));
849 mWriter->setLayerVisibleRegion(std::vector<IComposerClient::Rect>(1, displayFrame));
850 mWriter->setLayerZOrder(10);
851 mWriter->setLayerBlendMode(IComposerClient::BlendMode::NONE);
852 mWriter->setLayerSurfaceDamage(std::vector<IComposerClient::Rect>(1, displayFrame));
853 mWriter->setLayerDataspace(Dataspace::UNKNOWN);
854 mWriter->validateDisplay();
855
856 execute();
857 if (mReader->mCompositionChanges.size() != 0) {
858 GTEST_SUCCEED() << "Composition change requested, skipping test";
859 return;
860 }
861 mWriter->presentDisplay();
862 ASSERT_EQ(0, mReader->mErrors.size());
863
864 mWriter->setLayerCursorPosition(1, 1);
865 mWriter->setLayerCursorPosition(0, 0);
866 mWriter->validateDisplay();
867 mWriter->presentDisplay();
868 execute();
869 }
870
871 /**
872 * Test IComposerClient::Command::SET_LAYER_BUFFER.
873 */
TEST_P(GraphicsComposerHidlCommandTest,SET_LAYER_BUFFER)874 TEST_P(GraphicsComposerHidlCommandTest, SET_LAYER_BUFFER) {
875 auto handle = allocate();
876 ASSERT_NE(nullptr, handle.get());
877
878 Layer layer;
879 ASSERT_NO_FATAL_FAILURE(layer =
880 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
881
882 mWriter->selectDisplay(mPrimaryDisplay);
883 mWriter->selectLayer(layer);
884 mWriter->setLayerBuffer(0, handle.get(), -1);
885 execute();
886 }
887
888 /**
889 * Test IComposerClient::Command::SET_LAYER_BUFFER with the behavior used for clearing buffer slots.
890 */
TEST_P(GraphicsComposerHidlCommandTest,SET_LAYER_BUFFER_multipleTimes)891 TEST_P(GraphicsComposerHidlCommandTest, SET_LAYER_BUFFER_multipleTimes) {
892 // A placeholder buffer used to clear buffer slots
893 auto clearSlotBuffer = allocate(1u, 1u);
894
895 //
896 // Set the layer buffer to the first buffer
897 //
898 auto handle1 = allocate();
899 ASSERT_NE(nullptr, handle1.get());
900 IComposerClient::Rect displayFrame{0, 0, mDisplayWidth, mDisplayHeight};
901 Layer layer;
902 ASSERT_NO_FATAL_FAILURE(
903 layer = mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
904 mWriter->selectDisplay(mPrimaryDisplay);
905 mWriter->selectLayer(layer);
906 mWriter->setLayerCompositionType(IComposerClient::Composition::DEVICE);
907 mWriter->setLayerDisplayFrame(displayFrame);
908 mWriter->setLayerBuffer(0, handle1.get(), -1);
909 mWriter->setLayerDataspace(Dataspace::UNKNOWN);
910 mWriter->validateDisplay();
911 execute();
912 if (mReader->mCompositionChanges.size() != 0) {
913 GTEST_SUCCEED() << "Composition change requested, skipping test";
914 return;
915 }
916 ASSERT_EQ(0, mReader->mErrors.size());
917 mWriter->selectDisplay(mPrimaryDisplay);
918 mWriter->presentDisplay();
919 execute();
920 ASSERT_EQ(0, mReader->mErrors.size());
921
922 //
923 // Set the layer buffer to the second buffer
924 //
925 auto handle2 = allocate();
926 ASSERT_NE(nullptr, handle2.get());
927 mWriter->selectDisplay(mPrimaryDisplay);
928 mWriter->selectLayer(layer);
929 mWriter->setLayerCompositionType(IComposerClient::Composition::DEVICE);
930 mWriter->setLayerDisplayFrame(displayFrame);
931 mWriter->setLayerBuffer(1, handle2.get(), -1);
932 mWriter->setLayerDataspace(Dataspace::UNKNOWN);
933 mWriter->validateDisplay();
934 execute();
935 if (mReader->mCompositionChanges.size() != 0) {
936 GTEST_SUCCEED() << "Composition change requested, skipping test";
937 return;
938 }
939 ASSERT_EQ(0, mReader->mErrors.size());
940 mWriter->selectDisplay(mPrimaryDisplay);
941 mWriter->presentDisplay();
942 execute();
943 ASSERT_EQ(0, mReader->mErrors.size());
944
945 //
946 // Set the layer buffer to the third buffer
947 //
948 auto handle3 = allocate();
949 ASSERT_NE(nullptr, handle3.get());
950 mWriter->selectDisplay(mPrimaryDisplay);
951 mWriter->selectLayer(layer);
952 mWriter->setLayerCompositionType(IComposerClient::Composition::DEVICE);
953 mWriter->setLayerDisplayFrame(displayFrame);
954 mWriter->setLayerBuffer(2, handle3.get(), -1);
955 mWriter->setLayerDataspace(Dataspace::UNKNOWN);
956 mWriter->validateDisplay();
957 execute();
958 if (mReader->mCompositionChanges.size() != 0) {
959 GTEST_SUCCEED() << "Composition change requested, skipping test";
960 return;
961 }
962 ASSERT_EQ(0, mReader->mErrors.size());
963 mWriter->selectDisplay(mPrimaryDisplay);
964 mWriter->presentDisplay();
965 execute();
966 ASSERT_EQ(0, mReader->mErrors.size());
967
968 // Ensure we can clear multiple buffer slots and then restore the active buffer at the end
969 mWriter->selectDisplay(mPrimaryDisplay);
970 mWriter->selectLayer(layer);
971 mWriter->setLayerBuffer(0, clearSlotBuffer.get(), -1);
972 mWriter->selectDisplay(mPrimaryDisplay);
973 mWriter->selectLayer(layer);
974 mWriter->setLayerBuffer(1, clearSlotBuffer.get(), -1);
975 mWriter->selectDisplay(mPrimaryDisplay);
976 mWriter->selectLayer(layer);
977 mWriter->setLayerBuffer(2, nullptr, -1);
978 mWriter->validateDisplay();
979 execute();
980 ASSERT_EQ(0, mReader->mErrors.size());
981
982 mWriter->selectDisplay(mPrimaryDisplay);
983 mWriter->presentDisplay();
984 execute();
985 ASSERT_EQ(0, mReader->mErrors.size());
986 }
987
988 /**
989 * Test IComposerClient::Command::SET_LAYER_SURFACE_DAMAGE.
990 */
TEST_P(GraphicsComposerHidlCommandTest,SET_LAYER_SURFACE_DAMAGE)991 TEST_P(GraphicsComposerHidlCommandTest, SET_LAYER_SURFACE_DAMAGE) {
992 Layer layer;
993 ASSERT_NO_FATAL_FAILURE(layer =
994 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
995
996 IComposerClient::Rect empty{0, 0, 0, 0};
997 IComposerClient::Rect unit{0, 0, 1, 1};
998
999 mWriter->selectDisplay(mPrimaryDisplay);
1000 mWriter->selectLayer(layer);
1001 mWriter->setLayerSurfaceDamage(std::vector<IComposerClient::Rect>(1, empty));
1002 mWriter->setLayerSurfaceDamage(std::vector<IComposerClient::Rect>(1, unit));
1003 mWriter->setLayerSurfaceDamage(std::vector<IComposerClient::Rect>());
1004 execute();
1005 }
1006
1007 /**
1008 * Test IComposerClient::Command::SET_LAYER_BLEND_MODE.
1009 */
TEST_P(GraphicsComposerHidlCommandTest,SET_LAYER_BLEND_MODE)1010 TEST_P(GraphicsComposerHidlCommandTest, SET_LAYER_BLEND_MODE) {
1011 Layer layer;
1012 ASSERT_NO_FATAL_FAILURE(layer =
1013 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
1014
1015 mWriter->selectDisplay(mPrimaryDisplay);
1016 mWriter->selectLayer(layer);
1017 mWriter->setLayerBlendMode(IComposerClient::BlendMode::NONE);
1018 mWriter->setLayerBlendMode(IComposerClient::BlendMode::PREMULTIPLIED);
1019 mWriter->setLayerBlendMode(IComposerClient::BlendMode::COVERAGE);
1020 execute();
1021 }
1022
1023 /**
1024 * Test IComposerClient::Command::SET_LAYER_COLOR.
1025 */
TEST_P(GraphicsComposerHidlCommandTest,SET_LAYER_COLOR)1026 TEST_P(GraphicsComposerHidlCommandTest, SET_LAYER_COLOR) {
1027 Layer layer;
1028 ASSERT_NO_FATAL_FAILURE(layer =
1029 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
1030
1031 mWriter->selectDisplay(mPrimaryDisplay);
1032 mWriter->selectLayer(layer);
1033 mWriter->setLayerColor(IComposerClient::Color{0xff, 0xff, 0xff, 0xff});
1034 mWriter->setLayerColor(IComposerClient::Color{0, 0, 0, 0});
1035 execute();
1036 }
1037
1038 /**
1039 * Test IComposerClient::Command::SET_LAYER_COMPOSITION_TYPE.
1040 */
TEST_P(GraphicsComposerHidlCommandTest,SET_LAYER_COMPOSITION_TYPE)1041 TEST_P(GraphicsComposerHidlCommandTest, SET_LAYER_COMPOSITION_TYPE) {
1042 Layer layer;
1043 ASSERT_NO_FATAL_FAILURE(layer =
1044 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
1045
1046 mWriter->selectDisplay(mPrimaryDisplay);
1047 mWriter->selectLayer(layer);
1048 mWriter->setLayerCompositionType(IComposerClient::Composition::CLIENT);
1049 mWriter->setLayerCompositionType(IComposerClient::Composition::DEVICE);
1050 mWriter->setLayerCompositionType(IComposerClient::Composition::SOLID_COLOR);
1051 mWriter->setLayerCompositionType(IComposerClient::Composition::CURSOR);
1052 execute();
1053 }
1054
1055 /**
1056 * Test IComposerClient::Command::SET_LAYER_DATASPACE.
1057 */
TEST_P(GraphicsComposerHidlCommandTest,SET_LAYER_DATASPACE)1058 TEST_P(GraphicsComposerHidlCommandTest, SET_LAYER_DATASPACE) {
1059 Layer layer;
1060 ASSERT_NO_FATAL_FAILURE(layer =
1061 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
1062
1063 mWriter->selectDisplay(mPrimaryDisplay);
1064 mWriter->selectLayer(layer);
1065 mWriter->setLayerDataspace(Dataspace::UNKNOWN);
1066 execute();
1067 }
1068
1069 /**
1070 * Test IComposerClient::Command::SET_LAYER_DISPLAY_FRAME.
1071 */
TEST_P(GraphicsComposerHidlCommandTest,SET_LAYER_DISPLAY_FRAME)1072 TEST_P(GraphicsComposerHidlCommandTest, SET_LAYER_DISPLAY_FRAME) {
1073 Layer layer;
1074 ASSERT_NO_FATAL_FAILURE(layer =
1075 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
1076
1077 mWriter->selectDisplay(mPrimaryDisplay);
1078 mWriter->selectLayer(layer);
1079 mWriter->setLayerDisplayFrame(IComposerClient::Rect{0, 0, 1, 1});
1080 execute();
1081 }
1082
1083 /**
1084 * Test IComposerClient::Command::SET_LAYER_PLANE_ALPHA.
1085 */
TEST_P(GraphicsComposerHidlCommandTest,SET_LAYER_PLANE_ALPHA)1086 TEST_P(GraphicsComposerHidlCommandTest, SET_LAYER_PLANE_ALPHA) {
1087 Layer layer;
1088 ASSERT_NO_FATAL_FAILURE(layer =
1089 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
1090
1091 mWriter->selectDisplay(mPrimaryDisplay);
1092 mWriter->selectLayer(layer);
1093 mWriter->setLayerPlaneAlpha(0.0f);
1094 mWriter->setLayerPlaneAlpha(1.0f);
1095 execute();
1096 }
1097
1098 /**
1099 * Test IComposerClient::Command::SET_LAYER_SIDEBAND_STREAM.
1100 */
TEST_P(GraphicsComposerHidlCommandTest,SET_LAYER_SIDEBAND_STREAM)1101 TEST_P(GraphicsComposerHidlCommandTest, SET_LAYER_SIDEBAND_STREAM) {
1102 if (!mComposer->hasCapability(IComposer::Capability::SIDEBAND_STREAM)) {
1103 GTEST_SUCCEED() << "no sideband stream support";
1104 return;
1105 }
1106
1107 auto handle = allocate();
1108 ASSERT_NE(nullptr, handle.get());
1109
1110 Layer layer;
1111 ASSERT_NO_FATAL_FAILURE(layer =
1112 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
1113
1114 mWriter->selectDisplay(mPrimaryDisplay);
1115 mWriter->selectLayer(layer);
1116 mWriter->setLayerSidebandStream(handle.get());
1117 execute();
1118 }
1119
1120 /**
1121 * Test IComposerClient::Command::SET_LAYER_SOURCE_CROP.
1122 */
TEST_P(GraphicsComposerHidlCommandTest,SET_LAYER_SOURCE_CROP)1123 TEST_P(GraphicsComposerHidlCommandTest, SET_LAYER_SOURCE_CROP) {
1124 Layer layer;
1125 ASSERT_NO_FATAL_FAILURE(layer =
1126 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
1127
1128 mWriter->selectDisplay(mPrimaryDisplay);
1129 mWriter->selectLayer(layer);
1130 mWriter->setLayerSourceCrop(IComposerClient::FRect{0.0f, 0.0f, 1.0f, 1.0f});
1131 execute();
1132 }
1133
1134 /**
1135 * Test IComposerClient::Command::SET_LAYER_TRANSFORM.
1136 */
TEST_P(GraphicsComposerHidlCommandTest,SET_LAYER_TRANSFORM)1137 TEST_P(GraphicsComposerHidlCommandTest, SET_LAYER_TRANSFORM) {
1138 Layer layer;
1139 ASSERT_NO_FATAL_FAILURE(layer =
1140 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
1141
1142 mWriter->selectDisplay(mPrimaryDisplay);
1143 mWriter->selectLayer(layer);
1144 mWriter->setLayerTransform(static_cast<Transform>(0));
1145 mWriter->setLayerTransform(Transform::FLIP_H);
1146 mWriter->setLayerTransform(Transform::FLIP_V);
1147 mWriter->setLayerTransform(Transform::ROT_90);
1148 mWriter->setLayerTransform(Transform::ROT_180);
1149 mWriter->setLayerTransform(Transform::ROT_270);
1150 mWriter->setLayerTransform(static_cast<Transform>(Transform::FLIP_H | Transform::ROT_90));
1151 mWriter->setLayerTransform(static_cast<Transform>(Transform::FLIP_V | Transform::ROT_90));
1152 execute();
1153 }
1154
1155 /**
1156 * Test IComposerClient::Command::SET_LAYER_VISIBLE_REGION.
1157 */
TEST_P(GraphicsComposerHidlCommandTest,SET_LAYER_VISIBLE_REGION)1158 TEST_P(GraphicsComposerHidlCommandTest, SET_LAYER_VISIBLE_REGION) {
1159 Layer layer;
1160 ASSERT_NO_FATAL_FAILURE(layer =
1161 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
1162
1163 IComposerClient::Rect empty{0, 0, 0, 0};
1164 IComposerClient::Rect unit{0, 0, 1, 1};
1165
1166 mWriter->selectDisplay(mPrimaryDisplay);
1167 mWriter->selectLayer(layer);
1168 mWriter->setLayerVisibleRegion(std::vector<IComposerClient::Rect>(1, empty));
1169 mWriter->setLayerVisibleRegion(std::vector<IComposerClient::Rect>(1, unit));
1170 mWriter->setLayerVisibleRegion(std::vector<IComposerClient::Rect>());
1171 execute();
1172 }
1173
1174 /**
1175 * Test IComposerClient::Command::SET_LAYER_Z_ORDER.
1176 */
TEST_P(GraphicsComposerHidlCommandTest,SET_LAYER_Z_ORDER)1177 TEST_P(GraphicsComposerHidlCommandTest, SET_LAYER_Z_ORDER) {
1178 Layer layer;
1179 ASSERT_NO_FATAL_FAILURE(layer =
1180 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
1181
1182 mWriter->selectDisplay(mPrimaryDisplay);
1183 mWriter->selectLayer(layer);
1184 mWriter->setLayerZOrder(10);
1185 mWriter->setLayerZOrder(0);
1186 execute();
1187 }
1188
1189 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerHidlCommandTest);
1190 INSTANTIATE_TEST_SUITE_P(
1191 PerInstance, GraphicsComposerHidlCommandTest,
1192 testing::ValuesIn(android::hardware::getAllHalInstanceNames(IComposer::descriptor)),
1193 android::hardware::PrintInstanceNameToString);
1194
1195 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerHidlTest);
1196 INSTANTIATE_TEST_SUITE_P(
1197 PerInstance, GraphicsComposerHidlTest,
1198 testing::ValuesIn(android::hardware::getAllHalInstanceNames(IComposer::descriptor)),
1199 android::hardware::PrintInstanceNameToString);
1200
1201 } // namespace
1202 } // namespace vts
1203 } // namespace V2_1
1204 } // namespace composer
1205 } // namespace graphics
1206 } // namespace hardware
1207 } // namespace android
1208
main(int argc,char ** argv)1209 int main(int argc, char** argv) {
1210 ::testing::InitGoogleTest(&argc, argv);
1211
1212 using namespace std::chrono_literals;
1213 if (!android::base::WaitForProperty("init.svc.surfaceflinger", "stopped", 10s)) {
1214 ALOGE("Failed to stop init.svc.surfaceflinger");
1215 return -1;
1216 }
1217
1218 return RUN_ALL_TESTS();
1219 }
1220