blob: 15128ca649dac14a6bda602c6bada85cd5f4b287 [file] [log] [blame]
ramindani431aad42022-02-01 21:44:29 +00001/**
2 * Copyright (c) 2022, The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
Sally Qi2600d342022-08-16 12:46:17 -070016
ramindanid32ae8e2021-10-01 18:48:39 +000017#include <aidl/Gtest.h>
18#include <aidl/Vintf.h>
Ady Abraham3192f3d2021-12-03 16:08:56 -080019#include <aidl/android/hardware/graphics/common/BlendMode.h>
ramindani3335f7a2021-10-25 17:22:35 +000020#include <aidl/android/hardware/graphics/common/BufferUsage.h>
21#include <aidl/android/hardware/graphics/common/FRect.h>
Leon Scroggins IIIde057582022-01-13 12:26:00 -050022#include <aidl/android/hardware/graphics/common/PixelFormat.h>
ramindani3335f7a2021-10-25 17:22:35 +000023#include <aidl/android/hardware/graphics/common/Rect.h>
ramindani3335f7a2021-10-25 17:22:35 +000024#include <aidl/android/hardware/graphics/composer3/Composition.h>
ramindanid32ae8e2021-10-01 18:48:39 +000025#include <aidl/android/hardware/graphics/composer3/IComposer.h>
26#include <android-base/properties.h>
ramindania9780262021-10-01 18:48:39 +000027#include <android/binder_process.h>
Ady Abraham91c9d1a2021-12-15 18:14:45 -080028#include <android/hardware/graphics/composer3/ComposerClientReader.h>
29#include <android/hardware/graphics/composer3/ComposerClientWriter.h>
ramindanid32ae8e2021-10-01 18:48:39 +000030#include <binder/ProcessState.h>
31#include <gtest/gtest.h>
Ady Abraham72c5b502021-12-10 17:23:39 -080032#include <ui/Fence.h>
ramindani3335f7a2021-10-25 17:22:35 +000033#include <ui/GraphicBuffer.h>
34#include <ui/PixelFormat.h>
ramindani0291f112021-11-04 03:45:46 +000035#include <algorithm>
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -040036#include <iterator>
ramindani592b6512021-10-08 21:15:19 +000037#include <numeric>
ramindanid32ae8e2021-10-01 18:48:39 +000038#include <string>
ramindani1cb794e2021-10-13 20:45:23 +000039#include <thread>
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -040040#include <unordered_map>
ramindani458e53e2022-02-23 17:30:16 +000041#include "GraphicsComposerCallback.h"
42#include "VtsComposerClient.h"
ramindani3335f7a2021-10-25 17:22:35 +000043
ramindanid32ae8e2021-10-01 18:48:39 +000044#undef LOG_TAG
45#define LOG_TAG "VtsHalGraphicsComposer3_TargetTest"
46
47namespace aidl::android::hardware::graphics::composer3::vts {
48namespace {
49
ramindani1cb794e2021-10-13 20:45:23 +000050using namespace std::chrono_literals;
51
ramindanidcfe3a82021-11-29 17:00:31 +000052using ::android::GraphicBuffer;
53using ::android::sp;
54
ramindanid32ae8e2021-10-01 18:48:39 +000055class GraphicsComposerAidlTest : public ::testing::TestWithParam<std::string> {
ramindania9780262021-10-01 18:48:39 +000056 protected:
57 void SetUp() override {
ramindani431aad42022-02-01 21:44:29 +000058 mComposerClient = std::make_unique<VtsComposerClient>(GetParam());
59 ASSERT_TRUE(mComposerClient->createClient().isOk());
Jason Macnake531a092022-01-20 08:49:09 -080060
ramindani431aad42022-02-01 21:44:29 +000061 const auto& [status, displays] = mComposerClient->getDisplays();
Jason Macnake531a092022-01-20 08:49:09 -080062 ASSERT_TRUE(status.isOk());
ramindani431aad42022-02-01 21:44:29 +000063 mDisplays = displays;
ramindanidcfe3a82021-11-29 17:00:31 +000064
ramindani3335f7a2021-10-25 17:22:35 +000065 // explicitly disable vsync
66 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +000067 EXPECT_TRUE(mComposerClient->setVsync(display.getDisplayId(), false).isOk());
ramindani3335f7a2021-10-25 17:22:35 +000068 }
ramindani431aad42022-02-01 21:44:29 +000069 mComposerClient->setVsyncAllowed(false);
ramindania9780262021-10-01 18:48:39 +000070 }
71
ramindani3335f7a2021-10-25 17:22:35 +000072 void TearDown() override {
ramindani431aad42022-02-01 21:44:29 +000073 ASSERT_TRUE(mComposerClient->tearDown());
74 mComposerClient.reset();
ramindani3335f7a2021-10-25 17:22:35 +000075 }
ramindanic2b8d082021-11-06 02:03:50 +000076
ramindanid5751092022-04-22 22:30:20 +000077 void assertServiceSpecificError(const ScopedAStatus& status, int32_t serviceSpecificError) {
78 ASSERT_EQ(status.getExceptionCode(), EX_SERVICE_SPECIFIC);
79 ASSERT_EQ(status.getServiceSpecificError(), serviceSpecificError);
80 }
81
ramindani431aad42022-02-01 21:44:29 +000082 void Test_setContentTypeForDisplay(int64_t display,
83 const std::vector<ContentType>& supportedContentTypes,
84 ContentType contentType, const char* contentTypeStr) {
85 const bool contentTypeSupport =
86 std::find(supportedContentTypes.begin(), supportedContentTypes.end(),
87 contentType) != supportedContentTypes.end();
ramindanidcfe3a82021-11-29 17:00:31 +000088
89 if (!contentTypeSupport) {
ramindani431aad42022-02-01 21:44:29 +000090 const auto& status = mComposerClient->setContentType(display, contentType);
91 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +000092 EXPECT_NO_FATAL_FAILURE(
93 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
ramindanidcfe3a82021-11-29 17:00:31 +000094 GTEST_SUCCEED() << contentTypeStr << " content type is not supported on display "
95 << std::to_string(display) << ", skipping test";
96 return;
97 }
98
99 EXPECT_TRUE(mComposerClient->setContentType(display, contentType).isOk());
100 EXPECT_TRUE(mComposerClient->setContentType(display, ContentType::NONE).isOk());
101 }
102
ramindani431aad42022-02-01 21:44:29 +0000103 void Test_setContentType(ContentType contentType, const char* contentTypeStr) {
ramindanidcfe3a82021-11-29 17:00:31 +0000104 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000105 const auto& [status, supportedContentTypes] =
106 mComposerClient->getSupportedContentTypes(display.getDisplayId());
107 EXPECT_TRUE(status.isOk());
108 Test_setContentTypeForDisplay(display.getDisplayId(), supportedContentTypes,
109 contentType, contentTypeStr);
ramindanidcfe3a82021-11-29 17:00:31 +0000110 }
111 }
112
Jason Macnak325e8232022-01-24 14:48:55 -0800113 bool hasCapability(Capability capability) {
ramindani431aad42022-02-01 21:44:29 +0000114 const auto& [status, capabilities] = mComposerClient->getCapabilities();
115 EXPECT_TRUE(status.isOk());
Jason Macnak325e8232022-01-24 14:48:55 -0800116 return std::any_of(
117 capabilities.begin(), capabilities.end(),
118 [&](const Capability& activeCapability) { return activeCapability == capability; });
119 }
120
ramindani431aad42022-02-01 21:44:29 +0000121 const VtsDisplay& getPrimaryDisplay() const { return mDisplays[0]; }
ramindania9780262021-10-01 18:48:39 +0000122
ramindani431aad42022-02-01 21:44:29 +0000123 int64_t getPrimaryDisplayId() const { return getPrimaryDisplay().getDisplayId(); }
ramindania9780262021-10-01 18:48:39 +0000124
ramindani431aad42022-02-01 21:44:29 +0000125 int64_t getInvalidDisplayId() const { return mComposerClient->getInvalidDisplayId(); }
ramindani1cb794e2021-10-13 20:45:23 +0000126
ramindani431aad42022-02-01 21:44:29 +0000127 VtsDisplay& getEditablePrimaryDisplay() { return mDisplays[0]; }
ramindani0291f112021-11-04 03:45:46 +0000128
ramindani3335f7a2021-10-25 17:22:35 +0000129 struct TestParameters {
130 nsecs_t delayForChange;
131 bool refreshMiss;
132 };
133
ramindani431aad42022-02-01 21:44:29 +0000134 std::unique_ptr<VtsComposerClient> mComposerClient;
ramindani1cb794e2021-10-13 20:45:23 +0000135 std::vector<VtsDisplay> mDisplays;
ramindani3335f7a2021-10-25 17:22:35 +0000136 // use the slot count usually set by SF
137 static constexpr uint32_t kBufferSlotCount = 64;
ramindanid32ae8e2021-10-01 18:48:39 +0000138};
139
ramindani431aad42022-02-01 21:44:29 +0000140TEST_P(GraphicsComposerAidlTest, GetDisplayCapabilities_BadDisplay) {
141 const auto& [status, _] = mComposerClient->getDisplayCapabilities(getInvalidDisplayId());
ramindani5f696942021-10-14 16:24:18 +0000142
ramindani431aad42022-02-01 21:44:29 +0000143 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000144 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindania9780262021-10-01 18:48:39 +0000145}
146
ramindani431aad42022-02-01 21:44:29 +0000147TEST_P(GraphicsComposerAidlTest, GetDisplayCapabilities) {
ramindania9780262021-10-01 18:48:39 +0000148 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000149 const auto& [status, capabilities] =
150 mComposerClient->getDisplayCapabilities(display.getDisplayId());
ramindania9780262021-10-01 18:48:39 +0000151
ramindani431aad42022-02-01 21:44:29 +0000152 EXPECT_TRUE(status.isOk());
ramindania9780262021-10-01 18:48:39 +0000153 }
ramindanid32ae8e2021-10-01 18:48:39 +0000154}
155
ramindani2740bac2021-11-24 22:58:32 +0000156TEST_P(GraphicsComposerAidlTest, DumpDebugInfo) {
ramindani431aad42022-02-01 21:44:29 +0000157 ASSERT_TRUE(mComposerClient->dumpDebugInfo().isOk());
ramindani2740bac2021-11-24 22:58:32 +0000158}
159
160TEST_P(GraphicsComposerAidlTest, CreateClientSingleton) {
161 std::shared_ptr<IComposerClient> composerClient;
ramindani431aad42022-02-01 21:44:29 +0000162 const auto& status = mComposerClient->createClient();
ramindani2740bac2021-11-24 22:58:32 +0000163
ramindani431aad42022-02-01 21:44:29 +0000164 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000165 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_NO_RESOURCES));
ramindani2740bac2021-11-24 22:58:32 +0000166}
167
ramindani592b6512021-10-08 21:15:19 +0000168TEST_P(GraphicsComposerAidlTest, GetDisplayIdentificationData) {
ramindani431aad42022-02-01 21:44:29 +0000169 const auto& [status0, displayIdentification0] =
170 mComposerClient->getDisplayIdentificationData(getPrimaryDisplayId());
ramindanid5751092022-04-22 22:30:20 +0000171 if (!status0.isOk() && status0.getExceptionCode() == EX_SERVICE_SPECIFIC &&
172 status0.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindani431aad42022-02-01 21:44:29 +0000173 GTEST_SUCCEED() << "Display identification data not supported, skipping test";
ramindani592b6512021-10-08 21:15:19 +0000174 return;
175 }
ramindani431aad42022-02-01 21:44:29 +0000176 ASSERT_TRUE(status0.isOk()) << "failed to get display identification data";
ramindani592b6512021-10-08 21:15:19 +0000177 ASSERT_FALSE(displayIdentification0.data.empty());
178
179 constexpr size_t kEdidBlockSize = 128;
180 ASSERT_TRUE(displayIdentification0.data.size() % kEdidBlockSize == 0)
181 << "EDID blob length is not a multiple of " << kEdidBlockSize;
182
183 const uint8_t kEdidHeader[] = {0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00};
184 ASSERT_TRUE(std::equal(std::begin(kEdidHeader), std::end(kEdidHeader),
185 displayIdentification0.data.begin()))
186 << "EDID blob doesn't start with the fixed EDID header";
187 ASSERT_EQ(0, std::accumulate(displayIdentification0.data.begin(),
188 displayIdentification0.data.begin() + kEdidBlockSize,
189 static_cast<uint8_t>(0)))
190 << "EDID base block doesn't checksum";
191
ramindani431aad42022-02-01 21:44:29 +0000192 const auto& [status1, displayIdentification1] =
193 mComposerClient->getDisplayIdentificationData(getPrimaryDisplayId());
194 ASSERT_TRUE(status1.isOk());
ramindani592b6512021-10-08 21:15:19 +0000195
196 ASSERT_EQ(displayIdentification0.port, displayIdentification1.port) << "ports are not stable";
197 ASSERT_TRUE(displayIdentification0.data.size() == displayIdentification1.data.size() &&
198 std::equal(displayIdentification0.data.begin(), displayIdentification0.data.end(),
199 displayIdentification1.data.begin()))
200 << "data is not stable";
201}
202
203TEST_P(GraphicsComposerAidlTest, GetHdrCapabilities) {
ramindani431aad42022-02-01 21:44:29 +0000204 const auto& [status, hdrCapabilities] =
205 mComposerClient->getHdrCapabilities(getPrimaryDisplayId());
ramindani592b6512021-10-08 21:15:19 +0000206
ramindani431aad42022-02-01 21:44:29 +0000207 ASSERT_TRUE(status.isOk());
208 EXPECT_TRUE(hdrCapabilities.maxLuminance >= hdrCapabilities.minLuminance);
ramindani592b6512021-10-08 21:15:19 +0000209}
210
211TEST_P(GraphicsComposerAidlTest, GetPerFrameMetadataKeys) {
ramindani431aad42022-02-01 21:44:29 +0000212 const auto& [status, keys] = mComposerClient->getPerFrameMetadataKeys(getPrimaryDisplayId());
ramindanid5751092022-04-22 22:30:20 +0000213 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
214 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindanic2b8d082021-11-06 02:03:50 +0000215 GTEST_SUCCEED() << "getPerFrameMetadataKeys is not supported";
216 return;
ramindani592b6512021-10-08 21:15:19 +0000217 }
ramindani431aad42022-02-01 21:44:29 +0000218
219 ASSERT_TRUE(status.isOk());
220 EXPECT_TRUE(keys.size() >= 0);
ramindani592b6512021-10-08 21:15:19 +0000221}
222
223TEST_P(GraphicsComposerAidlTest, GetReadbackBufferAttributes) {
ramindani431aad42022-02-01 21:44:29 +0000224 const auto& [status, _] = mComposerClient->getReadbackBufferAttributes(getPrimaryDisplayId());
ramindanid5751092022-04-22 22:30:20 +0000225 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
226 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindani431aad42022-02-01 21:44:29 +0000227 GTEST_SUCCEED() << "getReadbackBufferAttributes is not supported";
228 return;
ramindani592b6512021-10-08 21:15:19 +0000229 }
ramindani431aad42022-02-01 21:44:29 +0000230
231 ASSERT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000232}
233
234TEST_P(GraphicsComposerAidlTest, GetRenderIntents) {
ramindani431aad42022-02-01 21:44:29 +0000235 const auto& [status, modes] = mComposerClient->getColorModes(getPrimaryDisplayId());
236 EXPECT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000237
ramindani431aad42022-02-01 21:44:29 +0000238 for (auto mode : modes) {
239 const auto& [intentStatus, intents] =
240 mComposerClient->getRenderIntents(getPrimaryDisplayId(), mode);
241 EXPECT_TRUE(intentStatus.isOk());
ramindani592b6512021-10-08 21:15:19 +0000242 bool isHdr;
243 switch (mode) {
244 case ColorMode::BT2100_PQ:
245 case ColorMode::BT2100_HLG:
246 isHdr = true;
247 break;
248 default:
249 isHdr = false;
250 break;
251 }
252 RenderIntent requiredIntent =
253 isHdr ? RenderIntent::TONE_MAP_COLORIMETRIC : RenderIntent::COLORIMETRIC;
254
ramindani431aad42022-02-01 21:44:29 +0000255 const auto iter = std::find(intents.cbegin(), intents.cend(), requiredIntent);
ramindani592b6512021-10-08 21:15:19 +0000256 EXPECT_NE(intents.cend(), iter);
257 }
258}
259
ramindani431aad42022-02-01 21:44:29 +0000260TEST_P(GraphicsComposerAidlTest, GetRenderIntents_BadDisplay) {
261 const auto& [status, modes] = mComposerClient->getColorModes(getPrimaryDisplayId());
262 ASSERT_TRUE(status.isOk());
263
ramindani592b6512021-10-08 21:15:19 +0000264 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +0000265 const auto& [intentStatus, _] =
266 mComposerClient->getRenderIntents(getInvalidDisplayId(), mode);
267
268 EXPECT_FALSE(intentStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000269 EXPECT_NO_FATAL_FAILURE(
270 assertServiceSpecificError(intentStatus, IComposerClient::EX_BAD_DISPLAY));
ramindani592b6512021-10-08 21:15:19 +0000271 }
272}
273
ramindani431aad42022-02-01 21:44:29 +0000274TEST_P(GraphicsComposerAidlTest, GetRenderIntents_BadParameter) {
275 const auto& [status, _] =
276 mComposerClient->getRenderIntents(getPrimaryDisplayId(), static_cast<ColorMode>(-1));
277
278 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000279 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
ramindani592b6512021-10-08 21:15:19 +0000280}
281
282TEST_P(GraphicsComposerAidlTest, GetColorModes) {
ramindani431aad42022-02-01 21:44:29 +0000283 const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
284 ASSERT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000285
ramindani431aad42022-02-01 21:44:29 +0000286 const auto native = std::find(colorModes.cbegin(), colorModes.cend(), ColorMode::NATIVE);
287 EXPECT_NE(colorModes.cend(), native);
ramindani592b6512021-10-08 21:15:19 +0000288}
289
ramindani431aad42022-02-01 21:44:29 +0000290TEST_P(GraphicsComposerAidlTest, GetColorMode_BadDisplay) {
291 const auto& [status, _] = mComposerClient->getColorModes(getInvalidDisplayId());
ramindani592b6512021-10-08 21:15:19 +0000292
ramindani431aad42022-02-01 21:44:29 +0000293 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000294 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani592b6512021-10-08 21:15:19 +0000295}
296
297TEST_P(GraphicsComposerAidlTest, SetColorMode) {
ramindani431aad42022-02-01 21:44:29 +0000298 const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
299 EXPECT_TRUE(status.isOk());
300
ramindani592b6512021-10-08 21:15:19 +0000301 for (auto mode : colorModes) {
ramindani431aad42022-02-01 21:44:29 +0000302 const auto& [intentStatus, intents] =
303 mComposerClient->getRenderIntents(getPrimaryDisplayId(), mode);
304 EXPECT_TRUE(intentStatus.isOk()) << "failed to get render intents";
305
ramindani592b6512021-10-08 21:15:19 +0000306 for (auto intent : intents) {
ramindani431aad42022-02-01 21:44:29 +0000307 const auto modeStatus =
308 mComposerClient->setColorMode(getPrimaryDisplayId(), mode, intent);
309 EXPECT_TRUE(modeStatus.isOk() ||
ramindanid5751092022-04-22 22:30:20 +0000310 (modeStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
311 IComposerClient::EX_UNSUPPORTED == modeStatus.getServiceSpecificError()))
ramindani592b6512021-10-08 21:15:19 +0000312 << "failed to set color mode";
313 }
314 }
315
ramindani431aad42022-02-01 21:44:29 +0000316 const auto modeStatus = mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE,
317 RenderIntent::COLORIMETRIC);
318 EXPECT_TRUE(modeStatus.isOk() ||
ramindanid5751092022-04-22 22:30:20 +0000319 (modeStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
320 IComposerClient::EX_UNSUPPORTED == modeStatus.getServiceSpecificError()))
ramindani592b6512021-10-08 21:15:19 +0000321 << "failed to set color mode";
322}
323
ramindani431aad42022-02-01 21:44:29 +0000324TEST_P(GraphicsComposerAidlTest, SetColorMode_BadDisplay) {
325 const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
326 ASSERT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000327
ramindani431aad42022-02-01 21:44:29 +0000328 for (auto mode : colorModes) {
329 const auto& [intentStatus, intents] =
330 mComposerClient->getRenderIntents(getPrimaryDisplayId(), mode);
331 ASSERT_TRUE(intentStatus.isOk()) << "failed to get render intents";
332
333 for (auto intent : intents) {
334 auto const modeStatus =
335 mComposerClient->setColorMode(getInvalidDisplayId(), mode, intent);
336
337 EXPECT_FALSE(modeStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000338 EXPECT_NO_FATAL_FAILURE(
339 assertServiceSpecificError(modeStatus, IComposerClient::EX_BAD_DISPLAY));
ramindani770d7082021-11-30 00:36:42 +0000340 }
341 }
ramindani592b6512021-10-08 21:15:19 +0000342}
343
ramindani431aad42022-02-01 21:44:29 +0000344TEST_P(GraphicsComposerAidlTest, SetColorMode_BadParameter) {
345 auto status = mComposerClient->setColorMode(getPrimaryDisplayId(), static_cast<ColorMode>(-1),
346 RenderIntent::COLORIMETRIC);
ramindani592b6512021-10-08 21:15:19 +0000347
ramindani431aad42022-02-01 21:44:29 +0000348 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000349 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
ramindani592b6512021-10-08 21:15:19 +0000350
ramindani431aad42022-02-01 21:44:29 +0000351 status = mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE,
352 static_cast<RenderIntent>(-1));
ramindani592b6512021-10-08 21:15:19 +0000353
ramindani431aad42022-02-01 21:44:29 +0000354 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000355 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
ramindani592b6512021-10-08 21:15:19 +0000356}
357
358TEST_P(GraphicsComposerAidlTest, GetDisplayedContentSamplingAttributes) {
ramindani431aad42022-02-01 21:44:29 +0000359 int constexpr kInvalid = -1;
360 const auto& [status, format] =
361 mComposerClient->getDisplayedContentSamplingAttributes(getPrimaryDisplayId());
ramindani592b6512021-10-08 21:15:19 +0000362
ramindanid5751092022-04-22 22:30:20 +0000363 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
364 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindani592b6512021-10-08 21:15:19 +0000365 SUCCEED() << "Device does not support optional extension. Test skipped";
366 return;
367 }
368
ramindani431aad42022-02-01 21:44:29 +0000369 ASSERT_TRUE(status.isOk());
370 EXPECT_NE(kInvalid, static_cast<int>(format.format));
371 EXPECT_NE(kInvalid, static_cast<int>(format.dataspace));
372 EXPECT_NE(kInvalid, static_cast<int>(format.componentMask));
ramindani592b6512021-10-08 21:15:19 +0000373};
374
375TEST_P(GraphicsComposerAidlTest, SetDisplayedContentSamplingEnabled) {
ramindani431aad42022-02-01 21:44:29 +0000376 int constexpr kMaxFrames = 10;
ramindani592b6512021-10-08 21:15:19 +0000377 FormatColorComponent enableAllComponents = FormatColorComponent::FORMAT_COMPONENT_0;
ramindani431aad42022-02-01 21:44:29 +0000378 auto status = mComposerClient->setDisplayedContentSamplingEnabled(
379 getPrimaryDisplayId(), /*isEnabled*/ true, enableAllComponents, kMaxFrames);
ramindanid5751092022-04-22 22:30:20 +0000380 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
381 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindani592b6512021-10-08 21:15:19 +0000382 SUCCEED() << "Device does not support optional extension. Test skipped";
383 return;
384 }
ramindani431aad42022-02-01 21:44:29 +0000385 EXPECT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000386
ramindani431aad42022-02-01 21:44:29 +0000387 status = mComposerClient->setDisplayedContentSamplingEnabled(
388 getPrimaryDisplayId(), /*isEnabled*/ false, enableAllComponents, kMaxFrames);
389 EXPECT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000390}
391
392TEST_P(GraphicsComposerAidlTest, GetDisplayedContentSample) {
ramindani431aad42022-02-01 21:44:29 +0000393 const auto& [status, displayContentSamplingAttributes] =
394 mComposerClient->getDisplayedContentSamplingAttributes(getPrimaryDisplayId());
ramindanid5751092022-04-22 22:30:20 +0000395 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
396 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindanideb059e2021-11-18 01:57:25 +0000397 SUCCEED() << "Sampling attributes aren't supported on this device, test skipped";
398 return;
399 }
ramindani592b6512021-10-08 21:15:19 +0000400
ramindani431aad42022-02-01 21:44:29 +0000401 int64_t constexpr kMaxFrames = 10;
402 int64_t constexpr kTimestamp = 0;
403 const auto& [sampleStatus, displayContentSample] = mComposerClient->getDisplayedContentSample(
404 getPrimaryDisplayId(), kMaxFrames, kTimestamp);
ramindanid5751092022-04-22 22:30:20 +0000405 if (!sampleStatus.isOk() && sampleStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
ramindani431aad42022-02-01 21:44:29 +0000406 sampleStatus.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindani592b6512021-10-08 21:15:19 +0000407 SUCCEED() << "Device does not support optional extension. Test skipped";
408 return;
409 }
410
ramindani431aad42022-02-01 21:44:29 +0000411 EXPECT_TRUE(sampleStatus.isOk());
412 const std::vector<std::vector<int64_t>> histogram = {
ramindani592b6512021-10-08 21:15:19 +0000413 displayContentSample.sampleComponent0, displayContentSample.sampleComponent1,
414 displayContentSample.sampleComponent2, displayContentSample.sampleComponent3};
415
ramindani3335f7a2021-10-25 17:22:35 +0000416 for (size_t i = 0; i < histogram.size(); i++) {
417 const bool shouldHaveHistogram =
418 static_cast<int>(displayContentSamplingAttributes.componentMask) & (1 << i);
419 EXPECT_EQ(shouldHaveHistogram, !histogram[i].empty());
ramindani592b6512021-10-08 21:15:19 +0000420 }
421}
422
ramindani431aad42022-02-01 21:44:29 +0000423TEST_P(GraphicsComposerAidlTest, GetDisplayConnectionType) {
424 const auto& [status, type] = mComposerClient->getDisplayConnectionType(getInvalidDisplayId());
425
426 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000427 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani431aad42022-02-01 21:44:29 +0000428
ramindani0291f112021-11-04 03:45:46 +0000429 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000430 const auto& [connectionTypeStatus, _] =
431 mComposerClient->getDisplayConnectionType(display.getDisplayId());
432 EXPECT_TRUE(connectionTypeStatus.isOk());
ramindani0291f112021-11-04 03:45:46 +0000433 }
434}
435
ramindani431aad42022-02-01 21:44:29 +0000436TEST_P(GraphicsComposerAidlTest, GetDisplayAttribute) {
ramindani0291f112021-11-04 03:45:46 +0000437 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000438 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
439 EXPECT_TRUE(status.isOk());
440
ramindani0291f112021-11-04 03:45:46 +0000441 for (const auto& config : configs) {
442 const std::array<DisplayAttribute, 4> requiredAttributes = {{
443 DisplayAttribute::WIDTH,
444 DisplayAttribute::HEIGHT,
445 DisplayAttribute::VSYNC_PERIOD,
446 DisplayAttribute::CONFIG_GROUP,
447 }};
ramindani0291f112021-11-04 03:45:46 +0000448 for (const auto& attribute : requiredAttributes) {
ramindani431aad42022-02-01 21:44:29 +0000449 const auto& [attribStatus, value] = mComposerClient->getDisplayAttribute(
450 display.getDisplayId(), config, attribute);
451 EXPECT_TRUE(attribStatus.isOk());
ramindani0291f112021-11-04 03:45:46 +0000452 EXPECT_NE(-1, value);
453 }
454
455 const std::array<DisplayAttribute, 2> optionalAttributes = {{
456 DisplayAttribute::DPI_X,
457 DisplayAttribute::DPI_Y,
458 }};
459 for (const auto& attribute : optionalAttributes) {
ramindani431aad42022-02-01 21:44:29 +0000460 const auto& [attribStatus, value] = mComposerClient->getDisplayAttribute(
461 display.getDisplayId(), config, attribute);
ramindanid5751092022-04-22 22:30:20 +0000462 EXPECT_TRUE(attribStatus.isOk() ||
463 (attribStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
464 IComposerClient::EX_UNSUPPORTED ==
465 attribStatus.getServiceSpecificError()));
ramindani0291f112021-11-04 03:45:46 +0000466 }
467 }
468 }
469}
470
ramindani431aad42022-02-01 21:44:29 +0000471TEST_P(GraphicsComposerAidlTest, CheckConfigsAreValid) {
ramindani0291f112021-11-04 03:45:46 +0000472 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000473 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
474 EXPECT_TRUE(status.isOk());
ramindani0291f112021-11-04 03:45:46 +0000475
476 EXPECT_FALSE(std::any_of(configs.begin(), configs.end(), [](auto config) {
477 return config == IComposerClient::INVALID_CONFIGURATION;
478 }));
479 }
480}
481
ramindani431aad42022-02-01 21:44:29 +0000482TEST_P(GraphicsComposerAidlTest, GetDisplayVsyncPeriod_BadDisplay) {
483 const auto& [status, vsyncPeriodNanos] =
484 mComposerClient->getDisplayVsyncPeriod(getInvalidDisplayId());
485
486 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000487 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani0291f112021-11-04 03:45:46 +0000488}
489
ramindani431aad42022-02-01 21:44:29 +0000490TEST_P(GraphicsComposerAidlTest, SetActiveConfigWithConstraints_BadDisplay) {
ramindani0291f112021-11-04 03:45:46 +0000491 VsyncPeriodChangeConstraints constraints;
ramindani0291f112021-11-04 03:45:46 +0000492 constraints.seamlessRequired = false;
493 constraints.desiredTimeNanos = systemTime();
ramindani431aad42022-02-01 21:44:29 +0000494 auto invalidDisplay = VtsDisplay(getInvalidDisplayId());
ramindani0291f112021-11-04 03:45:46 +0000495
ramindani431aad42022-02-01 21:44:29 +0000496 const auto& [status, timeline] = mComposerClient->setActiveConfigWithConstraints(
497 &invalidDisplay, /*config*/ 0, constraints);
498
499 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000500 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani0291f112021-11-04 03:45:46 +0000501}
502
ramindani431aad42022-02-01 21:44:29 +0000503TEST_P(GraphicsComposerAidlTest, SetActiveConfigWithConstraints_BadConfig) {
ramindani0291f112021-11-04 03:45:46 +0000504 VsyncPeriodChangeConstraints constraints;
ramindani0291f112021-11-04 03:45:46 +0000505 constraints.seamlessRequired = false;
506 constraints.desiredTimeNanos = systemTime();
507
508 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000509 int32_t constexpr kInvalidConfigId = IComposerClient::INVALID_CONFIGURATION;
510 const auto& [status, _] = mComposerClient->setActiveConfigWithConstraints(
511 &display, kInvalidConfigId, constraints);
512
513 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000514 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_CONFIG));
ramindani0291f112021-11-04 03:45:46 +0000515 }
516}
517
ramindani431aad42022-02-01 21:44:29 +0000518TEST_P(GraphicsComposerAidlTest, SetBootDisplayConfig_BadDisplay) {
ramindani476314c2022-03-16 00:17:08 +0000519 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
520 GTEST_SUCCEED() << "Boot Display Config not supported";
521 return;
522 }
ramindani431aad42022-02-01 21:44:29 +0000523 const auto& status = mComposerClient->setBootDisplayConfig(getInvalidDisplayId(), /*config*/ 0);
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100524
ramindani431aad42022-02-01 21:44:29 +0000525 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000526 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100527}
528
ramindani431aad42022-02-01 21:44:29 +0000529TEST_P(GraphicsComposerAidlTest, SetBootDisplayConfig_BadConfig) {
ramindani476314c2022-03-16 00:17:08 +0000530 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
531 GTEST_SUCCEED() << "Boot Display Config not supported";
532 return;
533 }
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100534 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000535 int32_t constexpr kInvalidConfigId = IComposerClient::INVALID_CONFIGURATION;
536 const auto& status =
537 mComposerClient->setBootDisplayConfig(display.getDisplayId(), kInvalidConfigId);
538
539 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000540 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_CONFIG));
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100541 }
542}
543
ramindani431aad42022-02-01 21:44:29 +0000544TEST_P(GraphicsComposerAidlTest, SetBootDisplayConfig) {
ramindani476314c2022-03-16 00:17:08 +0000545 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
546 GTEST_SUCCEED() << "Boot Display Config not supported";
547 return;
548 }
ramindani431aad42022-02-01 21:44:29 +0000549 const auto& [status, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
550 EXPECT_TRUE(status.isOk());
551 for (const auto& config : configs) {
552 EXPECT_TRUE(mComposerClient->setBootDisplayConfig(getPrimaryDisplayId(), config).isOk());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100553 }
554}
555
ramindani431aad42022-02-01 21:44:29 +0000556TEST_P(GraphicsComposerAidlTest, ClearBootDisplayConfig_BadDisplay) {
ramindani476314c2022-03-16 00:17:08 +0000557 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
558 GTEST_SUCCEED() << "Boot Display Config not supported";
559 return;
560 }
ramindani431aad42022-02-01 21:44:29 +0000561 const auto& status = mComposerClient->clearBootDisplayConfig(getInvalidDisplayId());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100562
ramindani431aad42022-02-01 21:44:29 +0000563 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000564 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100565}
566
ramindani431aad42022-02-01 21:44:29 +0000567TEST_P(GraphicsComposerAidlTest, ClearBootDisplayConfig) {
ramindani476314c2022-03-16 00:17:08 +0000568 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
569 GTEST_SUCCEED() << "Boot Display Config not supported";
570 return;
571 }
ramindani431aad42022-02-01 21:44:29 +0000572 EXPECT_TRUE(mComposerClient->clearBootDisplayConfig(getPrimaryDisplayId()).isOk());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100573}
574
ramindani431aad42022-02-01 21:44:29 +0000575TEST_P(GraphicsComposerAidlTest, GetPreferredBootDisplayConfig_BadDisplay) {
ramindani476314c2022-03-16 00:17:08 +0000576 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
577 GTEST_SUCCEED() << "Boot Display Config not supported";
578 return;
579 }
ramindani431aad42022-02-01 21:44:29 +0000580 const auto& [status, _] = mComposerClient->getPreferredBootDisplayConfig(getInvalidDisplayId());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100581
ramindani431aad42022-02-01 21:44:29 +0000582 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000583 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100584}
585
ramindani431aad42022-02-01 21:44:29 +0000586TEST_P(GraphicsComposerAidlTest, GetPreferredBootDisplayConfig) {
ramindani476314c2022-03-16 00:17:08 +0000587 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
588 GTEST_SUCCEED() << "Boot Display Config not supported";
589 return;
590 }
ramindani431aad42022-02-01 21:44:29 +0000591 const auto& [status, preferredDisplayConfig] =
592 mComposerClient->getPreferredBootDisplayConfig(getPrimaryDisplayId());
593 EXPECT_TRUE(status.isOk());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100594
ramindani431aad42022-02-01 21:44:29 +0000595 const auto& [configStatus, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
596
597 EXPECT_TRUE(configStatus.isOk());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100598 EXPECT_NE(configs.end(), std::find(configs.begin(), configs.end(), preferredDisplayConfig));
599}
600
ramindani476314c2022-03-16 00:17:08 +0000601TEST_P(GraphicsComposerAidlTest, BootDisplayConfig_Unsupported) {
602 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
603 const auto& [configStatus, config] =
604 mComposerClient->getActiveConfig(getPrimaryDisplayId());
605 EXPECT_TRUE(configStatus.isOk());
606
607 auto status = mComposerClient->setBootDisplayConfig(getPrimaryDisplayId(), config);
608 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000609 EXPECT_NO_FATAL_FAILURE(
610 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
ramindani476314c2022-03-16 00:17:08 +0000611
612 status = mComposerClient->getPreferredBootDisplayConfig(getPrimaryDisplayId()).first;
613 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000614 EXPECT_NO_FATAL_FAILURE(
615 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
ramindani476314c2022-03-16 00:17:08 +0000616
617 status = mComposerClient->clearBootDisplayConfig(getPrimaryDisplayId());
618 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000619 EXPECT_NO_FATAL_FAILURE(
620 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
ramindani476314c2022-03-16 00:17:08 +0000621 }
622}
623
ramindani431aad42022-02-01 21:44:29 +0000624TEST_P(GraphicsComposerAidlTest, SetAutoLowLatencyMode_BadDisplay) {
625 auto status = mComposerClient->setAutoLowLatencyMode(getInvalidDisplayId(), /*isEnabled*/ true);
626 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000627 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani431aad42022-02-01 21:44:29 +0000628
629 status = mComposerClient->setAutoLowLatencyMode(getInvalidDisplayId(), /*isEnabled*/ false);
630 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000631 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani0291f112021-11-04 03:45:46 +0000632}
633
ramindani431aad42022-02-01 21:44:29 +0000634TEST_P(GraphicsComposerAidlTest, SetAutoLowLatencyMode) {
ramindani0291f112021-11-04 03:45:46 +0000635 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000636 const auto& [status, capabilities] =
637 mComposerClient->getDisplayCapabilities(display.getDisplayId());
638 ASSERT_TRUE(status.isOk());
ramindani0291f112021-11-04 03:45:46 +0000639
640 const bool allmSupport =
641 std::find(capabilities.begin(), capabilities.end(),
642 DisplayCapability::AUTO_LOW_LATENCY_MODE) != capabilities.end();
643
644 if (!allmSupport) {
ramindani431aad42022-02-01 21:44:29 +0000645 const auto& statusIsOn = mComposerClient->setAutoLowLatencyMode(display.getDisplayId(),
646 /*isEnabled*/ true);
647 EXPECT_FALSE(statusIsOn.isOk());
ramindanid5751092022-04-22 22:30:20 +0000648 EXPECT_NO_FATAL_FAILURE(
649 assertServiceSpecificError(statusIsOn, IComposerClient::EX_UNSUPPORTED));
ramindani431aad42022-02-01 21:44:29 +0000650 const auto& statusIsOff = mComposerClient->setAutoLowLatencyMode(display.getDisplayId(),
651 /*isEnabled*/ false);
652 EXPECT_FALSE(statusIsOff.isOk());
ramindanid5751092022-04-22 22:30:20 +0000653 EXPECT_NO_FATAL_FAILURE(
654 assertServiceSpecificError(statusIsOff, IComposerClient::EX_UNSUPPORTED));
ramindani0291f112021-11-04 03:45:46 +0000655 GTEST_SUCCEED() << "Auto Low Latency Mode is not supported on display "
ramindani431aad42022-02-01 21:44:29 +0000656 << std::to_string(display.getDisplayId()) << ", skipping test";
ramindani0291f112021-11-04 03:45:46 +0000657 return;
658 }
659
ramindani431aad42022-02-01 21:44:29 +0000660 EXPECT_TRUE(mComposerClient->setAutoLowLatencyMode(display.getDisplayId(), true).isOk());
661 EXPECT_TRUE(mComposerClient->setAutoLowLatencyMode(display.getDisplayId(), false).isOk());
ramindani0291f112021-11-04 03:45:46 +0000662 }
663}
664
ramindani431aad42022-02-01 21:44:29 +0000665TEST_P(GraphicsComposerAidlTest, GetSupportedContentTypes_BadDisplay) {
666 const auto& [status, _] = mComposerClient->getSupportedContentTypes(getInvalidDisplayId());
667
668 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000669 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani0291f112021-11-04 03:45:46 +0000670}
671
ramindani431aad42022-02-01 21:44:29 +0000672TEST_P(GraphicsComposerAidlTest, GetSupportedContentTypes) {
ramindani0291f112021-11-04 03:45:46 +0000673 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000674 const auto& [status, supportedContentTypes] =
675 mComposerClient->getSupportedContentTypes(display.getDisplayId());
676 ASSERT_TRUE(status.isOk());
ramindani0291f112021-11-04 03:45:46 +0000677
678 const bool noneSupported =
679 std::find(supportedContentTypes.begin(), supportedContentTypes.end(),
680 ContentType::NONE) != supportedContentTypes.end();
ramindani431aad42022-02-01 21:44:29 +0000681
ramindani0291f112021-11-04 03:45:46 +0000682 EXPECT_FALSE(noneSupported);
683 }
684}
685
ramindani431aad42022-02-01 21:44:29 +0000686TEST_P(GraphicsComposerAidlTest, SetContentTypeNoneAlwaysAccepted) {
ramindani0291f112021-11-04 03:45:46 +0000687 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000688 EXPECT_TRUE(
689 mComposerClient->setContentType(display.getDisplayId(), ContentType::NONE).isOk());
ramindani0291f112021-11-04 03:45:46 +0000690 }
691}
692
ramindani431aad42022-02-01 21:44:29 +0000693TEST_P(GraphicsComposerAidlTest, SetContentType_BadDisplay) {
ramindani0291f112021-11-04 03:45:46 +0000694 constexpr ContentType types[] = {ContentType::NONE, ContentType::GRAPHICS, ContentType::PHOTO,
695 ContentType::CINEMA, ContentType::GAME};
696 for (const auto& type : types) {
ramindani431aad42022-02-01 21:44:29 +0000697 const auto& status = mComposerClient->setContentType(getInvalidDisplayId(), type);
ramindani0291f112021-11-04 03:45:46 +0000698
ramindani431aad42022-02-01 21:44:29 +0000699 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000700 EXPECT_NO_FATAL_FAILURE(
701 assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani0291f112021-11-04 03:45:46 +0000702 }
703}
704
ramindani431aad42022-02-01 21:44:29 +0000705TEST_P(GraphicsComposerAidlTest, SetGraphicsContentType) {
ramindani0291f112021-11-04 03:45:46 +0000706 Test_setContentType(ContentType::GRAPHICS, "GRAPHICS");
707}
708
ramindani431aad42022-02-01 21:44:29 +0000709TEST_P(GraphicsComposerAidlTest, SetPhotoContentType) {
ramindani0291f112021-11-04 03:45:46 +0000710 Test_setContentType(ContentType::PHOTO, "PHOTO");
711}
712
ramindani431aad42022-02-01 21:44:29 +0000713TEST_P(GraphicsComposerAidlTest, SetCinemaContentType) {
ramindani0291f112021-11-04 03:45:46 +0000714 Test_setContentType(ContentType::CINEMA, "CINEMA");
715}
716
ramindani431aad42022-02-01 21:44:29 +0000717TEST_P(GraphicsComposerAidlTest, SetGameContentType) {
ramindani0291f112021-11-04 03:45:46 +0000718 Test_setContentType(ContentType::GAME, "GAME");
719}
720
ramindanic2b8d082021-11-06 02:03:50 +0000721TEST_P(GraphicsComposerAidlTest, CreateVirtualDisplay) {
ramindani431aad42022-02-01 21:44:29 +0000722 const auto& [status, maxVirtualDisplayCount] = mComposerClient->getMaxVirtualDisplayCount();
723 EXPECT_TRUE(status.isOk());
724
ramindanic2b8d082021-11-06 02:03:50 +0000725 if (maxVirtualDisplayCount == 0) {
726 GTEST_SUCCEED() << "no virtual display support";
727 return;
728 }
729
ramindani431aad42022-02-01 21:44:29 +0000730 const auto& [virtualDisplayStatus, virtualDisplay] = mComposerClient->createVirtualDisplay(
731 /*width*/ 64, /*height*/ 64, common::PixelFormat::IMPLEMENTATION_DEFINED,
732 kBufferSlotCount);
ramindanic2b8d082021-11-06 02:03:50 +0000733
ramindani431aad42022-02-01 21:44:29 +0000734 ASSERT_TRUE(virtualDisplayStatus.isOk());
ramindanic2b8d082021-11-06 02:03:50 +0000735 EXPECT_TRUE(mComposerClient->destroyVirtualDisplay(virtualDisplay.display).isOk());
736}
737
ramindani431aad42022-02-01 21:44:29 +0000738TEST_P(GraphicsComposerAidlTest, DestroyVirtualDisplay_BadDisplay) {
739 const auto& [status, maxDisplayCount] = mComposerClient->getMaxVirtualDisplayCount();
740 EXPECT_TRUE(status.isOk());
741
ramindani2740bac2021-11-24 22:58:32 +0000742 if (maxDisplayCount == 0) {
743 GTEST_SUCCEED() << "no virtual display support";
744 return;
745 }
ramindani2740bac2021-11-24 22:58:32 +0000746
ramindani431aad42022-02-01 21:44:29 +0000747 const auto& destroyStatus = mComposerClient->destroyVirtualDisplay(getInvalidDisplayId());
748
749 EXPECT_FALSE(destroyStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000750 EXPECT_NO_FATAL_FAILURE(
751 assertServiceSpecificError(destroyStatus, IComposerClient::EX_BAD_DISPLAY));
ramindani2740bac2021-11-24 22:58:32 +0000752}
753
754TEST_P(GraphicsComposerAidlTest, CreateLayer) {
ramindani431aad42022-02-01 21:44:29 +0000755 const auto& [status, layer] =
756 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
ramindani2740bac2021-11-24 22:58:32 +0000757
ramindani431aad42022-02-01 21:44:29 +0000758 EXPECT_TRUE(status.isOk());
759 EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
ramindani2740bac2021-11-24 22:58:32 +0000760}
761
ramindani431aad42022-02-01 21:44:29 +0000762TEST_P(GraphicsComposerAidlTest, CreateLayer_BadDisplay) {
763 const auto& [status, _] = mComposerClient->createLayer(getInvalidDisplayId(), kBufferSlotCount);
ramindani2740bac2021-11-24 22:58:32 +0000764
ramindani431aad42022-02-01 21:44:29 +0000765 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000766 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani2740bac2021-11-24 22:58:32 +0000767}
768
ramindani431aad42022-02-01 21:44:29 +0000769TEST_P(GraphicsComposerAidlTest, DestroyLayer_BadDisplay) {
770 const auto& [status, layer] =
771 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
772 EXPECT_TRUE(status.isOk());
ramindani2740bac2021-11-24 22:58:32 +0000773
ramindani431aad42022-02-01 21:44:29 +0000774 const auto& destroyStatus = mComposerClient->destroyLayer(getInvalidDisplayId(), layer);
ramindani2740bac2021-11-24 22:58:32 +0000775
ramindani431aad42022-02-01 21:44:29 +0000776 EXPECT_FALSE(destroyStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000777 EXPECT_NO_FATAL_FAILURE(
778 assertServiceSpecificError(destroyStatus, IComposerClient::EX_BAD_DISPLAY));
ramindani431aad42022-02-01 21:44:29 +0000779 ASSERT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
ramindani2740bac2021-11-24 22:58:32 +0000780}
781
ramindani431aad42022-02-01 21:44:29 +0000782TEST_P(GraphicsComposerAidlTest, DestroyLayer_BadLayerError) {
ramindani2740bac2021-11-24 22:58:32 +0000783 // We haven't created any layers yet, so any id should be invalid
ramindani431aad42022-02-01 21:44:29 +0000784 const auto& status = mComposerClient->destroyLayer(getPrimaryDisplayId(), /*layer*/ 1);
ramindani2740bac2021-11-24 22:58:32 +0000785
ramindani431aad42022-02-01 21:44:29 +0000786 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000787 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_LAYER));
ramindani2740bac2021-11-24 22:58:32 +0000788}
789
ramindani431aad42022-02-01 21:44:29 +0000790TEST_P(GraphicsComposerAidlTest, GetActiveConfig_BadDisplay) {
791 const auto& [status, _] = mComposerClient->getActiveConfig(getInvalidDisplayId());
ramindani2740bac2021-11-24 22:58:32 +0000792
ramindani431aad42022-02-01 21:44:29 +0000793 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000794 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani2740bac2021-11-24 22:58:32 +0000795}
796
797TEST_P(GraphicsComposerAidlTest, GetDisplayConfig) {
ramindani431aad42022-02-01 21:44:29 +0000798 const auto& [status, _] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
799 EXPECT_TRUE(status.isOk());
ramindani2740bac2021-11-24 22:58:32 +0000800}
801
ramindani431aad42022-02-01 21:44:29 +0000802TEST_P(GraphicsComposerAidlTest, GetDisplayConfig_BadDisplay) {
803 const auto& [status, _] = mComposerClient->getDisplayConfigs(getInvalidDisplayId());
ramindani2740bac2021-11-24 22:58:32 +0000804
ramindani431aad42022-02-01 21:44:29 +0000805 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000806 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani2740bac2021-11-24 22:58:32 +0000807}
808
809TEST_P(GraphicsComposerAidlTest, GetDisplayName) {
ramindani431aad42022-02-01 21:44:29 +0000810 const auto& [status, _] = mComposerClient->getDisplayName(getPrimaryDisplayId());
811 EXPECT_TRUE(status.isOk());
ramindani2740bac2021-11-24 22:58:32 +0000812}
813
Sally Qi8ec063f2022-11-12 11:18:56 -0800814TEST_P(GraphicsComposerAidlTest, GetOverlaySupport) {
Sally Qic2c392f2023-01-13 14:50:20 -0800815 const auto& [status, properties] = mComposerClient->getOverlaySupport();
Sally Qi2600d342022-08-16 12:46:17 -0700816 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
817 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
818 GTEST_SUCCEED() << "getOverlaySupport is not supported";
819 return;
820 }
821
822 ASSERT_TRUE(status.isOk());
Sally Qic2c392f2023-01-13 14:50:20 -0800823 for (const auto& i : properties.combinations) {
824 for (const auto standard : i.standards) {
825 const auto val = static_cast<int32_t>(standard) &
826 static_cast<int32_t>(common::Dataspace::STANDARD_MASK);
827 ASSERT_TRUE(val == static_cast<int32_t>(standard));
828 }
829 for (const auto transfer : i.transfers) {
830 const auto val = static_cast<int32_t>(transfer) &
831 static_cast<int32_t>(common::Dataspace::TRANSFER_MASK);
832 ASSERT_TRUE(val == static_cast<int32_t>(transfer));
833 }
834 for (const auto range : i.ranges) {
835 const auto val = static_cast<int32_t>(range) &
836 static_cast<int32_t>(common::Dataspace::RANGE_MASK);
837 ASSERT_TRUE(val == static_cast<int32_t>(range));
838 }
839 }
Sally Qi2600d342022-08-16 12:46:17 -0700840}
841
ramindani431aad42022-02-01 21:44:29 +0000842TEST_P(GraphicsComposerAidlTest, GetDisplayPhysicalOrientation_BadDisplay) {
843 const auto& [status, _] = mComposerClient->getDisplayPhysicalOrientation(getInvalidDisplayId());
Ady Abrahamae12e382022-01-13 18:06:21 -0800844
ramindani431aad42022-02-01 21:44:29 +0000845 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000846 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
Ady Abrahamae12e382022-01-13 18:06:21 -0800847}
848
849TEST_P(GraphicsComposerAidlTest, GetDisplayPhysicalOrientation) {
850 const auto allowedDisplayOrientations = std::array<Transform, 4>{
851 Transform::NONE,
852 Transform::ROT_90,
853 Transform::ROT_180,
854 Transform::ROT_270,
855 };
856
ramindani431aad42022-02-01 21:44:29 +0000857 const auto& [status, displayOrientation] =
858 mComposerClient->getDisplayPhysicalOrientation(getPrimaryDisplayId());
Ady Abrahamae12e382022-01-13 18:06:21 -0800859
ramindani431aad42022-02-01 21:44:29 +0000860 EXPECT_TRUE(status.isOk());
Ady Abrahamae12e382022-01-13 18:06:21 -0800861 EXPECT_NE(std::find(allowedDisplayOrientations.begin(), allowedDisplayOrientations.end(),
862 displayOrientation),
863 allowedDisplayOrientations.end());
864}
865
ramindani2740bac2021-11-24 22:58:32 +0000866TEST_P(GraphicsComposerAidlTest, SetClientTargetSlotCount) {
ramindani431aad42022-02-01 21:44:29 +0000867 EXPECT_TRUE(mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kBufferSlotCount)
868 .isOk());
ramindani2740bac2021-11-24 22:58:32 +0000869}
870
871TEST_P(GraphicsComposerAidlTest, SetActiveConfig) {
ramindani431aad42022-02-01 21:44:29 +0000872 const auto& [status, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
873 EXPECT_TRUE(status.isOk());
874
875 for (const auto& config : configs) {
876 auto display = getEditablePrimaryDisplay();
877 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config).isOk());
878 const auto& [configStatus, config1] =
879 mComposerClient->getActiveConfig(getPrimaryDisplayId());
880 EXPECT_TRUE(configStatus.isOk());
ramindani2740bac2021-11-24 22:58:32 +0000881 EXPECT_EQ(config, config1);
882 }
883}
884
885TEST_P(GraphicsComposerAidlTest, SetActiveConfigPowerCycle) {
ramindani431aad42022-02-01 21:44:29 +0000886 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
887 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
ramindani2740bac2021-11-24 22:58:32 +0000888
ramindani431aad42022-02-01 21:44:29 +0000889 const auto& [status, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
890 EXPECT_TRUE(status.isOk());
891
892 for (const auto& config : configs) {
893 auto display = getEditablePrimaryDisplay();
894 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config).isOk());
895 const auto& [config1Status, config1] =
896 mComposerClient->getActiveConfig(getPrimaryDisplayId());
897 EXPECT_TRUE(config1Status.isOk());
ramindani2740bac2021-11-24 22:58:32 +0000898 EXPECT_EQ(config, config1);
899
ramindani431aad42022-02-01 21:44:29 +0000900 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
901 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
902 const auto& [config2Status, config2] =
903 mComposerClient->getActiveConfig(getPrimaryDisplayId());
904 EXPECT_TRUE(config2Status.isOk());
905 EXPECT_EQ(config, config2);
ramindani2740bac2021-11-24 22:58:32 +0000906 }
907}
908
ramindani2740bac2021-11-24 22:58:32 +0000909TEST_P(GraphicsComposerAidlTest, SetPowerModeUnsupported) {
ramindani431aad42022-02-01 21:44:29 +0000910 const auto& [status, capabilities] =
911 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
912 ASSERT_TRUE(status.isOk());
913
Ady Abraham6679baf2021-12-08 18:28:27 -0800914 const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
915 DisplayCapability::DOZE) != capabilities.end();
916 const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
917 DisplayCapability::SUSPEND) != capabilities.end();
ramindani2740bac2021-11-24 22:58:32 +0000918
ramindani431aad42022-02-01 21:44:29 +0000919 if (!isDozeSupported) {
920 const auto& powerModeDozeStatus =
921 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE);
922 EXPECT_FALSE(powerModeDozeStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000923 EXPECT_NO_FATAL_FAILURE(
924 assertServiceSpecificError(powerModeDozeStatus, IComposerClient::EX_UNSUPPORTED));
ramindani431aad42022-02-01 21:44:29 +0000925
926 const auto& powerModeDozeSuspendStatus =
927 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE_SUSPEND);
928 EXPECT_FALSE(powerModeDozeSuspendStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000929 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeDozeSuspendStatus,
930 IComposerClient::EX_UNSUPPORTED));
ramindani2740bac2021-11-24 22:58:32 +0000931 }
Ady Abraham6679baf2021-12-08 18:28:27 -0800932
933 if (!isSuspendSupported) {
ramindani431aad42022-02-01 21:44:29 +0000934 const auto& powerModeSuspendStatus =
935 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON_SUSPEND);
936 EXPECT_FALSE(powerModeSuspendStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000937 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeSuspendStatus,
938 IComposerClient::EX_UNSUPPORTED));
Ady Abraham6679baf2021-12-08 18:28:27 -0800939
ramindani431aad42022-02-01 21:44:29 +0000940 const auto& powerModeDozeSuspendStatus =
941 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE_SUSPEND);
942 EXPECT_FALSE(powerModeDozeSuspendStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000943 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeDozeSuspendStatus,
944 IComposerClient::EX_UNSUPPORTED));
Ady Abraham6679baf2021-12-08 18:28:27 -0800945 }
ramindani2740bac2021-11-24 22:58:32 +0000946}
947
948TEST_P(GraphicsComposerAidlTest, SetVsyncEnabled) {
ramindani431aad42022-02-01 21:44:29 +0000949 mComposerClient->setVsyncAllowed(true);
ramindani2740bac2021-11-24 22:58:32 +0000950
ramindani431aad42022-02-01 21:44:29 +0000951 EXPECT_TRUE(mComposerClient->setVsync(getPrimaryDisplayId(), true).isOk());
ramindani2740bac2021-11-24 22:58:32 +0000952 usleep(60 * 1000);
ramindani431aad42022-02-01 21:44:29 +0000953 EXPECT_TRUE(mComposerClient->setVsync(getPrimaryDisplayId(), false).isOk());
ramindani2740bac2021-11-24 22:58:32 +0000954
ramindani431aad42022-02-01 21:44:29 +0000955 mComposerClient->setVsyncAllowed(false);
ramindani2740bac2021-11-24 22:58:32 +0000956}
957
ramindanic2b8d082021-11-06 02:03:50 +0000958TEST_P(GraphicsComposerAidlTest, SetPowerMode) {
ramindani431aad42022-02-01 21:44:29 +0000959 const auto& [status, capabilities] =
960 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
961 ASSERT_TRUE(status.isOk());
962
Ady Abraham6679baf2021-12-08 18:28:27 -0800963 const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
964 DisplayCapability::DOZE) != capabilities.end();
965 const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
966 DisplayCapability::SUSPEND) != capabilities.end();
967
ramindanic2b8d082021-11-06 02:03:50 +0000968 std::vector<PowerMode> modes;
969 modes.push_back(PowerMode::OFF);
ramindanic2b8d082021-11-06 02:03:50 +0000970 modes.push_back(PowerMode::ON);
971
Ady Abraham6679baf2021-12-08 18:28:27 -0800972 if (isSuspendSupported) {
973 modes.push_back(PowerMode::ON_SUSPEND);
974 }
975
ramindani770d7082021-11-30 00:36:42 +0000976 if (isDozeSupported) {
977 modes.push_back(PowerMode::DOZE);
Ady Abraham6679baf2021-12-08 18:28:27 -0800978 }
979
980 if (isSuspendSupported && isDozeSupported) {
ramindani770d7082021-11-30 00:36:42 +0000981 modes.push_back(PowerMode::DOZE_SUSPEND);
982 }
983
ramindanic2b8d082021-11-06 02:03:50 +0000984 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +0000985 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindanic2b8d082021-11-06 02:03:50 +0000986 }
987}
988
989TEST_P(GraphicsComposerAidlTest, SetPowerModeVariations) {
ramindani431aad42022-02-01 21:44:29 +0000990 const auto& [status, capabilities] =
991 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
992 ASSERT_TRUE(status.isOk());
993
Ady Abraham6679baf2021-12-08 18:28:27 -0800994 const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
995 DisplayCapability::DOZE) != capabilities.end();
996 const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
997 DisplayCapability::SUSPEND) != capabilities.end();
998
ramindanic2b8d082021-11-06 02:03:50 +0000999 std::vector<PowerMode> modes;
1000
1001 modes.push_back(PowerMode::OFF);
ramindani770d7082021-11-30 00:36:42 +00001002 modes.push_back(PowerMode::ON);
ramindanic2b8d082021-11-06 02:03:50 +00001003 modes.push_back(PowerMode::OFF);
ramindanic2b8d082021-11-06 02:03:50 +00001004 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001005 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindanic2b8d082021-11-06 02:03:50 +00001006 }
ramindani770d7082021-11-30 00:36:42 +00001007 modes.clear();
ramindanic2b8d082021-11-06 02:03:50 +00001008
ramindani770d7082021-11-30 00:36:42 +00001009 modes.push_back(PowerMode::OFF);
1010 modes.push_back(PowerMode::OFF);
1011 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001012 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindani770d7082021-11-30 00:36:42 +00001013 }
ramindanic2b8d082021-11-06 02:03:50 +00001014 modes.clear();
1015
1016 modes.push_back(PowerMode::ON);
1017 modes.push_back(PowerMode::ON);
ramindanic2b8d082021-11-06 02:03:50 +00001018 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001019 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindanic2b8d082021-11-06 02:03:50 +00001020 }
ramindanic2b8d082021-11-06 02:03:50 +00001021 modes.clear();
1022
Ady Abraham6679baf2021-12-08 18:28:27 -08001023 if (isSuspendSupported) {
1024 modes.push_back(PowerMode::ON_SUSPEND);
1025 modes.push_back(PowerMode::ON_SUSPEND);
1026 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001027 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
Ady Abraham6679baf2021-12-08 18:28:27 -08001028 }
1029 modes.clear();
ramindanic2b8d082021-11-06 02:03:50 +00001030 }
1031
ramindanic2b8d082021-11-06 02:03:50 +00001032 if (isDozeSupported) {
ramindanic2b8d082021-11-06 02:03:50 +00001033 modes.push_back(PowerMode::DOZE);
1034 modes.push_back(PowerMode::DOZE);
ramindanic2b8d082021-11-06 02:03:50 +00001035 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001036 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindanic2b8d082021-11-06 02:03:50 +00001037 }
ramindanic2b8d082021-11-06 02:03:50 +00001038 modes.clear();
Ady Abraham6679baf2021-12-08 18:28:27 -08001039 }
ramindanic2b8d082021-11-06 02:03:50 +00001040
Ady Abraham6679baf2021-12-08 18:28:27 -08001041 if (isSuspendSupported && isDozeSupported) {
ramindanic2b8d082021-11-06 02:03:50 +00001042 modes.push_back(PowerMode::DOZE_SUSPEND);
1043 modes.push_back(PowerMode::DOZE_SUSPEND);
ramindanic2b8d082021-11-06 02:03:50 +00001044 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001045 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindanic2b8d082021-11-06 02:03:50 +00001046 }
Ady Abraham6679baf2021-12-08 18:28:27 -08001047 modes.clear();
ramindanic2b8d082021-11-06 02:03:50 +00001048 }
1049}
1050
ramindani431aad42022-02-01 21:44:29 +00001051TEST_P(GraphicsComposerAidlTest, SetPowerMode_BadDisplay) {
1052 const auto& status = mComposerClient->setPowerMode(getInvalidDisplayId(), PowerMode::ON);
ramindanic2b8d082021-11-06 02:03:50 +00001053
ramindani431aad42022-02-01 21:44:29 +00001054 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00001055 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindanic2b8d082021-11-06 02:03:50 +00001056}
1057
ramindani431aad42022-02-01 21:44:29 +00001058TEST_P(GraphicsComposerAidlTest, SetPowerMode_BadParameter) {
1059 const auto& status =
1060 mComposerClient->setPowerMode(getPrimaryDisplayId(), static_cast<PowerMode>(-1));
ramindanic2b8d082021-11-06 02:03:50 +00001061
ramindani431aad42022-02-01 21:44:29 +00001062 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00001063 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
ramindanic2b8d082021-11-06 02:03:50 +00001064}
1065
ramindanic2b8d082021-11-06 02:03:50 +00001066TEST_P(GraphicsComposerAidlTest, GetDataspaceSaturationMatrix) {
ramindani431aad42022-02-01 21:44:29 +00001067 const auto& [status, matrix] =
1068 mComposerClient->getDataspaceSaturationMatrix(common::Dataspace::SRGB_LINEAR);
1069 ASSERT_TRUE(status.isOk());
1070 ASSERT_EQ(16, matrix.size()); // matrix should not be empty if call succeeded.
ramindanideb059e2021-11-18 01:57:25 +00001071
ramindanic2b8d082021-11-06 02:03:50 +00001072 // the last row is known
ramindani431aad42022-02-01 21:44:29 +00001073 EXPECT_EQ(0.0f, matrix[12]);
1074 EXPECT_EQ(0.0f, matrix[13]);
1075 EXPECT_EQ(0.0f, matrix[14]);
1076 EXPECT_EQ(1.0f, matrix[15]);
ramindanic2b8d082021-11-06 02:03:50 +00001077}
1078
ramindani431aad42022-02-01 21:44:29 +00001079TEST_P(GraphicsComposerAidlTest, GetDataspaceSaturationMatrix_BadParameter) {
1080 const auto& [status, matrix] =
1081 mComposerClient->getDataspaceSaturationMatrix(common::Dataspace::UNKNOWN);
ramindanic2b8d082021-11-06 02:03:50 +00001082
ramindani431aad42022-02-01 21:44:29 +00001083 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00001084 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
ramindanic2b8d082021-11-06 02:03:50 +00001085}
1086
ramindanidcfe3a82021-11-29 17:00:31 +00001087// Tests for Command.
1088class GraphicsComposerAidlCommandTest : public GraphicsComposerAidlTest {
1089 protected:
ramindanidcfe3a82021-11-29 17:00:31 +00001090 void TearDown() override {
Ady Abraham3192f3d2021-12-03 16:08:56 -08001091 const auto errors = mReader.takeErrors();
1092 ASSERT_TRUE(mReader.takeErrors().empty());
ramindani431aad42022-02-01 21:44:29 +00001093 ASSERT_TRUE(mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty());
Ady Abraham3192f3d2021-12-03 16:08:56 -08001094
ramindanidcfe3a82021-11-29 17:00:31 +00001095 ASSERT_NO_FATAL_FAILURE(GraphicsComposerAidlTest::TearDown());
1096 }
1097
1098 void execute() {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001099 std::vector<CommandResultPayload> payloads;
1100 for (auto& [_, writer] : mWriters) {
1101 const auto& commands = writer.getPendingCommands();
1102 if (commands.empty()) {
1103 writer.reset();
1104 continue;
1105 }
1106
1107 auto [status, results] = mComposerClient->executeCommands(commands);
1108 ASSERT_TRUE(status.isOk()) << "executeCommands failed " << status.getDescription();
1109 writer.reset();
1110
1111 payloads.reserve(payloads.size() + results.size());
1112 payloads.insert(payloads.end(), std::make_move_iterator(results.begin()),
1113 std::make_move_iterator(results.end()));
ramindanidcfe3a82021-11-29 17:00:31 +00001114 }
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001115 mReader.parse(std::move(payloads));
ramindanidcfe3a82021-11-29 17:00:31 +00001116 }
1117
1118 static inline auto toTimePoint(nsecs_t time) {
1119 return std::chrono::time_point<std::chrono::steady_clock>(std::chrono::nanoseconds(time));
1120 }
1121
ramindanidcfe3a82021-11-29 17:00:31 +00001122 void forEachTwoConfigs(int64_t display, std::function<void(int32_t, int32_t)> func) {
ramindani431aad42022-02-01 21:44:29 +00001123 const auto& [status, displayConfigs] = mComposerClient->getDisplayConfigs(display);
1124 ASSERT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001125 for (const int32_t config1 : displayConfigs) {
1126 for (const int32_t config2 : displayConfigs) {
1127 if (config1 != config2) {
1128 func(config1, config2);
1129 }
1130 }
1131 }
1132 }
1133
1134 void waitForVsyncPeriodChange(int64_t display, const VsyncPeriodChangeTimeline& timeline,
1135 int64_t desiredTimeNanos, int64_t oldPeriodNanos,
1136 int64_t newPeriodNanos) {
1137 const auto kChangeDeadline = toTimePoint(timeline.newVsyncAppliedTimeNanos) + 100ms;
1138 while (std::chrono::steady_clock::now() <= kChangeDeadline) {
ramindani431aad42022-02-01 21:44:29 +00001139 const auto& [status, vsyncPeriodNanos] =
1140 mComposerClient->getDisplayVsyncPeriod(display);
1141 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001142 if (systemTime() <= desiredTimeNanos) {
1143 EXPECT_EQ(vsyncPeriodNanos, oldPeriodNanos);
1144 } else if (vsyncPeriodNanos == newPeriodNanos) {
1145 break;
1146 }
1147 std::this_thread::sleep_for(std::chrono::nanoseconds(oldPeriodNanos));
1148 }
1149 }
1150
Brian Lindahlca3eef22022-12-09 00:32:11 -07001151 sp<GraphicBuffer> allocate(uint32_t width, uint32_t height,
1152 ::android::PixelFormat pixelFormat) {
ramindanidcfe3a82021-11-29 17:00:31 +00001153 return sp<GraphicBuffer>::make(
Brian Lindahlca3eef22022-12-09 00:32:11 -07001154 width, height, pixelFormat, /*layerCount*/ 1U,
1155 static_cast<uint64_t>(common::BufferUsage::CPU_WRITE_OFTEN) |
1156 static_cast<uint64_t>(common::BufferUsage::CPU_READ_OFTEN) |
1157 static_cast<uint64_t>(common::BufferUsage::COMPOSER_OVERLAY),
ramindanidcfe3a82021-11-29 17:00:31 +00001158 "VtsHalGraphicsComposer3_TargetTest");
1159 }
1160
Brian Lindahlca3eef22022-12-09 00:32:11 -07001161 sp<GraphicBuffer> allocate(::android::PixelFormat pixelFormat) {
1162 return allocate(static_cast<uint32_t>(getPrimaryDisplay().getDisplayWidth()),
1163 static_cast<uint32_t>(getPrimaryDisplay().getDisplayHeight()), pixelFormat);
1164 }
1165
ramindanidcfe3a82021-11-29 17:00:31 +00001166 void sendRefreshFrame(const VtsDisplay& display, const VsyncPeriodChangeTimeline* timeline) {
1167 if (timeline != nullptr) {
1168 // Refresh time should be before newVsyncAppliedTimeNanos
1169 EXPECT_LT(timeline->refreshTimeNanos, timeline->newVsyncAppliedTimeNanos);
1170
1171 std::this_thread::sleep_until(toTimePoint(timeline->refreshTimeNanos));
1172 }
1173
ramindani431aad42022-02-01 21:44:29 +00001174 EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::ON).isOk());
1175 EXPECT_TRUE(mComposerClient
1176 ->setColorMode(display.getDisplayId(), ColorMode::NATIVE,
1177 RenderIntent::COLORIMETRIC)
1178 .isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001179
ramindani431aad42022-02-01 21:44:29 +00001180 const auto& [status, layer] =
1181 mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount);
1182 EXPECT_TRUE(status.isOk());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001183 auto& writer = getWriter(display.getDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001184 {
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001185 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindanidcfe3a82021-11-29 17:00:31 +00001186 ASSERT_NE(nullptr, buffer);
1187 ASSERT_EQ(::android::OK, buffer->initCheck());
1188 ASSERT_NE(nullptr, buffer->handle);
1189
ramindani431aad42022-02-01 21:44:29 +00001190 configureLayer(display, layer, Composition::DEVICE, display.getFrameRect(),
1191 display.getCrop());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001192 writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, buffer->handle,
1193 /*acquireFence*/ -1);
1194 writer.setLayerDataspace(display.getDisplayId(), layer, common::Dataspace::UNKNOWN);
ramindanidcfe3a82021-11-29 17:00:31 +00001195
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001196 writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp);
ramindanidcfe3a82021-11-29 17:00:31 +00001197 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001198 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001199
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001200 writer.presentDisplay(display.getDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001201 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001202 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001203 }
1204
1205 {
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001206 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindanidcfe3a82021-11-29 17:00:31 +00001207 ASSERT_NE(nullptr, buffer->handle);
1208
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001209 writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, buffer->handle,
1210 /*acquireFence*/ -1);
1211 writer.setLayerSurfaceDamage(display.getDisplayId(), layer,
1212 std::vector<Rect>(1, {0, 0, 10, 10}));
1213 writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp);
ramindanidcfe3a82021-11-29 17:00:31 +00001214 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001215 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001216
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001217 writer.presentDisplay(display.getDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001218 execute();
1219 }
1220
ramindani431aad42022-02-01 21:44:29 +00001221 EXPECT_TRUE(mComposerClient->destroyLayer(display.getDisplayId(), layer).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001222 }
1223
Ady Abraham72c5b502021-12-10 17:23:39 -08001224 sp<::android::Fence> presentAndGetFence(
1225 std::optional<ClockMonotonicTimestamp> expectedPresentTime) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001226 auto& writer = getWriter(getPrimaryDisplayId());
1227 writer.validateDisplay(getPrimaryDisplayId(), expectedPresentTime);
Ady Abraham72c5b502021-12-10 17:23:39 -08001228 execute();
1229 EXPECT_TRUE(mReader.takeErrors().empty());
1230
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001231 writer.presentDisplay(getPrimaryDisplayId());
Ady Abraham72c5b502021-12-10 17:23:39 -08001232 execute();
1233 EXPECT_TRUE(mReader.takeErrors().empty());
1234
ramindani431aad42022-02-01 21:44:29 +00001235 auto presentFence = mReader.takePresentFence(getPrimaryDisplayId());
Ady Abraham46219f52021-12-20 09:44:31 -08001236 // take ownership
1237 const int fenceOwner = presentFence.get();
1238 *presentFence.getR() = -1;
1239 EXPECT_NE(-1, fenceOwner);
1240 return sp<::android::Fence>::make(fenceOwner);
Ady Abraham72c5b502021-12-10 17:23:39 -08001241 }
1242
1243 int32_t getVsyncPeriod() {
ramindani431aad42022-02-01 21:44:29 +00001244 const auto& [status, activeConfig] =
1245 mComposerClient->getActiveConfig(getPrimaryDisplayId());
1246 EXPECT_TRUE(status.isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001247
ramindani431aad42022-02-01 21:44:29 +00001248 const auto& [vsyncPeriodStatus, vsyncPeriod] = mComposerClient->getDisplayAttribute(
1249 getPrimaryDisplayId(), activeConfig, DisplayAttribute::VSYNC_PERIOD);
1250 EXPECT_TRUE(vsyncPeriodStatus.isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001251 return vsyncPeriod;
1252 }
1253
1254 int64_t createOnScreenLayer() {
ramindani431aad42022-02-01 21:44:29 +00001255 const auto& [status, layer] =
1256 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1257 EXPECT_TRUE(status.isOk());
1258 Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
1259 getPrimaryDisplay().getDisplayHeight()};
1260 FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
1261 (float)getPrimaryDisplay().getDisplayHeight()};
1262 configureLayer(getPrimaryDisplay(), layer, Composition::DEVICE, displayFrame, cropRect);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001263 auto& writer = getWriter(getPrimaryDisplayId());
1264 writer.setLayerDataspace(getPrimaryDisplayId(), layer, common::Dataspace::UNKNOWN);
Ady Abraham72c5b502021-12-10 17:23:39 -08001265 return layer;
1266 }
1267
Midas Chiena0b56bd2022-01-13 23:27:33 +08001268 bool hasDisplayCapability(int64_t display, DisplayCapability cap) {
ramindani431aad42022-02-01 21:44:29 +00001269 const auto& [status, capabilities] = mComposerClient->getDisplayCapabilities(display);
1270 EXPECT_TRUE(status.isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08001271
1272 return std::find(capabilities.begin(), capabilities.end(), cap) != capabilities.end();
1273 }
1274
ramindanidcfe3a82021-11-29 17:00:31 +00001275 void Test_setActiveConfigWithConstraints(const TestParameters& params) {
1276 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +00001277 forEachTwoConfigs(display.getDisplayId(), [&](int32_t config1, int32_t config2) {
1278 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001279 sendRefreshFrame(display, nullptr);
1280
ramindani431aad42022-02-01 21:44:29 +00001281 const auto displayConfigGroup1 = display.getDisplayConfig(config1);
1282 int32_t vsyncPeriod1 = displayConfigGroup1.vsyncPeriod;
1283 int32_t configGroup1 = displayConfigGroup1.configGroup;
1284
1285 const auto displayConfigGroup2 = display.getDisplayConfig(config2);
1286 int32_t vsyncPeriod2 = displayConfigGroup2.vsyncPeriod;
1287 int32_t configGroup2 = displayConfigGroup2.configGroup;
ramindanidcfe3a82021-11-29 17:00:31 +00001288
1289 if (vsyncPeriod1 == vsyncPeriod2) {
1290 return; // continue
1291 }
1292
1293 // We don't allow delayed change when changing config groups
1294 if (params.delayForChange > 0 && configGroup1 != configGroup2) {
1295 return; // continue
1296 }
1297
ramindanidcfe3a82021-11-29 17:00:31 +00001298 VsyncPeriodChangeConstraints constraints = {
1299 .desiredTimeNanos = systemTime() + params.delayForChange,
1300 .seamlessRequired = false};
ramindani431aad42022-02-01 21:44:29 +00001301 const auto& [status, timeline] = mComposerClient->setActiveConfigWithConstraints(
1302 &display, config2, constraints);
1303 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001304
1305 EXPECT_TRUE(timeline.newVsyncAppliedTimeNanos >= constraints.desiredTimeNanos);
1306 // Refresh rate should change within a reasonable time
1307 constexpr std::chrono::nanoseconds kReasonableTimeForChange = 1s; // 1 second
1308 EXPECT_TRUE(timeline.newVsyncAppliedTimeNanos - constraints.desiredTimeNanos <=
1309 kReasonableTimeForChange.count());
1310
1311 if (timeline.refreshRequired) {
1312 if (params.refreshMiss) {
1313 // Miss the refresh frame on purpose to make sure the implementation sends a
1314 // callback
1315 std::this_thread::sleep_until(toTimePoint(timeline.refreshTimeNanos) +
1316 100ms);
1317 }
1318 sendRefreshFrame(display, &timeline);
1319 }
ramindani431aad42022-02-01 21:44:29 +00001320 waitForVsyncPeriodChange(display.getDisplayId(), timeline,
1321 constraints.desiredTimeNanos, vsyncPeriod1, vsyncPeriod2);
ramindanidcfe3a82021-11-29 17:00:31 +00001322
1323 // At this point the refresh rate should have changed already, however in rare
1324 // cases the implementation might have missed the deadline. In this case a new
1325 // timeline should have been provided.
ramindani431aad42022-02-01 21:44:29 +00001326 auto newTimeline = mComposerClient->takeLastVsyncPeriodChangeTimeline();
ramindanidcfe3a82021-11-29 17:00:31 +00001327 if (timeline.refreshRequired && params.refreshMiss) {
1328 EXPECT_TRUE(newTimeline.has_value());
1329 }
1330
1331 if (newTimeline.has_value()) {
1332 if (newTimeline->refreshRequired) {
1333 sendRefreshFrame(display, &newTimeline.value());
1334 }
ramindani431aad42022-02-01 21:44:29 +00001335 waitForVsyncPeriodChange(display.getDisplayId(), newTimeline.value(),
ramindanidcfe3a82021-11-29 17:00:31 +00001336 constraints.desiredTimeNanos, vsyncPeriod1,
1337 vsyncPeriod2);
1338 }
1339
ramindani431aad42022-02-01 21:44:29 +00001340 const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanos] =
1341 mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
1342 EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001343 EXPECT_EQ(vsyncPeriodNanos, vsyncPeriod2);
1344 });
1345 }
1346 }
1347
Ady Abraham72c5b502021-12-10 17:23:39 -08001348 void Test_expectedPresentTime(std::optional<int> framesDelay) {
Jason Macnak325e8232022-01-24 14:48:55 -08001349 if (hasCapability(Capability::PRESENT_FENCE_IS_NOT_RELIABLE)) {
1350 GTEST_SUCCEED() << "Device has unreliable present fences capability, skipping";
1351 return;
1352 }
1353
ramindani431aad42022-02-01 21:44:29 +00001354 ASSERT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001355
1356 const auto vsyncPeriod = getVsyncPeriod();
1357
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001358 const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1359 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
Ady Abraham72c5b502021-12-10 17:23:39 -08001360 ASSERT_NE(nullptr, buffer1);
1361 ASSERT_NE(nullptr, buffer2);
1362
1363 const auto layer = createOnScreenLayer();
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001364 auto& writer = getWriter(getPrimaryDisplayId());
1365 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer1->handle,
1366 /*acquireFence*/ -1);
Ady Abraham72c5b502021-12-10 17:23:39 -08001367 const sp<::android::Fence> presentFence1 =
1368 presentAndGetFence(ComposerClientWriter::kNoTimestamp);
1369 presentFence1->waitForever(LOG_TAG);
1370
1371 auto expectedPresentTime = presentFence1->getSignalTime() + vsyncPeriod;
1372 if (framesDelay.has_value()) {
1373 expectedPresentTime += *framesDelay * vsyncPeriod;
1374 }
1375
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001376 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer2->handle,
1377 /*acquireFence*/ -1);
Ady Abraham72c5b502021-12-10 17:23:39 -08001378 const auto setExpectedPresentTime = [&]() -> std::optional<ClockMonotonicTimestamp> {
1379 if (!framesDelay.has_value()) {
1380 return ComposerClientWriter::kNoTimestamp;
1381 } else if (*framesDelay == 0) {
1382 return ClockMonotonicTimestamp{0};
1383 }
1384 return ClockMonotonicTimestamp{expectedPresentTime};
1385 }();
1386
1387 const sp<::android::Fence> presentFence2 = presentAndGetFence(setExpectedPresentTime);
1388 presentFence2->waitForever(LOG_TAG);
1389
1390 const auto actualPresentTime = presentFence2->getSignalTime();
Ady Abrahamdf084f32022-01-10 14:10:23 -08001391 EXPECT_GE(actualPresentTime, expectedPresentTime - vsyncPeriod / 2);
Ady Abraham72c5b502021-12-10 17:23:39 -08001392
ramindani431aad42022-02-01 21:44:29 +00001393 ASSERT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001394 }
1395
ramindani431aad42022-02-01 21:44:29 +00001396 void configureLayer(const VtsDisplay& display, int64_t layer, Composition composition,
1397 const Rect& displayFrame, const FRect& cropRect) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001398 auto& writer = getWriter(display.getDisplayId());
1399 writer.setLayerCompositionType(display.getDisplayId(), layer, composition);
1400 writer.setLayerDisplayFrame(display.getDisplayId(), layer, displayFrame);
1401 writer.setLayerPlaneAlpha(display.getDisplayId(), layer, /*alpha*/ 1);
1402 writer.setLayerSourceCrop(display.getDisplayId(), layer, cropRect);
1403 writer.setLayerTransform(display.getDisplayId(), layer, static_cast<Transform>(0));
1404 writer.setLayerVisibleRegion(display.getDisplayId(), layer,
1405 std::vector<Rect>(1, displayFrame));
1406 writer.setLayerZOrder(display.getDisplayId(), layer, /*z*/ 10);
1407 writer.setLayerBlendMode(display.getDisplayId(), layer, BlendMode::NONE);
1408 writer.setLayerSurfaceDamage(display.getDisplayId(), layer,
1409 std::vector<Rect>(1, displayFrame));
ramindani431aad42022-02-01 21:44:29 +00001410 }
ramindanidcfe3a82021-11-29 17:00:31 +00001411 // clang-format off
1412 const std::array<float, 16> kIdentity = {{
1413 1.0f, 0.0f, 0.0f, 0.0f,
1414 0.0f, 1.0f, 0.0f, 0.0f,
1415 0.0f, 0.0f, 1.0f, 0.0f,
1416 0.0f, 0.0f, 0.0f, 1.0f,
1417 }};
1418 // clang-format on
1419
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001420 ComposerClientWriter& getWriter(int64_t display) {
1421 auto [it, _] = mWriters.try_emplace(display, display);
1422 return it->second;
1423 }
1424
Ady Abraham91c9d1a2021-12-15 18:14:45 -08001425 ComposerClientReader mReader;
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001426
1427 private:
1428 std::unordered_map<int64_t, ComposerClientWriter> mWriters;
ramindanidcfe3a82021-11-29 17:00:31 +00001429};
1430
ramindani431aad42022-02-01 21:44:29 +00001431TEST_P(GraphicsComposerAidlCommandTest, SetColorTransform) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001432 auto& writer = getWriter(getPrimaryDisplayId());
1433 writer.setColorTransform(getPrimaryDisplayId(), kIdentity.data());
ramindanidcfe3a82021-11-29 17:00:31 +00001434 execute();
1435}
1436
1437TEST_P(GraphicsComposerAidlCommandTest, SetLayerColorTransform) {
ramindani431aad42022-02-01 21:44:29 +00001438 const auto& [status, layer] =
1439 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1440 EXPECT_TRUE(status.isOk());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001441 auto& writer = getWriter(getPrimaryDisplayId());
1442 writer.setLayerColorTransform(getPrimaryDisplayId(), layer, kIdentity.data());
ramindanidcfe3a82021-11-29 17:00:31 +00001443 execute();
1444
Ady Abraham3192f3d2021-12-03 16:08:56 -08001445 const auto errors = mReader.takeErrors();
Jason Macnak062bc9a2022-01-20 15:00:09 -08001446 if (errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_UNSUPPORTED) {
ramindanidcfe3a82021-11-29 17:00:31 +00001447 GTEST_SUCCEED() << "setLayerColorTransform is not supported";
1448 return;
1449 }
1450}
1451
Alec Mouri60564e12021-12-09 18:48:20 -08001452TEST_P(GraphicsComposerAidlCommandTest, SetDisplayBrightness) {
ramindani431aad42022-02-01 21:44:29 +00001453 const auto& [status, capabilities] =
1454 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
1455 ASSERT_TRUE(status.isOk());
Alec Mouri60564e12021-12-09 18:48:20 -08001456 bool brightnessSupport = std::find(capabilities.begin(), capabilities.end(),
1457 DisplayCapability::BRIGHTNESS) != capabilities.end();
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001458 auto& writer = getWriter(getPrimaryDisplayId());
Alec Mouri60564e12021-12-09 18:48:20 -08001459 if (!brightnessSupport) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001460 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.5f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001461 execute();
1462 const auto errors = mReader.takeErrors();
1463 EXPECT_EQ(1, errors.size());
Jason Macnak062bc9a2022-01-20 15:00:09 -08001464 EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, errors[0].errorCode);
Alec Mouri60564e12021-12-09 18:48:20 -08001465 GTEST_SUCCEED() << "SetDisplayBrightness is not supported";
1466 return;
1467 }
1468
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001469 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001470 execute();
1471 EXPECT_TRUE(mReader.takeErrors().empty());
1472
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001473 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.5f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001474 execute();
1475 EXPECT_TRUE(mReader.takeErrors().empty());
1476
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001477 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 1.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001478 execute();
1479 EXPECT_TRUE(mReader.takeErrors().empty());
1480
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001481 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ -1.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001482 execute();
1483 EXPECT_TRUE(mReader.takeErrors().empty());
1484
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001485 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 2.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001486 execute();
1487 {
1488 const auto errors = mReader.takeErrors();
ramindanib3bdf052022-01-12 18:27:05 +00001489 ASSERT_EQ(1, errors.size());
Alec Mouri60564e12021-12-09 18:48:20 -08001490 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
1491 }
1492
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001493 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ -2.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001494 execute();
1495 {
1496 const auto errors = mReader.takeErrors();
ramindanib3bdf052022-01-12 18:27:05 +00001497 ASSERT_EQ(1, errors.size());
Alec Mouri60564e12021-12-09 18:48:20 -08001498 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
1499 }
1500}
1501
ramindani431aad42022-02-01 21:44:29 +00001502TEST_P(GraphicsComposerAidlCommandTest, SetClientTarget) {
1503 EXPECT_TRUE(mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kBufferSlotCount)
1504 .isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001505
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001506 auto& writer = getWriter(getPrimaryDisplayId());
1507 writer.setClientTarget(getPrimaryDisplayId(), /*slot*/ 0, nullptr, /*acquireFence*/ -1,
1508 Dataspace::UNKNOWN, std::vector<Rect>());
ramindanidcfe3a82021-11-29 17:00:31 +00001509
1510 execute();
1511}
1512
ramindani431aad42022-02-01 21:44:29 +00001513TEST_P(GraphicsComposerAidlCommandTest, SetOutputBuffer) {
1514 const auto& [status, virtualDisplayCount] = mComposerClient->getMaxVirtualDisplayCount();
1515 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001516 if (virtualDisplayCount == 0) {
1517 GTEST_SUCCEED() << "no virtual display support";
1518 return;
1519 }
1520
ramindani431aad42022-02-01 21:44:29 +00001521 const auto& [displayStatus, display] = mComposerClient->createVirtualDisplay(
1522 /*width*/ 64, /*height*/ 64, common::PixelFormat::IMPLEMENTATION_DEFINED,
1523 kBufferSlotCount);
1524 EXPECT_TRUE(displayStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001525
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001526 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001527 const auto handle = buffer->handle;
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001528 auto& writer = getWriter(display.display);
1529 writer.setOutputBuffer(display.display, /*slot*/ 0, handle, /*releaseFence*/ -1);
ramindanidcfe3a82021-11-29 17:00:31 +00001530 execute();
1531}
1532
ramindani431aad42022-02-01 21:44:29 +00001533TEST_P(GraphicsComposerAidlCommandTest, ValidDisplay) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001534 auto& writer = getWriter(getPrimaryDisplayId());
1535 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
ramindanidcfe3a82021-11-29 17:00:31 +00001536 execute();
1537}
1538
ramindani431aad42022-02-01 21:44:29 +00001539TEST_P(GraphicsComposerAidlCommandTest, AcceptDisplayChanges) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001540 auto& writer = getWriter(getPrimaryDisplayId());
1541 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
1542 writer.acceptDisplayChanges(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001543 execute();
1544}
1545
ramindani431aad42022-02-01 21:44:29 +00001546TEST_P(GraphicsComposerAidlCommandTest, PresentDisplay) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001547 auto& writer = getWriter(getPrimaryDisplayId());
1548 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
1549 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001550 execute();
1551}
1552
1553/**
1554 * Test IComposerClient::Command::PRESENT_DISPLAY
1555 *
1556 * Test that IComposerClient::Command::PRESENT_DISPLAY works without
1557 * additional call to validateDisplay when only the layer buffer handle and
1558 * surface damage have been set
1559 */
ramindani431aad42022-02-01 21:44:29 +00001560TEST_P(GraphicsComposerAidlCommandTest, PresentDisplayNoLayerStateChanges) {
Jason Macnak325e8232022-01-24 14:48:55 -08001561 if (!hasCapability(Capability::SKIP_VALIDATE)) {
ramindanidcfe3a82021-11-29 17:00:31 +00001562 GTEST_SUCCEED() << "Device does not have skip validate capability, skipping";
1563 return;
1564 }
ramindani431aad42022-02-01 21:44:29 +00001565 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001566
ramindani431aad42022-02-01 21:44:29 +00001567 const auto& [renderIntentsStatus, renderIntents] =
1568 mComposerClient->getRenderIntents(getPrimaryDisplayId(), ColorMode::NATIVE);
1569 EXPECT_TRUE(renderIntentsStatus.isOk());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001570 auto& writer = getWriter(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001571 for (auto intent : renderIntents) {
ramindani431aad42022-02-01 21:44:29 +00001572 EXPECT_TRUE(mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE, intent)
1573 .isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001574
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001575 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001576 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001577 ASSERT_NE(nullptr, handle);
1578
ramindani431aad42022-02-01 21:44:29 +00001579 const auto& [layerStatus, layer] =
1580 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1581 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001582
ramindani431aad42022-02-01 21:44:29 +00001583 Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
1584 getPrimaryDisplay().getDisplayHeight()};
1585 FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
1586 (float)getPrimaryDisplay().getDisplayHeight()};
1587 configureLayer(getPrimaryDisplay(), layer, Composition::CURSOR, displayFrame, cropRect);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001588 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle,
1589 /*acquireFence*/ -1);
1590 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
1591 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
ramindanidcfe3a82021-11-29 17:00:31 +00001592 execute();
ramindani431aad42022-02-01 21:44:29 +00001593 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
ramindanidcfe3a82021-11-29 17:00:31 +00001594 GTEST_SUCCEED() << "Composition change requested, skipping test";
1595 return;
1596 }
1597
Ady Abraham3192f3d2021-12-03 16:08:56 -08001598 ASSERT_TRUE(mReader.takeErrors().empty());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001599 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001600 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001601 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001602
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001603 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001604 const auto handle2 = buffer2->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001605 ASSERT_NE(nullptr, handle2);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001606 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle2,
1607 /*acquireFence*/ -1);
1608 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer,
1609 std::vector<Rect>(1, {0, 0, 10, 10}));
1610 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001611 execute();
1612 }
1613}
1614
ramindani431aad42022-02-01 21:44:29 +00001615TEST_P(GraphicsComposerAidlCommandTest, SetLayerCursorPosition) {
1616 const auto& [layerStatus, layer] =
1617 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1618 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001619
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001620 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001621 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001622 ASSERT_NE(nullptr, handle);
ramindanidcfe3a82021-11-29 17:00:31 +00001623
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001624 auto& writer = getWriter(getPrimaryDisplayId());
1625 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle, /*acquireFence*/ -1);
ramindani431aad42022-02-01 21:44:29 +00001626
1627 Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
1628 getPrimaryDisplay().getDisplayHeight()};
1629 FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
1630 (float)getPrimaryDisplay().getDisplayHeight()};
1631 configureLayer(getPrimaryDisplay(), layer, Composition::CURSOR, displayFrame, cropRect);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001632 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
1633 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
ramindanidcfe3a82021-11-29 17:00:31 +00001634
1635 execute();
Ady Abraham46219f52021-12-20 09:44:31 -08001636
ramindani431aad42022-02-01 21:44:29 +00001637 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
ramindanidcfe3a82021-11-29 17:00:31 +00001638 GTEST_SUCCEED() << "Composition change requested, skipping test";
1639 return;
1640 }
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001641 writer.presentDisplay(getPrimaryDisplayId());
Ady Abraham3192f3d2021-12-03 16:08:56 -08001642 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001643
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001644 writer.setLayerCursorPosition(getPrimaryDisplayId(), layer, /*x*/ 1, /*y*/ 1);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001645 execute();
1646
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001647 writer.setLayerCursorPosition(getPrimaryDisplayId(), layer, /*x*/ 0, /*y*/ 0);
1648 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
1649 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001650 execute();
1651}
1652
ramindani431aad42022-02-01 21:44:29 +00001653TEST_P(GraphicsComposerAidlCommandTest, SetLayerBuffer) {
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001654 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001655 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001656 ASSERT_NE(nullptr, handle);
1657
ramindani431aad42022-02-01 21:44:29 +00001658 const auto& [layerStatus, layer] =
1659 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1660 EXPECT_TRUE(layerStatus.isOk());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001661 auto& writer = getWriter(getPrimaryDisplayId());
1662 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle, /*acquireFence*/ -1);
ramindanidcfe3a82021-11-29 17:00:31 +00001663 execute();
1664}
1665
Brian Lindahlca3eef22022-12-09 00:32:11 -07001666TEST_P(GraphicsComposerAidlCommandTest, SetLayerBufferWithSlotsToClear) {
Brian Lindahl78ff2d62022-12-18 11:21:41 -07001667 const auto& [versionStatus, version] = mComposerClient->getInterfaceVersion();
1668 ASSERT_TRUE(versionStatus.isOk());
1669 if (version == 1) {
1670 GTEST_SUCCEED() << "Device does not support the new API for clearing buffer slots";
1671 return;
1672 }
1673
1674 const auto& [layerStatus, layer] =
1675 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1676 EXPECT_TRUE(layerStatus.isOk());
1677
1678 auto& writer = getWriter(getPrimaryDisplayId());
Brian Lindahlca3eef22022-12-09 00:32:11 -07001679
1680 const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1681 ASSERT_NE(nullptr, buffer1);
1682 const auto handle1 = buffer1->handle;
Brian Lindahlca3eef22022-12-09 00:32:11 -07001683 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle1, /*acquireFence*/ -1);
1684 execute();
1685 ASSERT_TRUE(mReader.takeErrors().empty());
1686
Brian Lindahlca3eef22022-12-09 00:32:11 -07001687 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1688 ASSERT_NE(nullptr, buffer2);
1689 const auto handle2 = buffer2->handle;
Brian Lindahl78ff2d62022-12-18 11:21:41 -07001690 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 1, handle2, /*acquireFence*/ -1);
1691 execute();
1692 ASSERT_TRUE(mReader.takeErrors().empty());
1693
1694 // Ensure we can clear the buffer slots and then set the active slot with a new buffer
1695 const auto buffer3 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1696 ASSERT_NE(nullptr, buffer3);
1697 const auto handle3 = buffer3->handle;
1698 writer.setLayerBufferSlotsToClear(getPrimaryDisplayId(), layer, /*slotsToClear*/ {0, 1});
1699 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 1, handle3, /*acquireFence*/ -1);
1700 execute();
1701 ASSERT_TRUE(mReader.takeErrors().empty());
1702}
1703
1704TEST_P(GraphicsComposerAidlCommandTest, SetLayerBufferWithSlotsToClear_backwardsCompatible) {
1705 const auto& [versionStatus, version] = mComposerClient->getInterfaceVersion();
1706 ASSERT_TRUE(versionStatus.isOk());
1707 if (version > 1) {
1708 GTEST_SUCCEED() << "Device does not need a backwards compatible way to clear buffer slots";
1709 return;
1710 }
1711
1712 auto clearSlotBuffer = allocate(1u, 1u, ::android::PIXEL_FORMAT_RGB_888);
1713 ASSERT_NE(nullptr, clearSlotBuffer);
1714 auto clearSlotBufferHandle = clearSlotBuffer->handle;
1715
1716 const auto& [layerStatus, layer] =
1717 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1718 EXPECT_TRUE(layerStatus.isOk());
1719
1720 auto& writer = getWriter(getPrimaryDisplayId());
1721
1722 const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1723 ASSERT_NE(nullptr, buffer1);
1724 const auto handle1 = buffer1->handle;
1725 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle1, /*acquireFence*/ -1);
1726 execute();
1727 ASSERT_TRUE(mReader.takeErrors().empty());
1728
1729 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1730 ASSERT_NE(nullptr, buffer2);
1731 const auto handle2 = buffer2->handle;
1732 EXPECT_TRUE(layerStatus.isOk());
1733 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 1, handle2, /*acquireFence*/ -1);
1734 execute();
1735 ASSERT_TRUE(mReader.takeErrors().empty());
1736
1737 // Ensure we can clear a buffer slot and then set that same slot with a new buffer
1738 const auto buffer3 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1739 ASSERT_NE(nullptr, buffer3);
1740 const auto handle3 = buffer2->handle;
1741 // SurfaceFlinger will never clear the active buffer, instead it will clear non-active buffers
1742 // and then re-use the active buffer's slot for the new buffer
1743 writer.setLayerBufferWithNewCommand(getPrimaryDisplayId(), layer, /*slot*/ 0,
Brian Lindahlca3eef22022-12-09 00:32:11 -07001744 clearSlotBufferHandle, /*acquireFence*/ -1);
Brian Lindahl78ff2d62022-12-18 11:21:41 -07001745 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 1, handle3, /*acquireFence*/ -1);
Brian Lindahlca3eef22022-12-09 00:32:11 -07001746 execute();
1747 ASSERT_TRUE(mReader.takeErrors().empty());
1748}
1749
ramindani431aad42022-02-01 21:44:29 +00001750TEST_P(GraphicsComposerAidlCommandTest, SetLayerSurfaceDamage) {
1751 const auto& [layerStatus, layer] =
1752 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1753 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001754
1755 Rect empty{0, 0, 0, 0};
1756 Rect unit{0, 0, 1, 1};
1757
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001758 auto& writer = getWriter(getPrimaryDisplayId());
1759 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
ramindanidcfe3a82021-11-29 17:00:31 +00001760 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001761 ASSERT_TRUE(mReader.takeErrors().empty());
1762
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001763 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
Ady Abraham3192f3d2021-12-03 16:08:56 -08001764 execute();
1765 ASSERT_TRUE(mReader.takeErrors().empty());
1766
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001767 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>());
Ady Abraham3192f3d2021-12-03 16:08:56 -08001768 execute();
1769 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001770}
1771
ramindani431aad42022-02-01 21:44:29 +00001772TEST_P(GraphicsComposerAidlCommandTest, SetLayerBlockingRegion) {
1773 const auto& [layerStatus, layer] =
1774 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1775 EXPECT_TRUE(layerStatus.isOk());
Leon Scroggins III03318152022-01-13 12:24:19 -05001776
1777 Rect empty{0, 0, 0, 0};
1778 Rect unit{0, 0, 1, 1};
1779
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001780 auto& writer = getWriter(getPrimaryDisplayId());
1781 writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
Leon Scroggins III03318152022-01-13 12:24:19 -05001782 execute();
1783 ASSERT_TRUE(mReader.takeErrors().empty());
1784
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001785 writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
Leon Scroggins III03318152022-01-13 12:24:19 -05001786 execute();
1787 ASSERT_TRUE(mReader.takeErrors().empty());
1788
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001789 writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>());
Leon Scroggins III03318152022-01-13 12:24:19 -05001790 execute();
1791 ASSERT_TRUE(mReader.takeErrors().empty());
1792}
1793
ramindani431aad42022-02-01 21:44:29 +00001794TEST_P(GraphicsComposerAidlCommandTest, SetLayerBlendMode) {
1795 const auto& [layerStatus, layer] =
1796 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1797 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001798
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001799 auto& writer = getWriter(getPrimaryDisplayId());
1800 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::NONE);
ramindanidcfe3a82021-11-29 17:00:31 +00001801 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001802 ASSERT_TRUE(mReader.takeErrors().empty());
1803
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001804 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::PREMULTIPLIED);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001805 execute();
1806 ASSERT_TRUE(mReader.takeErrors().empty());
1807
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001808 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::COVERAGE);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001809 execute();
1810 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001811}
1812
ramindani431aad42022-02-01 21:44:29 +00001813TEST_P(GraphicsComposerAidlCommandTest, SetLayerColor) {
1814 const auto& [layerStatus, layer] =
1815 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1816 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001817
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001818 auto& writer = getWriter(getPrimaryDisplayId());
1819 writer.setLayerColor(getPrimaryDisplayId(), layer, Color{1.0f, 1.0f, 1.0f, 1.0f});
ramindanidcfe3a82021-11-29 17:00:31 +00001820 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001821 ASSERT_TRUE(mReader.takeErrors().empty());
1822
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001823 writer.setLayerColor(getPrimaryDisplayId(), layer, Color{0.0f, 0.0f, 0.0f, 0.0f});
Ady Abraham3192f3d2021-12-03 16:08:56 -08001824 execute();
1825 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001826}
1827
ramindani431aad42022-02-01 21:44:29 +00001828TEST_P(GraphicsComposerAidlCommandTest, SetLayerCompositionType) {
1829 const auto& [layerStatus, layer] =
1830 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1831 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001832
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001833 auto& writer = getWriter(getPrimaryDisplayId());
1834 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::CLIENT);
ramindanidcfe3a82021-11-29 17:00:31 +00001835 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001836 ASSERT_TRUE(mReader.takeErrors().empty());
1837
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001838 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::DEVICE);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001839 execute();
1840 ASSERT_TRUE(mReader.takeErrors().empty());
1841
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001842 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::SOLID_COLOR);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001843 execute();
1844 ASSERT_TRUE(mReader.takeErrors().empty());
1845
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001846 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::CURSOR);
ramindani431aad42022-02-01 21:44:29 +00001847 execute();
1848}
1849
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001850TEST_P(GraphicsComposerAidlCommandTest, DisplayDecoration) {
1851 for (VtsDisplay& display : mDisplays) {
1852 const auto [layerStatus, layer] =
1853 mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount);
1854 EXPECT_TRUE(layerStatus.isOk());
1855
1856 const auto [error, support] =
1857 mComposerClient->getDisplayDecorationSupport(display.getDisplayId());
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001858
Leon Scroggins III91590872022-02-23 09:51:21 -05001859 const auto format = (error.isOk() && support) ? support->format
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001860 : aidl::android::hardware::graphics::common::PixelFormat::RGBA_8888;
1861 const auto decorBuffer = allocate(static_cast<::android::PixelFormat>(format));
1862 ASSERT_NE(nullptr, decorBuffer);
1863 if (::android::OK != decorBuffer->initCheck()) {
1864 if (support) {
1865 FAIL() << "Device advertised display decoration support with format "
1866 << aidl::android::hardware::graphics::common::toString(format)
1867 << " but failed to allocate it!";
1868 } else {
1869 FAIL() << "Device advertised NO display decoration support, but it should "
1870 << "still be able to allocate "
1871 << aidl::android::hardware::graphics::common::toString(format);
1872 }
1873 }
1874
Midas Chien7d55d422022-06-07 02:32:28 +08001875 configureLayer(display, layer, Composition::DISPLAY_DECORATION, display.getFrameRect(),
1876 display.getCrop());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001877 auto& writer = getWriter(display.getDisplayId());
1878 writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, decorBuffer->handle,
1879 /*acquireFence*/ -1);
1880 writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp);
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001881 execute();
1882 if (support) {
1883 ASSERT_TRUE(mReader.takeErrors().empty());
1884 } else {
1885 const auto errors = mReader.takeErrors();
1886 ASSERT_EQ(1, errors.size());
Leon Scroggins III6455e792022-02-24 12:18:58 -05001887 EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, errors[0].errorCode);
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001888 }
1889 }
1890}
1891
ramindani431aad42022-02-01 21:44:29 +00001892TEST_P(GraphicsComposerAidlCommandTest, SetLayerDataspace) {
1893 const auto& [layerStatus, layer] =
1894 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1895 EXPECT_TRUE(layerStatus.isOk());
1896
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001897 auto& writer = getWriter(getPrimaryDisplayId());
1898 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
ramindani431aad42022-02-01 21:44:29 +00001899 execute();
1900}
1901
1902TEST_P(GraphicsComposerAidlCommandTest, SetLayerDisplayFrame) {
1903 const auto& [layerStatus, layer] =
1904 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1905 EXPECT_TRUE(layerStatus.isOk());
1906
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001907 auto& writer = getWriter(getPrimaryDisplayId());
1908 writer.setLayerDisplayFrame(getPrimaryDisplayId(), layer, Rect{0, 0, 1, 1});
ramindani431aad42022-02-01 21:44:29 +00001909 execute();
1910}
1911
1912TEST_P(GraphicsComposerAidlCommandTest, SetLayerPlaneAlpha) {
1913 const auto& [layerStatus, layer] =
1914 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1915 EXPECT_TRUE(layerStatus.isOk());
1916
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001917 auto& writer = getWriter(getPrimaryDisplayId());
1918 writer.setLayerPlaneAlpha(getPrimaryDisplayId(), layer, /*alpha*/ 0.0f);
ramindani431aad42022-02-01 21:44:29 +00001919 execute();
1920 ASSERT_TRUE(mReader.takeErrors().empty());
1921
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001922 writer.setLayerPlaneAlpha(getPrimaryDisplayId(), layer, /*alpha*/ 1.0f);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001923 execute();
1924 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001925}
1926
ramindani431aad42022-02-01 21:44:29 +00001927TEST_P(GraphicsComposerAidlCommandTest, SetLayerSidebandStream) {
Jason Macnak325e8232022-01-24 14:48:55 -08001928 if (!hasCapability(Capability::SIDEBAND_STREAM)) {
ramindanidcfe3a82021-11-29 17:00:31 +00001929 GTEST_SUCCEED() << "no sideband stream support";
1930 return;
1931 }
1932
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001933 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001934 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001935 ASSERT_NE(nullptr, handle);
1936
ramindani431aad42022-02-01 21:44:29 +00001937 const auto& [layerStatus, layer] =
1938 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1939 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001940
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001941 auto& writer = getWriter(getPrimaryDisplayId());
1942 writer.setLayerSidebandStream(getPrimaryDisplayId(), layer, handle);
ramindanidcfe3a82021-11-29 17:00:31 +00001943 execute();
1944}
1945
ramindani431aad42022-02-01 21:44:29 +00001946TEST_P(GraphicsComposerAidlCommandTest, SetLayerSourceCrop) {
1947 const auto& [layerStatus, layer] =
1948 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1949 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001950
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001951 auto& writer = getWriter(getPrimaryDisplayId());
1952 writer.setLayerSourceCrop(getPrimaryDisplayId(), layer, FRect{0.0f, 0.0f, 1.0f, 1.0f});
ramindanidcfe3a82021-11-29 17:00:31 +00001953 execute();
1954}
1955
ramindani431aad42022-02-01 21:44:29 +00001956TEST_P(GraphicsComposerAidlCommandTest, SetLayerTransform) {
1957 const auto& [layerStatus, layer] =
1958 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1959 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001960
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001961 auto& writer = getWriter(getPrimaryDisplayId());
1962 writer.setLayerTransform(getPrimaryDisplayId(), layer, static_cast<Transform>(0));
ramindanidcfe3a82021-11-29 17:00:31 +00001963 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001964 ASSERT_TRUE(mReader.takeErrors().empty());
1965
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001966 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::FLIP_H);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001967 execute();
1968 ASSERT_TRUE(mReader.takeErrors().empty());
1969
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001970 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::FLIP_V);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001971 execute();
1972 ASSERT_TRUE(mReader.takeErrors().empty());
1973
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001974 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_90);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001975 execute();
1976 ASSERT_TRUE(mReader.takeErrors().empty());
1977
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001978 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_180);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001979 execute();
1980 ASSERT_TRUE(mReader.takeErrors().empty());
1981
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001982 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_270);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001983 execute();
1984 ASSERT_TRUE(mReader.takeErrors().empty());
1985
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001986 writer.setLayerTransform(getPrimaryDisplayId(), layer,
1987 static_cast<Transform>(static_cast<int>(Transform::FLIP_H) |
1988 static_cast<int>(Transform::ROT_90)));
Ady Abraham3192f3d2021-12-03 16:08:56 -08001989 execute();
1990 ASSERT_TRUE(mReader.takeErrors().empty());
1991
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001992 writer.setLayerTransform(getPrimaryDisplayId(), layer,
1993 static_cast<Transform>(static_cast<int>(Transform::FLIP_V) |
1994 static_cast<int>(Transform::ROT_90)));
Ady Abraham3192f3d2021-12-03 16:08:56 -08001995 execute();
1996 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001997}
1998
ramindani431aad42022-02-01 21:44:29 +00001999TEST_P(GraphicsComposerAidlCommandTest, SetLayerVisibleRegion) {
2000 const auto& [layerStatus, layer] =
2001 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2002 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002003
2004 Rect empty{0, 0, 0, 0};
2005 Rect unit{0, 0, 1, 1};
2006
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002007 auto& writer = getWriter(getPrimaryDisplayId());
2008 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
ramindanidcfe3a82021-11-29 17:00:31 +00002009 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002010 ASSERT_TRUE(mReader.takeErrors().empty());
2011
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002012 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
Ady Abraham3192f3d2021-12-03 16:08:56 -08002013 execute();
2014 ASSERT_TRUE(mReader.takeErrors().empty());
2015
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002016 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>());
Ady Abraham3192f3d2021-12-03 16:08:56 -08002017 execute();
2018 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002019}
2020
ramindani431aad42022-02-01 21:44:29 +00002021TEST_P(GraphicsComposerAidlCommandTest, SetLayerZOrder) {
2022 const auto& [layerStatus, layer] =
2023 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2024 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002025
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002026 auto& writer = getWriter(getPrimaryDisplayId());
2027 writer.setLayerZOrder(getPrimaryDisplayId(), layer, /*z*/ 10);
ramindanidcfe3a82021-11-29 17:00:31 +00002028 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002029 ASSERT_TRUE(mReader.takeErrors().empty());
2030
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002031 writer.setLayerZOrder(getPrimaryDisplayId(), layer, /*z*/ 0);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002032 execute();
2033 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002034}
2035
ramindani431aad42022-02-01 21:44:29 +00002036TEST_P(GraphicsComposerAidlCommandTest, SetLayerPerFrameMetadata) {
2037 const auto& [layerStatus, layer] =
2038 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2039 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002040
ramindanidcfe3a82021-11-29 17:00:31 +00002041 /**
2042 * DISPLAY_P3 is a color space that uses the DCI_P3 primaries,
2043 * the D65 white point and the SRGB transfer functions.
2044 * Rendering Intent: Colorimetric
2045 * Primaries:
2046 * x y
2047 * green 0.265 0.690
2048 * blue 0.150 0.060
2049 * red 0.680 0.320
2050 * white (D65) 0.3127 0.3290
2051 */
2052
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002053 auto& writer = getWriter(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00002054 std::vector<PerFrameMetadata> aidlMetadata;
2055 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X, 0.680f});
2056 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y, 0.320f});
2057 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X, 0.265f});
2058 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y, 0.690f});
2059 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X, 0.150f});
2060 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y, 0.060f});
2061 aidlMetadata.push_back({PerFrameMetadataKey::WHITE_POINT_X, 0.3127f});
2062 aidlMetadata.push_back({PerFrameMetadataKey::WHITE_POINT_Y, 0.3290f});
2063 aidlMetadata.push_back({PerFrameMetadataKey::MAX_LUMINANCE, 100.0f});
2064 aidlMetadata.push_back({PerFrameMetadataKey::MIN_LUMINANCE, 0.1f});
2065 aidlMetadata.push_back({PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL, 78.0});
2066 aidlMetadata.push_back({PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL, 62.0});
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002067 writer.setLayerPerFrameMetadata(getPrimaryDisplayId(), layer, aidlMetadata);
ramindanidcfe3a82021-11-29 17:00:31 +00002068 execute();
2069
Ady Abraham3192f3d2021-12-03 16:08:56 -08002070 const auto errors = mReader.takeErrors();
2071 if (errors.size() == 1 && errors[0].errorCode == EX_UNSUPPORTED_OPERATION) {
ramindanidcfe3a82021-11-29 17:00:31 +00002072 GTEST_SUCCEED() << "SetLayerPerFrameMetadata is not supported";
ramindani431aad42022-02-01 21:44:29 +00002073 EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002074 return;
2075 }
2076
ramindani431aad42022-02-01 21:44:29 +00002077 EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002078}
2079
Alec Mourib1f16722022-02-07 13:03:44 -08002080TEST_P(GraphicsComposerAidlCommandTest, setLayerBrightness) {
ramindani431aad42022-02-01 21:44:29 +00002081 const auto& [layerStatus, layer] =
2082 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
Alec Mouri95e490b2022-01-06 13:46:58 -08002083
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002084 auto& writer = getWriter(getPrimaryDisplayId());
2085 writer.setLayerBrightness(getPrimaryDisplayId(), layer, 0.2f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002086 execute();
2087 ASSERT_TRUE(mReader.takeErrors().empty());
2088
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002089 writer.setLayerBrightness(getPrimaryDisplayId(), layer, 1.f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002090 execute();
2091 ASSERT_TRUE(mReader.takeErrors().empty());
2092
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002093 writer.setLayerBrightness(getPrimaryDisplayId(), layer, 0.f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002094 execute();
2095 ASSERT_TRUE(mReader.takeErrors().empty());
2096
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002097 writer.setLayerBrightness(getPrimaryDisplayId(), layer, -1.f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002098 execute();
Alec Mourib1f16722022-02-07 13:03:44 -08002099 {
2100 const auto errors = mReader.takeErrors();
2101 ASSERT_EQ(1, errors.size());
2102 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
2103 }
2104
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002105 writer.setLayerBrightness(getPrimaryDisplayId(), layer, std::nanf(""));
Alec Mourib1f16722022-02-07 13:03:44 -08002106 execute();
2107 {
2108 const auto errors = mReader.takeErrors();
2109 ASSERT_EQ(1, errors.size());
2110 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
2111 }
Alec Mouri95e490b2022-01-06 13:46:58 -08002112}
2113
ramindani431aad42022-02-01 21:44:29 +00002114TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints) {
ramindanidcfe3a82021-11-29 17:00:31 +00002115 Test_setActiveConfigWithConstraints({.delayForChange = 0, .refreshMiss = false});
2116}
2117
ramindani431aad42022-02-01 21:44:29 +00002118TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_Delayed) {
ramindanidcfe3a82021-11-29 17:00:31 +00002119 Test_setActiveConfigWithConstraints({.delayForChange = 300'000'000, // 300ms
2120 .refreshMiss = false});
2121}
2122
ramindani431aad42022-02-01 21:44:29 +00002123TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_MissRefresh) {
ramindanidcfe3a82021-11-29 17:00:31 +00002124 Test_setActiveConfigWithConstraints({.delayForChange = 0, .refreshMiss = true});
2125}
2126
ramindani431aad42022-02-01 21:44:29 +00002127TEST_P(GraphicsComposerAidlCommandTest, GetDisplayVsyncPeriod) {
ramindanidcfe3a82021-11-29 17:00:31 +00002128 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +00002129 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
2130 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002131
ramindani431aad42022-02-01 21:44:29 +00002132 for (int32_t config : configs) {
2133 int32_t expectedVsyncPeriodNanos = display.getDisplayConfig(config).vsyncPeriod;
2134
ramindanidcfe3a82021-11-29 17:00:31 +00002135 VsyncPeriodChangeConstraints constraints;
2136
2137 constraints.desiredTimeNanos = systemTime();
2138 constraints.seamlessRequired = false;
ramindani431aad42022-02-01 21:44:29 +00002139
2140 const auto& [timelineStatus, timeline] =
2141 mComposerClient->setActiveConfigWithConstraints(&display, config, constraints);
2142 EXPECT_TRUE(timelineStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002143
2144 if (timeline.refreshRequired) {
2145 sendRefreshFrame(display, &timeline);
2146 }
ramindani431aad42022-02-01 21:44:29 +00002147 waitForVsyncPeriodChange(display.getDisplayId(), timeline, constraints.desiredTimeNanos,
2148 /*odPeriodNanos*/ 0, expectedVsyncPeriodNanos);
ramindanidcfe3a82021-11-29 17:00:31 +00002149
2150 int32_t vsyncPeriodNanos;
2151 int retryCount = 100;
2152 do {
2153 std::this_thread::sleep_for(10ms);
ramindani431aad42022-02-01 21:44:29 +00002154 const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanosValue] =
2155 mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
2156
2157 EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
2158 vsyncPeriodNanos = vsyncPeriodNanosValue;
ramindanidcfe3a82021-11-29 17:00:31 +00002159 --retryCount;
2160 } while (vsyncPeriodNanos != expectedVsyncPeriodNanos && retryCount > 0);
2161
2162 EXPECT_EQ(vsyncPeriodNanos, expectedVsyncPeriodNanos);
2163
2164 // Make sure that the vsync period stays the same if the active config is not
2165 // changed.
2166 auto timeout = 1ms;
2167 for (int i = 0; i < 10; i++) {
2168 std::this_thread::sleep_for(timeout);
2169 timeout *= 2;
2170 vsyncPeriodNanos = 0;
ramindani431aad42022-02-01 21:44:29 +00002171 const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanosValue] =
2172 mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
2173
2174 EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
2175 vsyncPeriodNanos = vsyncPeriodNanosValue;
ramindanidcfe3a82021-11-29 17:00:31 +00002176 EXPECT_EQ(vsyncPeriodNanos, expectedVsyncPeriodNanos);
2177 }
2178 }
2179 }
2180}
2181
ramindani431aad42022-02-01 21:44:29 +00002182TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_SeamlessNotAllowed) {
ramindanidcfe3a82021-11-29 17:00:31 +00002183 VsyncPeriodChangeConstraints constraints;
ramindanidcfe3a82021-11-29 17:00:31 +00002184 constraints.seamlessRequired = true;
2185 constraints.desiredTimeNanos = systemTime();
2186
2187 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +00002188 forEachTwoConfigs(display.getDisplayId(), [&](int32_t config1, int32_t config2) {
2189 int32_t configGroup1 = display.getDisplayConfig(config1).configGroup;
2190 int32_t configGroup2 = display.getDisplayConfig(config2).configGroup;
ramindanidcfe3a82021-11-29 17:00:31 +00002191 if (configGroup1 != configGroup2) {
ramindani431aad42022-02-01 21:44:29 +00002192 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002193 sendRefreshFrame(display, nullptr);
ramindani431aad42022-02-01 21:44:29 +00002194 const auto& [status, _] = mComposerClient->setActiveConfigWithConstraints(
2195 &display, config2, constraints);
2196 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00002197 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(
2198 status, IComposerClient::EX_SEAMLESS_NOT_ALLOWED));
ramindanidcfe3a82021-11-29 17:00:31 +00002199 }
2200 });
2201 }
2202}
2203
ramindani431aad42022-02-01 21:44:29 +00002204TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_NoTimestamp) {
2205 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ std::nullopt));
Ady Abraham72c5b502021-12-10 17:23:39 -08002206}
2207
ramindani431aad42022-02-01 21:44:29 +00002208TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_0) {
2209 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ 0));
Ady Abraham72c5b502021-12-10 17:23:39 -08002210}
2211
ramindani431aad42022-02-01 21:44:29 +00002212TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_5) {
2213 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ 5));
Ady Abraham72c5b502021-12-10 17:23:39 -08002214}
2215
ramindani431aad42022-02-01 21:44:29 +00002216TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Unsupported) {
2217 const bool hasDisplayIdleTimerSupport =
2218 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002219 if (!hasDisplayIdleTimerSupport) {
ramindani431aad42022-02-01 21:44:29 +00002220 const auto& status =
2221 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0);
2222 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00002223 EXPECT_NO_FATAL_FAILURE(
2224 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
Midas Chiena0b56bd2022-01-13 23:27:33 +08002225 }
2226}
2227
ramindani431aad42022-02-01 21:44:29 +00002228TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_BadParameter) {
2229 const bool hasDisplayIdleTimerSupport =
2230 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002231 if (!hasDisplayIdleTimerSupport) {
2232 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2233 return;
2234 }
2235
ramindani431aad42022-02-01 21:44:29 +00002236 const auto& status =
2237 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ -1);
2238 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00002239 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
Midas Chiena0b56bd2022-01-13 23:27:33 +08002240}
2241
ramindani431aad42022-02-01 21:44:29 +00002242TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Disable) {
2243 const bool hasDisplayIdleTimerSupport =
2244 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002245 if (!hasDisplayIdleTimerSupport) {
2246 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2247 return;
2248 }
2249
ramindani431aad42022-02-01 21:44:29 +00002250 EXPECT_TRUE(mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002251 std::this_thread::sleep_for(1s);
ramindani431aad42022-02-01 21:44:29 +00002252 EXPECT_EQ(0, mComposerClient->getVsyncIdleCount());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002253}
2254
ramindani431aad42022-02-01 21:44:29 +00002255TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Timeout_2) {
2256 const bool hasDisplayIdleTimerSupport =
2257 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002258 if (!hasDisplayIdleTimerSupport) {
2259 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2260 return;
2261 }
2262
ramindani431aad42022-02-01 21:44:29 +00002263 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
2264 EXPECT_TRUE(mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002265
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002266 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002267 ASSERT_NE(nullptr, buffer->handle);
2268
2269 const auto layer = createOnScreenLayer();
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002270 auto& writer = getWriter(getPrimaryDisplayId());
2271 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer->handle,
2272 /*acquireFence*/ -1);
ramindani431aad42022-02-01 21:44:29 +00002273 int32_t vsyncIdleCount = mComposerClient->getVsyncIdleCount();
Midas Chiena0b56bd2022-01-13 23:27:33 +08002274 auto earlyVsyncIdleTime = systemTime() + std::chrono::nanoseconds(2s).count();
ramindani431aad42022-02-01 21:44:29 +00002275 EXPECT_TRUE(
2276 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 2000).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002277
2278 const sp<::android::Fence> presentFence =
ramindani431aad42022-02-01 21:44:29 +00002279 presentAndGetFence(ComposerClientWriter::kNoTimestamp);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002280 presentFence->waitForever(LOG_TAG);
2281
2282 std::this_thread::sleep_for(3s);
ramindani431aad42022-02-01 21:44:29 +00002283 if (vsyncIdleCount < mComposerClient->getVsyncIdleCount()) {
2284 EXPECT_GE(mComposerClient->getVsyncIdleTime(), earlyVsyncIdleTime);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002285 }
2286
ramindani431aad42022-02-01 21:44:29 +00002287 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002288}
2289
Kriti Dang4efe8602022-05-03 16:55:59 +02002290/*
2291 * Test that no two display configs are exactly the same.
2292 */
2293TEST_P(GraphicsComposerAidlTest, GetDisplayConfigNoRepetitions) {
2294 for (const auto& display : mDisplays) {
2295 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
2296 for (std::vector<int>::size_type i = 0; i < configs.size(); i++) {
2297 for (std::vector<int>::size_type j = i + 1; j < configs.size(); j++) {
2298 const auto& [widthStatus1, width1] = mComposerClient->getDisplayAttribute(
2299 display.getDisplayId(), configs[i], DisplayAttribute::WIDTH);
2300 const auto& [heightStatus1, height1] = mComposerClient->getDisplayAttribute(
2301 display.getDisplayId(), configs[i], DisplayAttribute::HEIGHT);
2302 const auto& [vsyncPeriodStatus1, vsyncPeriod1] =
2303 mComposerClient->getDisplayAttribute(display.getDisplayId(), configs[i],
2304 DisplayAttribute::VSYNC_PERIOD);
2305 const auto& [groupStatus1, group1] = mComposerClient->getDisplayAttribute(
2306 display.getDisplayId(), configs[i], DisplayAttribute::CONFIG_GROUP);
2307
2308 const auto& [widthStatus2, width2] = mComposerClient->getDisplayAttribute(
2309 display.getDisplayId(), configs[j], DisplayAttribute::WIDTH);
2310 const auto& [heightStatus2, height2] = mComposerClient->getDisplayAttribute(
2311 display.getDisplayId(), configs[j], DisplayAttribute::HEIGHT);
2312 const auto& [vsyncPeriodStatus2, vsyncPeriod2] =
2313 mComposerClient->getDisplayAttribute(display.getDisplayId(), configs[j],
2314 DisplayAttribute::VSYNC_PERIOD);
2315 const auto& [groupStatus2, group2] = mComposerClient->getDisplayAttribute(
2316 display.getDisplayId(), configs[j], DisplayAttribute::CONFIG_GROUP);
2317
2318 ASSERT_FALSE(width1 == width2 && height1 == height2 &&
2319 vsyncPeriod1 == vsyncPeriod2 && group1 == group2);
2320 }
2321 }
2322 }
2323}
2324
Leon Scroggins IIIb3e336e2022-10-06 12:32:16 -04002325TEST_P(GraphicsComposerAidlCommandTest, MultiThreadedPresent) {
2326 std::vector<VtsDisplay*> displays;
2327 for (auto& display : mDisplays) {
2328 if (hasDisplayCapability(display.getDisplayId(),
2329 DisplayCapability::MULTI_THREADED_PRESENT)) {
2330 displays.push_back(&display);
2331 }
2332 }
2333 if (displays.size() <= 1u) {
2334 return;
2335 }
2336 // TODO(b/251842321): Try to present on multiple threads.
2337}
2338
ramindanidcfe3a82021-11-29 17:00:31 +00002339GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlCommandTest);
2340INSTANTIATE_TEST_SUITE_P(
2341 PerInstance, GraphicsComposerAidlCommandTest,
2342 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
2343 ::android::PrintInstanceNameToString);
2344
ramindanid32ae8e2021-10-01 18:48:39 +00002345GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlTest);
2346INSTANTIATE_TEST_SUITE_P(
2347 PerInstance, GraphicsComposerAidlTest,
2348 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
2349 ::android::PrintInstanceNameToString);
2350} // namespace
2351} // namespace aidl::android::hardware::graphics::composer3::vts
2352
2353int main(int argc, char** argv) {
2354 ::testing::InitGoogleTest(&argc, argv);
2355
2356 using namespace std::chrono_literals;
2357 if (!android::base::WaitForProperty("init.svc.surfaceflinger", "stopped", 10s)) {
2358 ALOGE("Failed to stop init.svc.surfaceflinger");
2359 return -1;
2360 }
ramindanibeea10e2021-12-07 21:02:49 +00002361
2362 android::ProcessState::self()->setThreadPoolMaxThreadCount(4);
2363
2364 // The binder threadpool we start will inherit sched policy and priority
2365 // of (this) creating thread. We want the binder thread pool to have
2366 // SCHED_FIFO policy and priority 1 (lowest RT priority)
2367 // Once the pool is created we reset this thread's priority back to
2368 // original.
2369 // This thread policy is based on what we do in the SurfaceFlinger while starting
2370 // the thread pool and we need to replicate that for the VTS tests.
2371 int newPriority = 0;
2372 int origPolicy = sched_getscheduler(0);
2373 struct sched_param origSchedParam;
2374
2375 int errorInPriorityModification = sched_getparam(0, &origSchedParam);
2376 if (errorInPriorityModification == 0) {
2377 int policy = SCHED_FIFO;
2378 newPriority = sched_get_priority_min(policy);
2379
2380 struct sched_param param;
2381 param.sched_priority = newPriority;
2382
2383 errorInPriorityModification = sched_setscheduler(0, policy, &param);
2384 }
2385
2386 // start the thread pool
2387 android::ProcessState::self()->startThreadPool();
2388
2389 // Reset current thread's policy and priority
2390 if (errorInPriorityModification == 0) {
2391 errorInPriorityModification = sched_setscheduler(0, origPolicy, &origSchedParam);
2392 } else {
2393 ALOGE("Failed to set VtsHalGraphicsComposer3_TargetTest binder threadpool priority to "
2394 "SCHED_FIFO");
2395 }
2396
ramindanid32ae8e2021-10-01 18:48:39 +00002397 return RUN_ALL_TESTS();
ramindania9780262021-10-01 18:48:39 +00002398}