1 /*
2 * Copyright (C) 2018 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@2.3"
18
19 #include <algorithm>
20
21 #include <android-base/logging.h>
22 #include <android/hardware/graphics/mapper/2.0/IMapper.h>
23 #include <composer-command-buffer/2.3/ComposerCommandBuffer.h>
24 #include <composer-vts/2.1/GraphicsComposerCallback.h>
25 #include <composer-vts/2.1/TestCommandReader.h>
26 #include <composer-vts/2.3/ComposerVts.h>
27 #include <gtest/gtest.h>
28 #include <hidl/GtestPrinter.h>
29 #include <hidl/ServiceManagement.h>
30 #include <mapper-vts/2.0/MapperVts.h>
31
32 namespace android {
33 namespace hardware {
34 namespace graphics {
35 namespace composer {
36 namespace V2_3 {
37 namespace vts {
38 namespace {
39
40 using common::V1_0::BufferUsage;
41 using common::V1_1::RenderIntent;
42 using common::V1_2::ColorMode;
43 using common::V1_2::Dataspace;
44 using common::V1_2::PixelFormat;
45 using mapper::V2_0::IMapper;
46 using V2_2::vts::Gralloc;
47
48 class GraphicsComposerHidlTest : public ::testing::TestWithParam<std::string> {
49 protected:
SetUp()50 void SetUp() override {
51 ASSERT_NO_FATAL_FAILURE(
52 mComposer = std::make_unique<Composer>(IComposer::getService(GetParam())));
53 ASSERT_NO_FATAL_FAILURE(mComposerClient = mComposer->createClient());
54
55 mComposerCallback = new V2_1::vts::GraphicsComposerCallback;
56 mComposerClient->registerCallback(mComposerCallback);
57
58 // assume the first display is primary and is never removed
59 mPrimaryDisplay = waitForFirstDisplay();
60
61 mInvalidDisplayId = GetInvalidDisplayId();
62
63 // explicitly disable vsync
64 mComposerClient->setVsyncEnabled(mPrimaryDisplay, false);
65 mComposerCallback->setVsyncAllowed(false);
66
67 mWriter = std::make_unique<CommandWriterBase>(1024);
68 mReader = std::make_unique<V2_1::vts::TestCommandReader>();
69 }
70
TearDown()71 void TearDown() override {
72 ASSERT_EQ(0, mReader->mErrors.size());
73 ASSERT_EQ(0, mReader->mCompositionChanges.size());
74 if (mComposerCallback != nullptr) {
75 EXPECT_EQ(0, mComposerCallback->getInvalidHotplugCount());
76 EXPECT_EQ(0, mComposerCallback->getInvalidRefreshCount());
77 EXPECT_EQ(0, mComposerCallback->getInvalidVsyncCount());
78 }
79 }
80
81 // returns an invalid display id (one that has not been registered to a
82 // display. Currently assuming that a device will never have close to
83 // std::numeric_limit<uint64_t>::max() displays registered while running tests
GetInvalidDisplayId()84 Display GetInvalidDisplayId() {
85 std::vector<Display> validDisplays = mComposerCallback->getDisplays();
86 uint64_t id = std::numeric_limits<uint64_t>::max();
87 while (id > 0) {
88 if (std::find(validDisplays.begin(), validDisplays.end(), id) == validDisplays.end()) {
89 return id;
90 }
91 id--;
92 }
93
94 return 0;
95 }
96
execute()97 void execute() { mComposerClient->execute(mReader.get(), mWriter.get()); }
98
99 // use the slot count usually set by SF
100 static constexpr uint32_t kBufferSlotCount = 64;
101
102 std::unique_ptr<Composer> mComposer;
103 std::unique_ptr<ComposerClient> mComposerClient;
104 sp<V2_1::vts::GraphicsComposerCallback> mComposerCallback;
105 // the first display and is assumed never to be removed
106 Display mPrimaryDisplay;
107 Display mInvalidDisplayId;
108 std::unique_ptr<CommandWriterBase> mWriter;
109 std::unique_ptr<V2_1::vts::TestCommandReader> mReader;
110
111 private:
waitForFirstDisplay()112 Display waitForFirstDisplay() {
113 while (true) {
114 std::vector<Display> displays = mComposerCallback->getDisplays();
115 if (displays.empty()) {
116 usleep(5 * 1000);
117 continue;
118 }
119
120 return displays[0];
121 }
122 }
123 };
124
125 // Tests for IComposerClient::Command.
126 class GraphicsComposerHidlCommandTest : public GraphicsComposerHidlTest {
127 protected:
SetUp()128 void SetUp() override {
129 ASSERT_NO_FATAL_FAILURE(GraphicsComposerHidlTest::SetUp());
130
131 ASSERT_NO_FATAL_FAILURE(mGralloc = std::make_unique<Gralloc>());
132
133 mWriter = std::make_unique<CommandWriterBase>(1024);
134 mReader = std::make_unique<V2_1::vts::TestCommandReader>();
135 }
136
TearDown()137 void TearDown() override {
138 ASSERT_EQ(0, mReader->mErrors.size());
139 ASSERT_NO_FATAL_FAILURE(GraphicsComposerHidlTest::TearDown());
140 }
141
allocate()142 const native_handle_t* allocate() {
143 return mGralloc->allocate(
144 64, 64, 1, static_cast<common::V1_1::PixelFormat>(PixelFormat::RGBA_8888),
145 static_cast<uint64_t>(BufferUsage::CPU_WRITE_OFTEN | BufferUsage::CPU_READ_OFTEN));
146 }
147
execute()148 void execute() { mComposerClient->execute(mReader.get(), mWriter.get()); }
149
150 std::unique_ptr<CommandWriterBase> mWriter;
151 std::unique_ptr<V2_1::vts::TestCommandReader> mReader;
152
153 private:
154 std::unique_ptr<Gralloc> mGralloc;
155 };
156
157 /**
158 * Test IComposerClient::getDisplayIdentificationData.
159 *
160 * TODO: Check that ports are unique for multiple displays.
161 */
TEST_P(GraphicsComposerHidlTest,GetDisplayIdentificationData)162 TEST_P(GraphicsComposerHidlTest, GetDisplayIdentificationData) {
163 uint8_t port0;
164 std::vector<uint8_t> data0;
165 if (mComposerClient->getDisplayIdentificationData(mPrimaryDisplay, &port0, &data0)) {
166 uint8_t port1;
167 std::vector<uint8_t> data1;
168 ASSERT_TRUE(mComposerClient->getDisplayIdentificationData(mPrimaryDisplay, &port1, &data1));
169
170 ASSERT_EQ(port0, port1) << "ports are not stable";
171 ASSERT_TRUE(data0.size() == data1.size() &&
172 std::equal(data0.begin(), data0.end(), data1.begin()))
173 << "data is not stable";
174 }
175 }
176
177 /**
178 * Test IComposerClient::Command::SET_LAYER_PER_FRAME_METADATA.
179 */
TEST_P(GraphicsComposerHidlCommandTest,SET_LAYER_PER_FRAME_METADATA)180 TEST_P(GraphicsComposerHidlCommandTest, SET_LAYER_PER_FRAME_METADATA) {
181 Layer layer;
182 ASSERT_NO_FATAL_FAILURE(layer =
183 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
184
185 mWriter->selectDisplay(mPrimaryDisplay);
186 mWriter->selectLayer(layer);
187
188 /**
189 * DISPLAY_P3 is a color space that uses the DCI_P3 primaries,
190 * the D65 white point and the SRGB transfer functions.
191 * Rendering Intent: Colorimetric
192 * Primaries:
193 * x y
194 * green 0.265 0.690
195 * blue 0.150 0.060
196 * red 0.680 0.320
197 * white (D65) 0.3127 0.3290
198 */
199
200 std::vector<IComposerClient::PerFrameMetadata> hidlMetadata;
201 hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X, 0.680});
202 hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y, 0.320});
203 hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X, 0.265});
204 hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y, 0.690});
205 hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X, 0.150});
206 hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y, 0.060});
207 hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::WHITE_POINT_X, 0.3127});
208 hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::WHITE_POINT_Y, 0.3290});
209 hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::MAX_LUMINANCE, 100.0});
210 hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::MIN_LUMINANCE, 0.1});
211 hidlMetadata.push_back({IComposerClient::PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL, 78.0});
212 hidlMetadata.push_back(
213 {IComposerClient::PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL, 62.0});
214 mWriter->setLayerPerFrameMetadata(hidlMetadata);
215 execute();
216
217 if (mReader->mErrors.size() == 1 &&
218 static_cast<Error>(mReader->mErrors[0].second) == Error::UNSUPPORTED) {
219 mReader->mErrors.clear();
220 GTEST_SUCCEED() << "SetLayerPerFrameMetadata is not supported";
221 ASSERT_NO_FATAL_FAILURE(mComposerClient->destroyLayer(mPrimaryDisplay, layer));
222 return;
223 }
224
225 ASSERT_NO_FATAL_FAILURE(mComposerClient->destroyLayer(mPrimaryDisplay, layer));
226 }
227
228 /**
229 * Test IComposerClient::getHdrCapabilities_2_3
230 */
TEST_P(GraphicsComposerHidlTest,GetHdrCapabilities_2_3)231 TEST_P(GraphicsComposerHidlTest, GetHdrCapabilities_2_3) {
232 float maxLuminance;
233 float maxAverageLuminance;
234 float minLuminance;
235 ASSERT_NO_FATAL_FAILURE(mComposerClient->getHdrCapabilities_2_3(
236 mPrimaryDisplay, &maxLuminance, &maxAverageLuminance, &minLuminance));
237 ASSERT_TRUE(maxLuminance >= minLuminance);
238 }
239
240 /**
241 * Test IComposerClient::getPerFrameMetadataKeys_2_3
242 */
TEST_P(GraphicsComposerHidlTest,GetPerFrameMetadataKeys_2_3)243 TEST_P(GraphicsComposerHidlTest, GetPerFrameMetadataKeys_2_3) {
244 std::vector<IComposerClient::PerFrameMetadataKey> keys;
245 mComposerClient->getRaw()->getPerFrameMetadataKeys_2_3(
246 mPrimaryDisplay, [&](const auto tmpError, const auto outKeys) {
247 if (tmpError != Error::UNSUPPORTED) {
248 ASSERT_EQ(Error::NONE, tmpError);
249 keys = outKeys;
250 }
251 });
252 }
253
254 /**
255 * TestIComposerClient::getReadbackBufferAttributes_2_3
256 */
TEST_P(GraphicsComposerHidlTest,GetReadbackBufferAttributes_2_3)257 TEST_P(GraphicsComposerHidlTest, GetReadbackBufferAttributes_2_3) {
258 Dataspace dataspace;
259 PixelFormat pixelFormat;
260
261 mComposerClient->getRaw()->getReadbackBufferAttributes_2_3(
262 mPrimaryDisplay,
263 [&](const auto tmpError, const auto outPixelFormat, const auto outDataspace) {
264 if (tmpError != Error::UNSUPPORTED) {
265 ASSERT_EQ(Error::NONE, tmpError);
266 dataspace = outDataspace;
267 pixelFormat = outPixelFormat;
268 }
269 });
270 }
271
272 /**
273 * Test IComposerClient::getClientTargetSupport_2_3
274 */
TEST_P(GraphicsComposerHidlTest,GetClientTargetSupport_2_3)275 TEST_P(GraphicsComposerHidlTest, GetClientTargetSupport_2_3) {
276 std::vector<V2_1::Config> configs = mComposerClient->getDisplayConfigs(mPrimaryDisplay);
277 for (auto config : configs) {
278 int32_t width = mComposerClient->getDisplayAttribute(mPrimaryDisplay, config,
279 IComposerClient::Attribute::WIDTH);
280 int32_t height = mComposerClient->getDisplayAttribute(mPrimaryDisplay, config,
281 IComposerClient::Attribute::HEIGHT);
282 ASSERT_LT(0, width);
283 ASSERT_LT(0, height);
284
285 mComposerClient->setActiveConfig(mPrimaryDisplay, config);
286
287 ASSERT_TRUE(mComposerClient->getClientTargetSupport_2_3(
288 mPrimaryDisplay, width, height, PixelFormat::RGBA_8888, Dataspace::UNKNOWN));
289 }
290 }
291 /**
292 * Test IComposerClient::getClientTargetSupport_2_3
293 *
294 * Test that IComposerClient::getClientTargetSupport_2_3 returns
295 * Error::BAD_DISPLAY when passed in an invalid display handle
296 */
297
TEST_P(GraphicsComposerHidlTest,GetClientTargetSupport_2_3BadDisplay)298 TEST_P(GraphicsComposerHidlTest, GetClientTargetSupport_2_3BadDisplay) {
299 std::vector<V2_1::Config> configs = mComposerClient->getDisplayConfigs(mPrimaryDisplay);
300 for (auto config : configs) {
301 int32_t width = mComposerClient->getDisplayAttribute(mPrimaryDisplay, config,
302 IComposerClient::Attribute::WIDTH);
303 int32_t height = mComposerClient->getDisplayAttribute(mPrimaryDisplay, config,
304 IComposerClient::Attribute::HEIGHT);
305 ASSERT_LT(0, width);
306 ASSERT_LT(0, height);
307
308 mComposerClient->setActiveConfig(mPrimaryDisplay, config);
309
310 Error error = mComposerClient->getRaw()->getClientTargetSupport_2_3(
311 mInvalidDisplayId, width, height, PixelFormat::RGBA_8888, Dataspace::UNKNOWN);
312
313 EXPECT_EQ(Error::BAD_DISPLAY, error);
314 }
315 }
316
317 /**
318 * Test IComposerClient::getRenderIntents_2_3
319 */
TEST_P(GraphicsComposerHidlTest,GetRenderIntents_2_3)320 TEST_P(GraphicsComposerHidlTest, GetRenderIntents_2_3) {
321 std::vector<ColorMode> modes = mComposerClient->getColorModes_2_3(mPrimaryDisplay);
322 for (auto mode : modes) {
323 std::vector<RenderIntent> intents =
324 mComposerClient->getRenderIntents_2_3(mPrimaryDisplay, mode);
325
326 bool isHdr;
327 switch (mode) {
328 case ColorMode::BT2100_PQ:
329 case ColorMode::BT2100_HLG:
330 isHdr = true;
331 break;
332 default:
333 isHdr = false;
334 break;
335 }
336 RenderIntent requiredIntent =
337 isHdr ? RenderIntent::TONE_MAP_COLORIMETRIC : RenderIntent::COLORIMETRIC;
338
339 auto iter = std::find(intents.cbegin(), intents.cend(), requiredIntent);
340 EXPECT_NE(intents.cend(), iter);
341 }
342 }
343
344 /*
345 * Test IComposerClient::getRenderIntents_2_3
346 *
347 * Test that IComposerClient::getRenderIntents_2_3 returns Error::BAD_DISPLAY when
348 * passed an invalid display handle
349 */
TEST_P(GraphicsComposerHidlTest,GetRenderIntents_2_3BadDisplay)350 TEST_P(GraphicsComposerHidlTest, GetRenderIntents_2_3BadDisplay) {
351 std::vector<ColorMode> modes = mComposerClient->getColorModes_2_3(mPrimaryDisplay);
352 for (auto mode : modes) {
353 mComposerClient->getRaw()->getRenderIntents_2_3(
354 mInvalidDisplayId, mode,
355 [&](const auto& tmpError, const auto&) { EXPECT_EQ(Error::BAD_DISPLAY, tmpError); });
356 }
357 }
358
359 /*
360 * Test IComposerClient::getRenderIntents_2_3
361 *
362 * Test that IComposerClient::getRenderIntents_2_3 returns Error::BAD_PARAMETER when
363 * pased either an invalid Color mode or an invalid Render Intent
364 */
TEST_P(GraphicsComposerHidlTest,GetRenderIntents_2_3BadParameter)365 TEST_P(GraphicsComposerHidlTest, GetRenderIntents_2_3BadParameter) {
366 mComposerClient->getRaw()->getRenderIntents_2_3(
367 mPrimaryDisplay, static_cast<ColorMode>(-1),
368 [&](const auto& tmpError, const auto&) { EXPECT_EQ(Error::BAD_PARAMETER, tmpError); });
369 }
370
371 /**
372 * IComposerClient::getColorModes_2_3
373 */
TEST_P(GraphicsComposerHidlTest,GetColorModes_2_3)374 TEST_P(GraphicsComposerHidlTest, GetColorModes_2_3) {
375 std::vector<ColorMode> colorModes = mComposerClient->getColorModes_2_3(mPrimaryDisplay);
376
377 auto native = std::find(colorModes.cbegin(), colorModes.cend(), ColorMode::NATIVE);
378 ASSERT_NE(colorModes.cend(), native);
379 }
380
381 /*
382 * Test IComposerClient::getColorModes_2_3
383 *
384 * Test that IComposerClient::getColorModes_2_3 returns Error::BAD_DISPLAY when
385 * passed an invalid display handle
386 */
TEST_P(GraphicsComposerHidlTest,GetColorMode_2_3BadDisplay)387 TEST_P(GraphicsComposerHidlTest, GetColorMode_2_3BadDisplay) {
388 mComposerClient->getRaw()->getColorModes_2_3(
389 mInvalidDisplayId,
390 [&](const auto& tmpError, const auto&) { ASSERT_EQ(Error::BAD_DISPLAY, tmpError); });
391 }
392
393 /**
394 * IComposerClient::setColorMode_2_3
395 */
TEST_P(GraphicsComposerHidlTest,SetColorMode_2_3)396 TEST_P(GraphicsComposerHidlTest, SetColorMode_2_3) {
397 std::vector<ColorMode> colorModes = mComposerClient->getColorModes_2_3(mPrimaryDisplay);
398 for (auto mode : colorModes) {
399 std::vector<RenderIntent> intents =
400 mComposerClient->getRenderIntents_2_3(mPrimaryDisplay, mode);
401 for (auto intent : intents) {
402 ASSERT_NO_FATAL_FAILURE(
403 mComposerClient->setColorMode_2_3(mPrimaryDisplay, mode, intent));
404 }
405 }
406
407 ASSERT_NO_FATAL_FAILURE(mComposerClient->setColorMode_2_3(mPrimaryDisplay, ColorMode::NATIVE,
408 RenderIntent::COLORIMETRIC));
409 }
410
411 /*
412 * Test IComposerClient::setColorMode_2_3
413 *
414 * Test that IComposerClient::setColorMode_2_3 returns an Error::BAD_DISPLAY
415 * when passed an invalid display handle
416 */
TEST_P(GraphicsComposerHidlTest,SetColorMode_2_3BadDisplay)417 TEST_P(GraphicsComposerHidlTest, SetColorMode_2_3BadDisplay) {
418 Error error = mComposerClient->getRaw()->setColorMode_2_3(mInvalidDisplayId, ColorMode::NATIVE,
419 RenderIntent::COLORIMETRIC);
420
421 ASSERT_EQ(Error::BAD_DISPLAY, error);
422 }
423
424 /*
425 * Test IComposerClient::setColorMode_2_3
426 *
427 * Test that IComposerClient::setColorMode_2_3 returns Error::BAD_PARAMETER when
428 * passed an invalid Color mode or an invalid render intent
429 */
TEST_P(GraphicsComposerHidlTest,SetColorMode_2_3BadParameter)430 TEST_P(GraphicsComposerHidlTest, SetColorMode_2_3BadParameter) {
431 Error colorModeError = mComposerClient->getRaw()->setColorMode_2_3(
432 mPrimaryDisplay, static_cast<ColorMode>(-1), RenderIntent::COLORIMETRIC);
433 EXPECT_EQ(Error::BAD_PARAMETER, colorModeError);
434
435 Error renderIntentError = mComposerClient->getRaw()->setColorMode_2_3(
436 mPrimaryDisplay, ColorMode::NATIVE, static_cast<RenderIntent>(-1));
437 EXPECT_EQ(Error::BAD_PARAMETER, renderIntentError);
438 }
439
440 /**
441 * Test IComposerClient::Command::SET_LAYER_COLOR_TRANSFORM.
442 * TODO Add color to the layer, use matrix to keep only red component,
443 * and check.
444 */
TEST_P(GraphicsComposerHidlTest,SetLayerColorTransform)445 TEST_P(GraphicsComposerHidlTest, SetLayerColorTransform) {
446 Layer layer;
447 ASSERT_NO_FATAL_FAILURE(layer =
448 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
449 mWriter->selectDisplay(mPrimaryDisplay);
450 mWriter->selectLayer(layer);
451
452 // clang-format off
453 const std::array<float, 16> matrix = {{
454 1.0f, 0.0f, 0.0f, 0.0f,
455 0.0f, 1.0f, 0.0f, 0.0f,
456 0.0f, 0.0f, 1.0f, 0.0f,
457 0.0f, 0.0f, 0.0f, 1.0f,
458 }};
459 // clang-format on
460
461 mWriter->setLayerColorTransform(matrix.data());
462 execute();
463
464 if (mReader->mErrors.size() == 1 &&
465 static_cast<Error>(mReader->mErrors[0].second) == Error::UNSUPPORTED) {
466 mReader->mErrors.clear();
467 GTEST_SUCCEED() << "setLayerColorTransform is not supported";
468 return;
469 }
470 }
471
TEST_P(GraphicsComposerHidlTest,GetDisplayedContentSamplingAttributes)472 TEST_P(GraphicsComposerHidlTest, GetDisplayedContentSamplingAttributes) {
473 int constexpr invalid = -1;
474 auto format = static_cast<PixelFormat>(invalid);
475 auto dataspace = static_cast<Dataspace>(invalid);
476 auto componentMask = static_cast<hidl_bitfield<IComposerClient::FormatColorComponent>>(invalid);
477 auto error = mComposerClient->getDisplayedContentSamplingAttributes(mPrimaryDisplay, format,
478 dataspace, componentMask);
479
480 if (error == Error::UNSUPPORTED) {
481 SUCCEED() << "Device does not support optional extension. Test skipped";
482 return;
483 }
484
485 EXPECT_EQ(error, Error::NONE);
486 EXPECT_NE(format, static_cast<PixelFormat>(invalid));
487 EXPECT_NE(dataspace, static_cast<Dataspace>(invalid));
488 EXPECT_NE(componentMask,
489 static_cast<hidl_bitfield<IComposerClient::FormatColorComponent>>(invalid));
490 };
491
TEST_P(GraphicsComposerHidlTest,SetDisplayedContentSamplingEnabled)492 TEST_P(GraphicsComposerHidlTest, SetDisplayedContentSamplingEnabled) {
493 auto const maxFrames = 10;
494 auto const enableAllComponents = 0;
495 auto error = mComposerClient->setDisplayedContentSamplingEnabled(
496 mPrimaryDisplay, IComposerClient::DisplayedContentSampling::ENABLE, enableAllComponents,
497 maxFrames);
498 if (error == Error::UNSUPPORTED) {
499 SUCCEED() << "Device does not support optional extension. Test skipped";
500 return;
501 }
502 EXPECT_EQ(error, Error::NONE);
503
504 error = mComposerClient->setDisplayedContentSamplingEnabled(
505 mPrimaryDisplay, IComposerClient::DisplayedContentSampling::DISABLE, enableAllComponents,
506 maxFrames);
507 EXPECT_EQ(error, Error::NONE);
508 }
509
TEST_P(GraphicsComposerHidlTest,GetDisplayedContentSample)510 TEST_P(GraphicsComposerHidlTest, GetDisplayedContentSample) {
511 int constexpr invalid = -1;
512 auto format = static_cast<PixelFormat>(invalid);
513 auto dataspace = static_cast<Dataspace>(invalid);
514 auto componentMask = static_cast<hidl_bitfield<IComposerClient::FormatColorComponent>>(invalid);
515 auto error = mComposerClient->getDisplayedContentSamplingAttributes(mPrimaryDisplay, format,
516 dataspace, componentMask);
517
518 uint64_t maxFrames = 10;
519 uint64_t timestamp = 0;
520 uint64_t frameCount = 0;
521 hidl_array<hidl_vec<uint64_t>, 4> histogram;
522 error = mComposerClient->getDisplayedContentSample(mPrimaryDisplay, maxFrames, timestamp,
523 frameCount, histogram[0], histogram[1],
524 histogram[2], histogram[3]);
525 if (error == Error::UNSUPPORTED) {
526 SUCCEED() << "Device does not support optional extension. Test skipped";
527 return;
528 }
529
530 EXPECT_EQ(error, Error::NONE);
531 EXPECT_LE(frameCount, maxFrames);
532 for (auto i = 0; i < histogram.size(); i++) {
533 if (componentMask & (1 << i)) {
534 EXPECT_NE(histogram[i].size(), 0);
535 } else {
536 EXPECT_EQ(histogram[i].size(), 0);
537 }
538 }
539 }
540
541 /*
542 * getDisplayCapabilities is required in composer 2.3
543 * Test some constraints.
544 */
TEST_P(GraphicsComposerHidlTest,getDisplayCapabilitiesBasic)545 TEST_P(GraphicsComposerHidlTest, getDisplayCapabilitiesBasic) {
546 std::vector<IComposerClient::DisplayCapability> capabilities;
547 const auto error = mComposerClient->getDisplayCapabilities(mPrimaryDisplay, &capabilities);
548 ASSERT_EQ(Error::NONE, error);
549 const bool hasDozeSupport =
550 std::find(capabilities.begin(), capabilities.end(),
551 IComposerClient::DisplayCapability::DOZE) != capabilities.end();
552 EXPECT_EQ(mComposerClient->getDozeSupport(mPrimaryDisplay), hasDozeSupport);
553 bool hasBrightnessSupport =
554 std::find(capabilities.begin(), capabilities.end(),
555 IComposerClient::DisplayCapability::BRIGHTNESS) != capabilities.end();
556 EXPECT_EQ(mComposerClient->getDisplayBrightnessSupport(mPrimaryDisplay), hasBrightnessSupport);
557 }
558
TEST_P(GraphicsComposerHidlTest,getDisplayCapabilitiesBadDisplay)559 TEST_P(GraphicsComposerHidlTest, getDisplayCapabilitiesBadDisplay) {
560 std::vector<IComposerClient::DisplayCapability> capabilities;
561 const auto error = mComposerClient->getDisplayCapabilities(mInvalidDisplayId, &capabilities);
562 EXPECT_EQ(Error::BAD_DISPLAY, error);
563 }
564
TEST_P(GraphicsComposerHidlTest,SetLayerPerFrameMetadataBlobs)565 TEST_P(GraphicsComposerHidlTest, SetLayerPerFrameMetadataBlobs) {
566 Layer layer;
567 ASSERT_NO_FATAL_FAILURE(layer =
568 mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount));
569
570 mWriter->selectDisplay(mPrimaryDisplay);
571 mWriter->selectLayer(layer);
572
573 std::vector<IComposerClient::PerFrameMetadataBlob> metadata;
574 metadata.push_back(
575 {IComposerClient::PerFrameMetadataKey::HDR10_PLUS_SEI, std::vector<uint8_t>(1, 0xff)});
576
577 mWriter->setLayerPerFrameMetadataBlobs(metadata);
578 execute();
579
580 if (mReader->mErrors.size() == 1 &&
581 static_cast<Error>(mReader->mErrors[0].second) == Error::UNSUPPORTED) {
582 mReader->mErrors.clear();
583 GTEST_SUCCEED() << "setLayerDynamicPerFrameMetadata is not supported";
584 return;
585 }
586 }
587
588 /*
589 * Test that if brightness operations are supported, setDisplayBrightness works as expected.
590 */
TEST_P(GraphicsComposerHidlTest,setDisplayBrightness)591 TEST_P(GraphicsComposerHidlTest, setDisplayBrightness) {
592 std::vector<IComposerClient::DisplayCapability> capabilities;
593 const auto error = mComposerClient->getDisplayCapabilities(mPrimaryDisplay, &capabilities);
594 ASSERT_EQ(Error::NONE, error);
595 bool brightnessSupport =
596 std::find(capabilities.begin(), capabilities.end(),
597 IComposerClient::DisplayCapability::BRIGHTNESS) != capabilities.end();
598 if (!brightnessSupport) {
599 EXPECT_EQ(mComposerClient->getRaw()->setDisplayBrightness(mPrimaryDisplay, 0.5f),
600 Error::UNSUPPORTED);
601 GTEST_SUCCEED() << "Brightness operations are not supported";
602 return;
603 }
604
605 EXPECT_EQ(mComposerClient->setDisplayBrightness(mPrimaryDisplay, 0.0f), Error::NONE);
606 EXPECT_EQ(mComposerClient->setDisplayBrightness(mPrimaryDisplay, 0.5f), Error::NONE);
607 EXPECT_EQ(mComposerClient->setDisplayBrightness(mPrimaryDisplay, 1.0f), Error::NONE);
608 EXPECT_EQ(mComposerClient->setDisplayBrightness(mPrimaryDisplay, -1.0f), Error::NONE);
609
610 EXPECT_EQ(mComposerClient->setDisplayBrightness(mPrimaryDisplay, +2.0f), Error::BAD_PARAMETER);
611 EXPECT_EQ(mComposerClient->setDisplayBrightness(mPrimaryDisplay, -2.0f), Error::BAD_PARAMETER);
612 }
613
614 INSTANTIATE_TEST_SUITE_P(
615 PerInstance, GraphicsComposerHidlTest,
616 testing::ValuesIn(android::hardware::getAllHalInstanceNames(IComposer::descriptor)),
617 android::hardware::PrintInstanceNameToString);
618
619 INSTANTIATE_TEST_SUITE_P(
620 PerInstance, GraphicsComposerHidlCommandTest,
621 testing::ValuesIn(android::hardware::getAllHalInstanceNames(IComposer::descriptor)),
622 android::hardware::PrintInstanceNameToString);
623
624 } // namespace
625 } // namespace vts
626 } // namespace V2_3
627 } // namespace composer
628 } // namespace graphics
629 } // namespace hardware
630 } // namespace android
631