blob: 6d7495136d4639ef099e9a4da4cf6dccde351a49 [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>
Joen Chene0a962c2023-08-28 09:49:11 +000037#include <mutex>
ramindani592b6512021-10-08 21:15:19 +000038#include <numeric>
ramindanid32ae8e2021-10-01 18:48:39 +000039#include <string>
ramindani1cb794e2021-10-13 20:45:23 +000040#include <thread>
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -040041#include <unordered_map>
ramindani458e53e2022-02-23 17:30:16 +000042#include "GraphicsComposerCallback.h"
43#include "VtsComposerClient.h"
ramindani3335f7a2021-10-25 17:22:35 +000044
ramindanid32ae8e2021-10-01 18:48:39 +000045#undef LOG_TAG
46#define LOG_TAG "VtsHalGraphicsComposer3_TargetTest"
47
48namespace aidl::android::hardware::graphics::composer3::vts {
ramindanid32ae8e2021-10-01 18:48:39 +000049
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
ramindani17c71102023-03-20 10:51:14 -0700121 int getInterfaceVersion() {
122 const auto& [versionStatus, version] = mComposerClient->getInterfaceVersion();
123 EXPECT_TRUE(versionStatus.isOk());
124 return version;
125 }
126
ramindani431aad42022-02-01 21:44:29 +0000127 const VtsDisplay& getPrimaryDisplay() const { return mDisplays[0]; }
ramindania9780262021-10-01 18:48:39 +0000128
ramindani431aad42022-02-01 21:44:29 +0000129 int64_t getPrimaryDisplayId() const { return getPrimaryDisplay().getDisplayId(); }
ramindania9780262021-10-01 18:48:39 +0000130
ramindani431aad42022-02-01 21:44:29 +0000131 int64_t getInvalidDisplayId() const { return mComposerClient->getInvalidDisplayId(); }
ramindani1cb794e2021-10-13 20:45:23 +0000132
ramindani431aad42022-02-01 21:44:29 +0000133 VtsDisplay& getEditablePrimaryDisplay() { return mDisplays[0]; }
ramindani0291f112021-11-04 03:45:46 +0000134
ramindani3335f7a2021-10-25 17:22:35 +0000135 struct TestParameters {
136 nsecs_t delayForChange;
137 bool refreshMiss;
138 };
139
ramindani431aad42022-02-01 21:44:29 +0000140 std::unique_ptr<VtsComposerClient> mComposerClient;
ramindani1cb794e2021-10-13 20:45:23 +0000141 std::vector<VtsDisplay> mDisplays;
ramindani3335f7a2021-10-25 17:22:35 +0000142 // use the slot count usually set by SF
143 static constexpr uint32_t kBufferSlotCount = 64;
ramindanid32ae8e2021-10-01 18:48:39 +0000144};
145
ramindani431aad42022-02-01 21:44:29 +0000146TEST_P(GraphicsComposerAidlTest, GetDisplayCapabilities_BadDisplay) {
147 const auto& [status, _] = mComposerClient->getDisplayCapabilities(getInvalidDisplayId());
ramindani5f696942021-10-14 16:24:18 +0000148
ramindani431aad42022-02-01 21:44:29 +0000149 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000150 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindania9780262021-10-01 18:48:39 +0000151}
152
ramindani431aad42022-02-01 21:44:29 +0000153TEST_P(GraphicsComposerAidlTest, GetDisplayCapabilities) {
ramindania9780262021-10-01 18:48:39 +0000154 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000155 const auto& [status, capabilities] =
156 mComposerClient->getDisplayCapabilities(display.getDisplayId());
ramindania9780262021-10-01 18:48:39 +0000157
ramindani431aad42022-02-01 21:44:29 +0000158 EXPECT_TRUE(status.isOk());
ramindania9780262021-10-01 18:48:39 +0000159 }
ramindanid32ae8e2021-10-01 18:48:39 +0000160}
161
ramindani2740bac2021-11-24 22:58:32 +0000162TEST_P(GraphicsComposerAidlTest, DumpDebugInfo) {
ramindani431aad42022-02-01 21:44:29 +0000163 ASSERT_TRUE(mComposerClient->dumpDebugInfo().isOk());
ramindani2740bac2021-11-24 22:58:32 +0000164}
165
166TEST_P(GraphicsComposerAidlTest, CreateClientSingleton) {
167 std::shared_ptr<IComposerClient> composerClient;
ramindani431aad42022-02-01 21:44:29 +0000168 const auto& status = mComposerClient->createClient();
ramindani2740bac2021-11-24 22:58:32 +0000169
ramindani431aad42022-02-01 21:44:29 +0000170 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000171 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_NO_RESOURCES));
ramindani2740bac2021-11-24 22:58:32 +0000172}
173
ramindani592b6512021-10-08 21:15:19 +0000174TEST_P(GraphicsComposerAidlTest, GetDisplayIdentificationData) {
ramindani431aad42022-02-01 21:44:29 +0000175 const auto& [status0, displayIdentification0] =
176 mComposerClient->getDisplayIdentificationData(getPrimaryDisplayId());
ramindanid5751092022-04-22 22:30:20 +0000177 if (!status0.isOk() && status0.getExceptionCode() == EX_SERVICE_SPECIFIC &&
178 status0.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindani431aad42022-02-01 21:44:29 +0000179 GTEST_SUCCEED() << "Display identification data not supported, skipping test";
ramindani592b6512021-10-08 21:15:19 +0000180 return;
181 }
ramindani431aad42022-02-01 21:44:29 +0000182 ASSERT_TRUE(status0.isOk()) << "failed to get display identification data";
ramindani592b6512021-10-08 21:15:19 +0000183 ASSERT_FALSE(displayIdentification0.data.empty());
184
185 constexpr size_t kEdidBlockSize = 128;
186 ASSERT_TRUE(displayIdentification0.data.size() % kEdidBlockSize == 0)
187 << "EDID blob length is not a multiple of " << kEdidBlockSize;
188
189 const uint8_t kEdidHeader[] = {0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00};
190 ASSERT_TRUE(std::equal(std::begin(kEdidHeader), std::end(kEdidHeader),
191 displayIdentification0.data.begin()))
192 << "EDID blob doesn't start with the fixed EDID header";
193 ASSERT_EQ(0, std::accumulate(displayIdentification0.data.begin(),
194 displayIdentification0.data.begin() + kEdidBlockSize,
195 static_cast<uint8_t>(0)))
196 << "EDID base block doesn't checksum";
197
ramindani431aad42022-02-01 21:44:29 +0000198 const auto& [status1, displayIdentification1] =
199 mComposerClient->getDisplayIdentificationData(getPrimaryDisplayId());
200 ASSERT_TRUE(status1.isOk());
ramindani592b6512021-10-08 21:15:19 +0000201
202 ASSERT_EQ(displayIdentification0.port, displayIdentification1.port) << "ports are not stable";
203 ASSERT_TRUE(displayIdentification0.data.size() == displayIdentification1.data.size() &&
204 std::equal(displayIdentification0.data.begin(), displayIdentification0.data.end(),
205 displayIdentification1.data.begin()))
206 << "data is not stable";
207}
208
209TEST_P(GraphicsComposerAidlTest, GetHdrCapabilities) {
ramindani431aad42022-02-01 21:44:29 +0000210 const auto& [status, hdrCapabilities] =
211 mComposerClient->getHdrCapabilities(getPrimaryDisplayId());
ramindani592b6512021-10-08 21:15:19 +0000212
ramindani431aad42022-02-01 21:44:29 +0000213 ASSERT_TRUE(status.isOk());
214 EXPECT_TRUE(hdrCapabilities.maxLuminance >= hdrCapabilities.minLuminance);
ramindani592b6512021-10-08 21:15:19 +0000215}
216
217TEST_P(GraphicsComposerAidlTest, GetPerFrameMetadataKeys) {
ramindani431aad42022-02-01 21:44:29 +0000218 const auto& [status, keys] = mComposerClient->getPerFrameMetadataKeys(getPrimaryDisplayId());
ramindanid5751092022-04-22 22:30:20 +0000219 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
220 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindanic2b8d082021-11-06 02:03:50 +0000221 GTEST_SUCCEED() << "getPerFrameMetadataKeys is not supported";
222 return;
ramindani592b6512021-10-08 21:15:19 +0000223 }
ramindani431aad42022-02-01 21:44:29 +0000224
225 ASSERT_TRUE(status.isOk());
226 EXPECT_TRUE(keys.size() >= 0);
ramindani592b6512021-10-08 21:15:19 +0000227}
228
229TEST_P(GraphicsComposerAidlTest, GetReadbackBufferAttributes) {
ramindani431aad42022-02-01 21:44:29 +0000230 const auto& [status, _] = mComposerClient->getReadbackBufferAttributes(getPrimaryDisplayId());
ramindanid5751092022-04-22 22:30:20 +0000231 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
232 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindani431aad42022-02-01 21:44:29 +0000233 GTEST_SUCCEED() << "getReadbackBufferAttributes is not supported";
234 return;
ramindani592b6512021-10-08 21:15:19 +0000235 }
ramindani431aad42022-02-01 21:44:29 +0000236
237 ASSERT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000238}
239
240TEST_P(GraphicsComposerAidlTest, GetRenderIntents) {
ramindani431aad42022-02-01 21:44:29 +0000241 const auto& [status, modes] = mComposerClient->getColorModes(getPrimaryDisplayId());
242 EXPECT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000243
ramindani431aad42022-02-01 21:44:29 +0000244 for (auto mode : modes) {
245 const auto& [intentStatus, intents] =
246 mComposerClient->getRenderIntents(getPrimaryDisplayId(), mode);
247 EXPECT_TRUE(intentStatus.isOk());
ramindani592b6512021-10-08 21:15:19 +0000248 bool isHdr;
249 switch (mode) {
250 case ColorMode::BT2100_PQ:
251 case ColorMode::BT2100_HLG:
252 isHdr = true;
253 break;
254 default:
255 isHdr = false;
256 break;
257 }
258 RenderIntent requiredIntent =
259 isHdr ? RenderIntent::TONE_MAP_COLORIMETRIC : RenderIntent::COLORIMETRIC;
260
ramindani431aad42022-02-01 21:44:29 +0000261 const auto iter = std::find(intents.cbegin(), intents.cend(), requiredIntent);
ramindani592b6512021-10-08 21:15:19 +0000262 EXPECT_NE(intents.cend(), iter);
263 }
264}
265
ramindani431aad42022-02-01 21:44:29 +0000266TEST_P(GraphicsComposerAidlTest, GetRenderIntents_BadDisplay) {
267 const auto& [status, modes] = mComposerClient->getColorModes(getPrimaryDisplayId());
268 ASSERT_TRUE(status.isOk());
269
ramindani592b6512021-10-08 21:15:19 +0000270 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +0000271 const auto& [intentStatus, _] =
272 mComposerClient->getRenderIntents(getInvalidDisplayId(), mode);
273
274 EXPECT_FALSE(intentStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000275 EXPECT_NO_FATAL_FAILURE(
276 assertServiceSpecificError(intentStatus, IComposerClient::EX_BAD_DISPLAY));
ramindani592b6512021-10-08 21:15:19 +0000277 }
278}
279
ramindani431aad42022-02-01 21:44:29 +0000280TEST_P(GraphicsComposerAidlTest, GetRenderIntents_BadParameter) {
281 const auto& [status, _] =
282 mComposerClient->getRenderIntents(getPrimaryDisplayId(), static_cast<ColorMode>(-1));
283
284 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000285 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
ramindani592b6512021-10-08 21:15:19 +0000286}
287
288TEST_P(GraphicsComposerAidlTest, GetColorModes) {
ramindani431aad42022-02-01 21:44:29 +0000289 const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
290 ASSERT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000291
ramindani431aad42022-02-01 21:44:29 +0000292 const auto native = std::find(colorModes.cbegin(), colorModes.cend(), ColorMode::NATIVE);
293 EXPECT_NE(colorModes.cend(), native);
ramindani592b6512021-10-08 21:15:19 +0000294}
295
ramindani431aad42022-02-01 21:44:29 +0000296TEST_P(GraphicsComposerAidlTest, GetColorMode_BadDisplay) {
297 const auto& [status, _] = mComposerClient->getColorModes(getInvalidDisplayId());
ramindani592b6512021-10-08 21:15:19 +0000298
ramindani431aad42022-02-01 21:44:29 +0000299 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000300 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani592b6512021-10-08 21:15:19 +0000301}
302
303TEST_P(GraphicsComposerAidlTest, SetColorMode) {
ramindani431aad42022-02-01 21:44:29 +0000304 const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
305 EXPECT_TRUE(status.isOk());
306
ramindani592b6512021-10-08 21:15:19 +0000307 for (auto mode : colorModes) {
ramindani431aad42022-02-01 21:44:29 +0000308 const auto& [intentStatus, intents] =
309 mComposerClient->getRenderIntents(getPrimaryDisplayId(), mode);
310 EXPECT_TRUE(intentStatus.isOk()) << "failed to get render intents";
311
ramindani592b6512021-10-08 21:15:19 +0000312 for (auto intent : intents) {
ramindani431aad42022-02-01 21:44:29 +0000313 const auto modeStatus =
314 mComposerClient->setColorMode(getPrimaryDisplayId(), mode, intent);
315 EXPECT_TRUE(modeStatus.isOk() ||
ramindanid5751092022-04-22 22:30:20 +0000316 (modeStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
317 IComposerClient::EX_UNSUPPORTED == modeStatus.getServiceSpecificError()))
ramindani592b6512021-10-08 21:15:19 +0000318 << "failed to set color mode";
319 }
320 }
321
ramindani431aad42022-02-01 21:44:29 +0000322 const auto modeStatus = mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE,
323 RenderIntent::COLORIMETRIC);
324 EXPECT_TRUE(modeStatus.isOk() ||
ramindanid5751092022-04-22 22:30:20 +0000325 (modeStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
326 IComposerClient::EX_UNSUPPORTED == modeStatus.getServiceSpecificError()))
ramindani592b6512021-10-08 21:15:19 +0000327 << "failed to set color mode";
328}
329
ramindani431aad42022-02-01 21:44:29 +0000330TEST_P(GraphicsComposerAidlTest, SetColorMode_BadDisplay) {
331 const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
332 ASSERT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000333
ramindani431aad42022-02-01 21:44:29 +0000334 for (auto mode : colorModes) {
335 const auto& [intentStatus, intents] =
336 mComposerClient->getRenderIntents(getPrimaryDisplayId(), mode);
337 ASSERT_TRUE(intentStatus.isOk()) << "failed to get render intents";
338
339 for (auto intent : intents) {
340 auto const modeStatus =
341 mComposerClient->setColorMode(getInvalidDisplayId(), mode, intent);
342
343 EXPECT_FALSE(modeStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000344 EXPECT_NO_FATAL_FAILURE(
345 assertServiceSpecificError(modeStatus, IComposerClient::EX_BAD_DISPLAY));
ramindani770d7082021-11-30 00:36:42 +0000346 }
347 }
ramindani592b6512021-10-08 21:15:19 +0000348}
349
ramindani431aad42022-02-01 21:44:29 +0000350TEST_P(GraphicsComposerAidlTest, SetColorMode_BadParameter) {
351 auto status = mComposerClient->setColorMode(getPrimaryDisplayId(), static_cast<ColorMode>(-1),
352 RenderIntent::COLORIMETRIC);
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
ramindani431aad42022-02-01 21:44:29 +0000357 status = mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE,
358 static_cast<RenderIntent>(-1));
ramindani592b6512021-10-08 21:15:19 +0000359
ramindani431aad42022-02-01 21:44:29 +0000360 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000361 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
ramindani592b6512021-10-08 21:15:19 +0000362}
363
364TEST_P(GraphicsComposerAidlTest, GetDisplayedContentSamplingAttributes) {
ramindani431aad42022-02-01 21:44:29 +0000365 int constexpr kInvalid = -1;
366 const auto& [status, format] =
367 mComposerClient->getDisplayedContentSamplingAttributes(getPrimaryDisplayId());
ramindani592b6512021-10-08 21:15:19 +0000368
ramindanid5751092022-04-22 22:30:20 +0000369 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
370 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindani592b6512021-10-08 21:15:19 +0000371 SUCCEED() << "Device does not support optional extension. Test skipped";
372 return;
373 }
374
ramindani431aad42022-02-01 21:44:29 +0000375 ASSERT_TRUE(status.isOk());
376 EXPECT_NE(kInvalid, static_cast<int>(format.format));
377 EXPECT_NE(kInvalid, static_cast<int>(format.dataspace));
378 EXPECT_NE(kInvalid, static_cast<int>(format.componentMask));
ramindani592b6512021-10-08 21:15:19 +0000379};
380
381TEST_P(GraphicsComposerAidlTest, SetDisplayedContentSamplingEnabled) {
ramindani431aad42022-02-01 21:44:29 +0000382 int constexpr kMaxFrames = 10;
ramindani592b6512021-10-08 21:15:19 +0000383 FormatColorComponent enableAllComponents = FormatColorComponent::FORMAT_COMPONENT_0;
ramindani431aad42022-02-01 21:44:29 +0000384 auto status = mComposerClient->setDisplayedContentSamplingEnabled(
385 getPrimaryDisplayId(), /*isEnabled*/ true, enableAllComponents, kMaxFrames);
ramindanid5751092022-04-22 22:30:20 +0000386 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
387 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindani592b6512021-10-08 21:15:19 +0000388 SUCCEED() << "Device does not support optional extension. Test skipped";
389 return;
390 }
ramindani431aad42022-02-01 21:44:29 +0000391 EXPECT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000392
ramindani431aad42022-02-01 21:44:29 +0000393 status = mComposerClient->setDisplayedContentSamplingEnabled(
394 getPrimaryDisplayId(), /*isEnabled*/ false, enableAllComponents, kMaxFrames);
395 EXPECT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000396}
397
398TEST_P(GraphicsComposerAidlTest, GetDisplayedContentSample) {
ramindani431aad42022-02-01 21:44:29 +0000399 const auto& [status, displayContentSamplingAttributes] =
400 mComposerClient->getDisplayedContentSamplingAttributes(getPrimaryDisplayId());
ramindanid5751092022-04-22 22:30:20 +0000401 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
402 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindanideb059e2021-11-18 01:57:25 +0000403 SUCCEED() << "Sampling attributes aren't supported on this device, test skipped";
404 return;
405 }
ramindani592b6512021-10-08 21:15:19 +0000406
ramindani431aad42022-02-01 21:44:29 +0000407 int64_t constexpr kMaxFrames = 10;
408 int64_t constexpr kTimestamp = 0;
409 const auto& [sampleStatus, displayContentSample] = mComposerClient->getDisplayedContentSample(
410 getPrimaryDisplayId(), kMaxFrames, kTimestamp);
ramindanid5751092022-04-22 22:30:20 +0000411 if (!sampleStatus.isOk() && sampleStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
ramindani431aad42022-02-01 21:44:29 +0000412 sampleStatus.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindani592b6512021-10-08 21:15:19 +0000413 SUCCEED() << "Device does not support optional extension. Test skipped";
414 return;
415 }
416
ramindani431aad42022-02-01 21:44:29 +0000417 EXPECT_TRUE(sampleStatus.isOk());
418 const std::vector<std::vector<int64_t>> histogram = {
ramindani592b6512021-10-08 21:15:19 +0000419 displayContentSample.sampleComponent0, displayContentSample.sampleComponent1,
420 displayContentSample.sampleComponent2, displayContentSample.sampleComponent3};
421
ramindani3335f7a2021-10-25 17:22:35 +0000422 for (size_t i = 0; i < histogram.size(); i++) {
423 const bool shouldHaveHistogram =
424 static_cast<int>(displayContentSamplingAttributes.componentMask) & (1 << i);
425 EXPECT_EQ(shouldHaveHistogram, !histogram[i].empty());
ramindani592b6512021-10-08 21:15:19 +0000426 }
427}
428
ramindani431aad42022-02-01 21:44:29 +0000429TEST_P(GraphicsComposerAidlTest, GetDisplayConnectionType) {
430 const auto& [status, type] = mComposerClient->getDisplayConnectionType(getInvalidDisplayId());
431
432 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000433 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani431aad42022-02-01 21:44:29 +0000434
ramindani0291f112021-11-04 03:45:46 +0000435 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000436 const auto& [connectionTypeStatus, _] =
437 mComposerClient->getDisplayConnectionType(display.getDisplayId());
438 EXPECT_TRUE(connectionTypeStatus.isOk());
ramindani0291f112021-11-04 03:45:46 +0000439 }
440}
441
ramindani431aad42022-02-01 21:44:29 +0000442TEST_P(GraphicsComposerAidlTest, GetDisplayAttribute) {
ramindani0291f112021-11-04 03:45:46 +0000443 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000444 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
445 EXPECT_TRUE(status.isOk());
446
ramindani0291f112021-11-04 03:45:46 +0000447 for (const auto& config : configs) {
448 const std::array<DisplayAttribute, 4> requiredAttributes = {{
449 DisplayAttribute::WIDTH,
450 DisplayAttribute::HEIGHT,
451 DisplayAttribute::VSYNC_PERIOD,
452 DisplayAttribute::CONFIG_GROUP,
453 }};
ramindani0291f112021-11-04 03:45:46 +0000454 for (const auto& attribute : requiredAttributes) {
ramindani431aad42022-02-01 21:44:29 +0000455 const auto& [attribStatus, value] = mComposerClient->getDisplayAttribute(
456 display.getDisplayId(), config, attribute);
457 EXPECT_TRUE(attribStatus.isOk());
ramindani0291f112021-11-04 03:45:46 +0000458 EXPECT_NE(-1, value);
459 }
460
461 const std::array<DisplayAttribute, 2> optionalAttributes = {{
462 DisplayAttribute::DPI_X,
463 DisplayAttribute::DPI_Y,
464 }};
465 for (const auto& attribute : optionalAttributes) {
ramindani431aad42022-02-01 21:44:29 +0000466 const auto& [attribStatus, value] = mComposerClient->getDisplayAttribute(
467 display.getDisplayId(), config, attribute);
ramindanid5751092022-04-22 22:30:20 +0000468 EXPECT_TRUE(attribStatus.isOk() ||
469 (attribStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
470 IComposerClient::EX_UNSUPPORTED ==
471 attribStatus.getServiceSpecificError()));
ramindani0291f112021-11-04 03:45:46 +0000472 }
473 }
474 }
475}
476
ramindani431aad42022-02-01 21:44:29 +0000477TEST_P(GraphicsComposerAidlTest, CheckConfigsAreValid) {
ramindani0291f112021-11-04 03:45:46 +0000478 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000479 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
480 EXPECT_TRUE(status.isOk());
ramindani0291f112021-11-04 03:45:46 +0000481
482 EXPECT_FALSE(std::any_of(configs.begin(), configs.end(), [](auto config) {
483 return config == IComposerClient::INVALID_CONFIGURATION;
484 }));
485 }
486}
487
ramindani431aad42022-02-01 21:44:29 +0000488TEST_P(GraphicsComposerAidlTest, GetDisplayVsyncPeriod_BadDisplay) {
489 const auto& [status, vsyncPeriodNanos] =
490 mComposerClient->getDisplayVsyncPeriod(getInvalidDisplayId());
491
492 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000493 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani0291f112021-11-04 03:45:46 +0000494}
495
ramindani431aad42022-02-01 21:44:29 +0000496TEST_P(GraphicsComposerAidlTest, SetActiveConfigWithConstraints_BadDisplay) {
ramindani0291f112021-11-04 03:45:46 +0000497 VsyncPeriodChangeConstraints constraints;
ramindani0291f112021-11-04 03:45:46 +0000498 constraints.seamlessRequired = false;
499 constraints.desiredTimeNanos = systemTime();
ramindani431aad42022-02-01 21:44:29 +0000500 auto invalidDisplay = VtsDisplay(getInvalidDisplayId());
ramindani0291f112021-11-04 03:45:46 +0000501
ramindani431aad42022-02-01 21:44:29 +0000502 const auto& [status, timeline] = mComposerClient->setActiveConfigWithConstraints(
503 &invalidDisplay, /*config*/ 0, constraints);
504
505 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000506 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani0291f112021-11-04 03:45:46 +0000507}
508
ramindani431aad42022-02-01 21:44:29 +0000509TEST_P(GraphicsComposerAidlTest, SetActiveConfigWithConstraints_BadConfig) {
ramindani0291f112021-11-04 03:45:46 +0000510 VsyncPeriodChangeConstraints constraints;
ramindani0291f112021-11-04 03:45:46 +0000511 constraints.seamlessRequired = false;
512 constraints.desiredTimeNanos = systemTime();
513
514 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000515 int32_t constexpr kInvalidConfigId = IComposerClient::INVALID_CONFIGURATION;
516 const auto& [status, _] = mComposerClient->setActiveConfigWithConstraints(
517 &display, kInvalidConfigId, constraints);
518
519 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000520 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_CONFIG));
ramindani0291f112021-11-04 03:45:46 +0000521 }
522}
523
ramindani431aad42022-02-01 21:44:29 +0000524TEST_P(GraphicsComposerAidlTest, SetBootDisplayConfig_BadDisplay) {
ramindani476314c2022-03-16 00:17:08 +0000525 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
526 GTEST_SUCCEED() << "Boot Display Config not supported";
527 return;
528 }
ramindani431aad42022-02-01 21:44:29 +0000529 const auto& status = mComposerClient->setBootDisplayConfig(getInvalidDisplayId(), /*config*/ 0);
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100530
ramindani431aad42022-02-01 21:44:29 +0000531 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000532 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100533}
534
ramindani431aad42022-02-01 21:44:29 +0000535TEST_P(GraphicsComposerAidlTest, SetBootDisplayConfig_BadConfig) {
ramindani476314c2022-03-16 00:17:08 +0000536 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
537 GTEST_SUCCEED() << "Boot Display Config not supported";
538 return;
539 }
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100540 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000541 int32_t constexpr kInvalidConfigId = IComposerClient::INVALID_CONFIGURATION;
542 const auto& status =
543 mComposerClient->setBootDisplayConfig(display.getDisplayId(), kInvalidConfigId);
544
545 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000546 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_CONFIG));
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100547 }
548}
549
ramindani431aad42022-02-01 21:44:29 +0000550TEST_P(GraphicsComposerAidlTest, SetBootDisplayConfig) {
ramindani476314c2022-03-16 00:17:08 +0000551 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
552 GTEST_SUCCEED() << "Boot Display Config not supported";
553 return;
554 }
ramindani431aad42022-02-01 21:44:29 +0000555 const auto& [status, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
556 EXPECT_TRUE(status.isOk());
557 for (const auto& config : configs) {
558 EXPECT_TRUE(mComposerClient->setBootDisplayConfig(getPrimaryDisplayId(), config).isOk());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100559 }
560}
561
ramindani431aad42022-02-01 21:44:29 +0000562TEST_P(GraphicsComposerAidlTest, ClearBootDisplayConfig_BadDisplay) {
ramindani476314c2022-03-16 00:17:08 +0000563 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
564 GTEST_SUCCEED() << "Boot Display Config not supported";
565 return;
566 }
ramindani431aad42022-02-01 21:44:29 +0000567 const auto& status = mComposerClient->clearBootDisplayConfig(getInvalidDisplayId());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100568
ramindani431aad42022-02-01 21:44:29 +0000569 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000570 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100571}
572
ramindani431aad42022-02-01 21:44:29 +0000573TEST_P(GraphicsComposerAidlTest, ClearBootDisplayConfig) {
ramindani476314c2022-03-16 00:17:08 +0000574 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
575 GTEST_SUCCEED() << "Boot Display Config not supported";
576 return;
577 }
ramindani431aad42022-02-01 21:44:29 +0000578 EXPECT_TRUE(mComposerClient->clearBootDisplayConfig(getPrimaryDisplayId()).isOk());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100579}
580
ramindani431aad42022-02-01 21:44:29 +0000581TEST_P(GraphicsComposerAidlTest, GetPreferredBootDisplayConfig_BadDisplay) {
ramindani476314c2022-03-16 00:17:08 +0000582 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
583 GTEST_SUCCEED() << "Boot Display Config not supported";
584 return;
585 }
ramindani431aad42022-02-01 21:44:29 +0000586 const auto& [status, _] = mComposerClient->getPreferredBootDisplayConfig(getInvalidDisplayId());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100587
ramindani431aad42022-02-01 21:44:29 +0000588 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000589 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100590}
591
ramindani431aad42022-02-01 21:44:29 +0000592TEST_P(GraphicsComposerAidlTest, GetPreferredBootDisplayConfig) {
ramindani476314c2022-03-16 00:17:08 +0000593 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
594 GTEST_SUCCEED() << "Boot Display Config not supported";
595 return;
596 }
ramindani431aad42022-02-01 21:44:29 +0000597 const auto& [status, preferredDisplayConfig] =
598 mComposerClient->getPreferredBootDisplayConfig(getPrimaryDisplayId());
599 EXPECT_TRUE(status.isOk());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100600
ramindani431aad42022-02-01 21:44:29 +0000601 const auto& [configStatus, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
602
603 EXPECT_TRUE(configStatus.isOk());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100604 EXPECT_NE(configs.end(), std::find(configs.begin(), configs.end(), preferredDisplayConfig));
605}
606
ramindani476314c2022-03-16 00:17:08 +0000607TEST_P(GraphicsComposerAidlTest, BootDisplayConfig_Unsupported) {
608 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
609 const auto& [configStatus, config] =
610 mComposerClient->getActiveConfig(getPrimaryDisplayId());
611 EXPECT_TRUE(configStatus.isOk());
612
613 auto status = mComposerClient->setBootDisplayConfig(getPrimaryDisplayId(), config);
614 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000615 EXPECT_NO_FATAL_FAILURE(
616 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
ramindani476314c2022-03-16 00:17:08 +0000617
618 status = mComposerClient->getPreferredBootDisplayConfig(getPrimaryDisplayId()).first;
619 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000620 EXPECT_NO_FATAL_FAILURE(
621 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
ramindani476314c2022-03-16 00:17:08 +0000622
623 status = mComposerClient->clearBootDisplayConfig(getPrimaryDisplayId());
624 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000625 EXPECT_NO_FATAL_FAILURE(
626 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
ramindani476314c2022-03-16 00:17:08 +0000627 }
628}
629
Kriti Dang3793ebd2022-12-05 13:03:49 +0100630TEST_P(GraphicsComposerAidlTest, GetHdrConversionCapabilities) {
631 if (!hasCapability(Capability::HDR_OUTPUT_CONVERSION_CONFIG)) {
632 GTEST_SUCCEED() << "HDR output conversion not supported";
633 return;
634 }
635 const auto& [status, conversionCapabilities] = mComposerClient->getHdrConversionCapabilities();
636 EXPECT_TRUE(status.isOk());
637}
638
639TEST_P(GraphicsComposerAidlTest, SetHdrConversionStrategy_Passthrough) {
640 if (!hasCapability(Capability::HDR_OUTPUT_CONVERSION_CONFIG)) {
641 GTEST_SUCCEED() << "HDR output conversion not supported";
642 return;
643 }
644 common::HdrConversionStrategy hdrConversionStrategy;
645 hdrConversionStrategy.set<common::HdrConversionStrategy::Tag::passthrough>(true);
Kriti Dang37622762023-02-09 18:15:37 +0100646 const auto& [status, preferredHdrOutputType] =
647 mComposerClient->setHdrConversionStrategy(hdrConversionStrategy);
Kriti Dang3793ebd2022-12-05 13:03:49 +0100648 EXPECT_TRUE(status.isOk());
Kriti Dang37622762023-02-09 18:15:37 +0100649 EXPECT_EQ(common::Hdr::INVALID, preferredHdrOutputType);
Kriti Dang3793ebd2022-12-05 13:03:49 +0100650}
651
652TEST_P(GraphicsComposerAidlTest, SetHdrConversionStrategy_Force) {
653 if (!hasCapability(Capability::HDR_OUTPUT_CONVERSION_CONFIG)) {
654 GTEST_SUCCEED() << "HDR output conversion not supported";
655 return;
656 }
657 const auto& [status, conversionCapabilities] = mComposerClient->getHdrConversionCapabilities();
Kriti Dang79bbec92023-05-04 17:54:26 +0200658 const auto& [status2, hdrCapabilities] =
659 mComposerClient->getHdrCapabilities(getPrimaryDisplayId());
660 const auto& hdrTypes = hdrCapabilities.types;
Kriti Dang3793ebd2022-12-05 13:03:49 +0100661 for (auto conversionCapability : conversionCapabilities) {
Kriti Dang5fcddd72023-03-07 14:55:51 +0100662 if (conversionCapability.outputType != common::Hdr::INVALID) {
Kriti Dang79bbec92023-05-04 17:54:26 +0200663 if (std::find(hdrTypes.begin(), hdrTypes.end(), conversionCapability.outputType) ==
664 hdrTypes.end()) {
665 continue;
666 }
Kriti Dang3793ebd2022-12-05 13:03:49 +0100667 common::HdrConversionStrategy hdrConversionStrategy;
668 hdrConversionStrategy.set<common::HdrConversionStrategy::Tag::forceHdrConversion>(
Kriti Dang5fcddd72023-03-07 14:55:51 +0100669 conversionCapability.outputType);
Kriti Dang37622762023-02-09 18:15:37 +0100670 const auto& [statusSet, preferredHdrOutputType] =
Kriti Dang3793ebd2022-12-05 13:03:49 +0100671 mComposerClient->setHdrConversionStrategy(hdrConversionStrategy);
Kriti Dang37622762023-02-09 18:15:37 +0100672 EXPECT_TRUE(statusSet.isOk());
673 EXPECT_EQ(common::Hdr::INVALID, preferredHdrOutputType);
Kriti Dang3793ebd2022-12-05 13:03:49 +0100674 }
675 }
676}
677
678TEST_P(GraphicsComposerAidlTest, SetHdrConversionStrategy_Auto) {
679 if (!hasCapability(Capability::HDR_OUTPUT_CONVERSION_CONFIG)) {
680 GTEST_SUCCEED() << "HDR output conversion not supported";
681 return;
682 }
683 const auto& [status, conversionCapabilities] = mComposerClient->getHdrConversionCapabilities();
Kriti Dang79bbec92023-05-04 17:54:26 +0200684 const auto& [status2, hdrCapabilities] =
685 mComposerClient->getHdrCapabilities(getPrimaryDisplayId());
686 if (hdrCapabilities.types.size() <= 0) {
687 return;
688 }
Kriti Dang3793ebd2022-12-05 13:03:49 +0100689 std::vector<aidl::android::hardware::graphics::common::Hdr> autoHdrTypes;
690 for (auto conversionCapability : conversionCapabilities) {
Kriti Dang5fcddd72023-03-07 14:55:51 +0100691 if (conversionCapability.outputType != common::Hdr::INVALID) {
692 autoHdrTypes.push_back(conversionCapability.outputType);
Kriti Dang3793ebd2022-12-05 13:03:49 +0100693 }
694 }
695 common::HdrConversionStrategy hdrConversionStrategy;
696 hdrConversionStrategy.set<common::HdrConversionStrategy::Tag::autoAllowedHdrTypes>(
697 autoHdrTypes);
Kriti Dang37622762023-02-09 18:15:37 +0100698 const auto& [statusSet, preferredHdrOutputType] =
699 mComposerClient->setHdrConversionStrategy(hdrConversionStrategy);
700 EXPECT_TRUE(statusSet.isOk());
701 EXPECT_NE(common::Hdr::INVALID, preferredHdrOutputType);
Kriti Dang3793ebd2022-12-05 13:03:49 +0100702}
703
ramindani431aad42022-02-01 21:44:29 +0000704TEST_P(GraphicsComposerAidlTest, SetAutoLowLatencyMode_BadDisplay) {
705 auto status = mComposerClient->setAutoLowLatencyMode(getInvalidDisplayId(), /*isEnabled*/ true);
706 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000707 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani431aad42022-02-01 21:44:29 +0000708
709 status = mComposerClient->setAutoLowLatencyMode(getInvalidDisplayId(), /*isEnabled*/ false);
710 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000711 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani0291f112021-11-04 03:45:46 +0000712}
713
ramindani431aad42022-02-01 21:44:29 +0000714TEST_P(GraphicsComposerAidlTest, SetAutoLowLatencyMode) {
ramindani0291f112021-11-04 03:45:46 +0000715 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000716 const auto& [status, capabilities] =
717 mComposerClient->getDisplayCapabilities(display.getDisplayId());
718 ASSERT_TRUE(status.isOk());
ramindani0291f112021-11-04 03:45:46 +0000719
720 const bool allmSupport =
721 std::find(capabilities.begin(), capabilities.end(),
722 DisplayCapability::AUTO_LOW_LATENCY_MODE) != capabilities.end();
723
724 if (!allmSupport) {
ramindani431aad42022-02-01 21:44:29 +0000725 const auto& statusIsOn = mComposerClient->setAutoLowLatencyMode(display.getDisplayId(),
726 /*isEnabled*/ true);
727 EXPECT_FALSE(statusIsOn.isOk());
ramindanid5751092022-04-22 22:30:20 +0000728 EXPECT_NO_FATAL_FAILURE(
729 assertServiceSpecificError(statusIsOn, IComposerClient::EX_UNSUPPORTED));
ramindani431aad42022-02-01 21:44:29 +0000730 const auto& statusIsOff = mComposerClient->setAutoLowLatencyMode(display.getDisplayId(),
731 /*isEnabled*/ false);
732 EXPECT_FALSE(statusIsOff.isOk());
ramindanid5751092022-04-22 22:30:20 +0000733 EXPECT_NO_FATAL_FAILURE(
734 assertServiceSpecificError(statusIsOff, IComposerClient::EX_UNSUPPORTED));
ramindani0291f112021-11-04 03:45:46 +0000735 GTEST_SUCCEED() << "Auto Low Latency Mode is not supported on display "
ramindani431aad42022-02-01 21:44:29 +0000736 << std::to_string(display.getDisplayId()) << ", skipping test";
ramindani0291f112021-11-04 03:45:46 +0000737 return;
738 }
739
ramindani431aad42022-02-01 21:44:29 +0000740 EXPECT_TRUE(mComposerClient->setAutoLowLatencyMode(display.getDisplayId(), true).isOk());
741 EXPECT_TRUE(mComposerClient->setAutoLowLatencyMode(display.getDisplayId(), false).isOk());
ramindani0291f112021-11-04 03:45:46 +0000742 }
743}
744
ramindani431aad42022-02-01 21:44:29 +0000745TEST_P(GraphicsComposerAidlTest, GetSupportedContentTypes_BadDisplay) {
746 const auto& [status, _] = mComposerClient->getSupportedContentTypes(getInvalidDisplayId());
747
748 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000749 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani0291f112021-11-04 03:45:46 +0000750}
751
ramindani431aad42022-02-01 21:44:29 +0000752TEST_P(GraphicsComposerAidlTest, GetSupportedContentTypes) {
ramindani0291f112021-11-04 03:45:46 +0000753 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000754 const auto& [status, supportedContentTypes] =
755 mComposerClient->getSupportedContentTypes(display.getDisplayId());
756 ASSERT_TRUE(status.isOk());
ramindani0291f112021-11-04 03:45:46 +0000757
758 const bool noneSupported =
759 std::find(supportedContentTypes.begin(), supportedContentTypes.end(),
760 ContentType::NONE) != supportedContentTypes.end();
ramindani431aad42022-02-01 21:44:29 +0000761
ramindani0291f112021-11-04 03:45:46 +0000762 EXPECT_FALSE(noneSupported);
763 }
764}
765
ramindani431aad42022-02-01 21:44:29 +0000766TEST_P(GraphicsComposerAidlTest, SetContentTypeNoneAlwaysAccepted) {
ramindani0291f112021-11-04 03:45:46 +0000767 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000768 EXPECT_TRUE(
769 mComposerClient->setContentType(display.getDisplayId(), ContentType::NONE).isOk());
ramindani0291f112021-11-04 03:45:46 +0000770 }
771}
772
ramindani431aad42022-02-01 21:44:29 +0000773TEST_P(GraphicsComposerAidlTest, SetContentType_BadDisplay) {
ramindani0291f112021-11-04 03:45:46 +0000774 constexpr ContentType types[] = {ContentType::NONE, ContentType::GRAPHICS, ContentType::PHOTO,
775 ContentType::CINEMA, ContentType::GAME};
776 for (const auto& type : types) {
ramindani431aad42022-02-01 21:44:29 +0000777 const auto& status = mComposerClient->setContentType(getInvalidDisplayId(), type);
ramindani0291f112021-11-04 03:45:46 +0000778
ramindani431aad42022-02-01 21:44:29 +0000779 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000780 EXPECT_NO_FATAL_FAILURE(
781 assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani0291f112021-11-04 03:45:46 +0000782 }
783}
784
ramindani431aad42022-02-01 21:44:29 +0000785TEST_P(GraphicsComposerAidlTest, SetGraphicsContentType) {
ramindani0291f112021-11-04 03:45:46 +0000786 Test_setContentType(ContentType::GRAPHICS, "GRAPHICS");
787}
788
ramindani431aad42022-02-01 21:44:29 +0000789TEST_P(GraphicsComposerAidlTest, SetPhotoContentType) {
ramindani0291f112021-11-04 03:45:46 +0000790 Test_setContentType(ContentType::PHOTO, "PHOTO");
791}
792
ramindani431aad42022-02-01 21:44:29 +0000793TEST_P(GraphicsComposerAidlTest, SetCinemaContentType) {
ramindani0291f112021-11-04 03:45:46 +0000794 Test_setContentType(ContentType::CINEMA, "CINEMA");
795}
796
ramindani431aad42022-02-01 21:44:29 +0000797TEST_P(GraphicsComposerAidlTest, SetGameContentType) {
ramindani0291f112021-11-04 03:45:46 +0000798 Test_setContentType(ContentType::GAME, "GAME");
799}
800
ramindanic2b8d082021-11-06 02:03:50 +0000801TEST_P(GraphicsComposerAidlTest, CreateVirtualDisplay) {
ramindani431aad42022-02-01 21:44:29 +0000802 const auto& [status, maxVirtualDisplayCount] = mComposerClient->getMaxVirtualDisplayCount();
803 EXPECT_TRUE(status.isOk());
804
ramindanic2b8d082021-11-06 02:03:50 +0000805 if (maxVirtualDisplayCount == 0) {
806 GTEST_SUCCEED() << "no virtual display support";
807 return;
808 }
809
ramindani431aad42022-02-01 21:44:29 +0000810 const auto& [virtualDisplayStatus, virtualDisplay] = mComposerClient->createVirtualDisplay(
811 /*width*/ 64, /*height*/ 64, common::PixelFormat::IMPLEMENTATION_DEFINED,
812 kBufferSlotCount);
ramindanic2b8d082021-11-06 02:03:50 +0000813
ramindani431aad42022-02-01 21:44:29 +0000814 ASSERT_TRUE(virtualDisplayStatus.isOk());
ramindanic2b8d082021-11-06 02:03:50 +0000815 EXPECT_TRUE(mComposerClient->destroyVirtualDisplay(virtualDisplay.display).isOk());
816}
817
ramindani431aad42022-02-01 21:44:29 +0000818TEST_P(GraphicsComposerAidlTest, DestroyVirtualDisplay_BadDisplay) {
819 const auto& [status, maxDisplayCount] = mComposerClient->getMaxVirtualDisplayCount();
820 EXPECT_TRUE(status.isOk());
821
ramindani2740bac2021-11-24 22:58:32 +0000822 if (maxDisplayCount == 0) {
823 GTEST_SUCCEED() << "no virtual display support";
824 return;
825 }
ramindani2740bac2021-11-24 22:58:32 +0000826
ramindani431aad42022-02-01 21:44:29 +0000827 const auto& destroyStatus = mComposerClient->destroyVirtualDisplay(getInvalidDisplayId());
828
829 EXPECT_FALSE(destroyStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000830 EXPECT_NO_FATAL_FAILURE(
831 assertServiceSpecificError(destroyStatus, IComposerClient::EX_BAD_DISPLAY));
ramindani2740bac2021-11-24 22:58:32 +0000832}
833
834TEST_P(GraphicsComposerAidlTest, CreateLayer) {
ramindani431aad42022-02-01 21:44:29 +0000835 const auto& [status, layer] =
836 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
ramindani2740bac2021-11-24 22:58:32 +0000837
ramindani431aad42022-02-01 21:44:29 +0000838 EXPECT_TRUE(status.isOk());
839 EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
ramindani2740bac2021-11-24 22:58:32 +0000840}
841
ramindani431aad42022-02-01 21:44:29 +0000842TEST_P(GraphicsComposerAidlTest, CreateLayer_BadDisplay) {
843 const auto& [status, _] = mComposerClient->createLayer(getInvalidDisplayId(), kBufferSlotCount);
ramindani2740bac2021-11-24 22:58:32 +0000844
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));
ramindani2740bac2021-11-24 22:58:32 +0000847}
848
ramindani431aad42022-02-01 21:44:29 +0000849TEST_P(GraphicsComposerAidlTest, DestroyLayer_BadDisplay) {
850 const auto& [status, layer] =
851 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
852 EXPECT_TRUE(status.isOk());
ramindani2740bac2021-11-24 22:58:32 +0000853
ramindani431aad42022-02-01 21:44:29 +0000854 const auto& destroyStatus = mComposerClient->destroyLayer(getInvalidDisplayId(), layer);
ramindani2740bac2021-11-24 22:58:32 +0000855
ramindani431aad42022-02-01 21:44:29 +0000856 EXPECT_FALSE(destroyStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000857 EXPECT_NO_FATAL_FAILURE(
858 assertServiceSpecificError(destroyStatus, IComposerClient::EX_BAD_DISPLAY));
ramindani431aad42022-02-01 21:44:29 +0000859 ASSERT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
ramindani2740bac2021-11-24 22:58:32 +0000860}
861
ramindani431aad42022-02-01 21:44:29 +0000862TEST_P(GraphicsComposerAidlTest, DestroyLayer_BadLayerError) {
ramindani2740bac2021-11-24 22:58:32 +0000863 // We haven't created any layers yet, so any id should be invalid
ramindani431aad42022-02-01 21:44:29 +0000864 const auto& status = mComposerClient->destroyLayer(getPrimaryDisplayId(), /*layer*/ 1);
ramindani2740bac2021-11-24 22:58:32 +0000865
ramindani431aad42022-02-01 21:44:29 +0000866 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000867 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_LAYER));
ramindani2740bac2021-11-24 22:58:32 +0000868}
869
ramindani431aad42022-02-01 21:44:29 +0000870TEST_P(GraphicsComposerAidlTest, GetActiveConfig_BadDisplay) {
871 const auto& [status, _] = mComposerClient->getActiveConfig(getInvalidDisplayId());
ramindani2740bac2021-11-24 22:58:32 +0000872
ramindani431aad42022-02-01 21:44:29 +0000873 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000874 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani2740bac2021-11-24 22:58:32 +0000875}
876
877TEST_P(GraphicsComposerAidlTest, GetDisplayConfig) {
ramindani431aad42022-02-01 21:44:29 +0000878 const auto& [status, _] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
879 EXPECT_TRUE(status.isOk());
ramindani2740bac2021-11-24 22:58:32 +0000880}
881
ramindani431aad42022-02-01 21:44:29 +0000882TEST_P(GraphicsComposerAidlTest, GetDisplayConfig_BadDisplay) {
883 const auto& [status, _] = mComposerClient->getDisplayConfigs(getInvalidDisplayId());
ramindani2740bac2021-11-24 22:58:32 +0000884
ramindani431aad42022-02-01 21:44:29 +0000885 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000886 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani2740bac2021-11-24 22:58:32 +0000887}
888
889TEST_P(GraphicsComposerAidlTest, GetDisplayName) {
ramindani431aad42022-02-01 21:44:29 +0000890 const auto& [status, _] = mComposerClient->getDisplayName(getPrimaryDisplayId());
891 EXPECT_TRUE(status.isOk());
ramindani2740bac2021-11-24 22:58:32 +0000892}
893
ramindani431aad42022-02-01 21:44:29 +0000894TEST_P(GraphicsComposerAidlTest, GetDisplayPhysicalOrientation_BadDisplay) {
895 const auto& [status, _] = mComposerClient->getDisplayPhysicalOrientation(getInvalidDisplayId());
Ady Abrahamae12e382022-01-13 18:06:21 -0800896
ramindani431aad42022-02-01 21:44:29 +0000897 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000898 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
Ady Abrahamae12e382022-01-13 18:06:21 -0800899}
900
901TEST_P(GraphicsComposerAidlTest, GetDisplayPhysicalOrientation) {
902 const auto allowedDisplayOrientations = std::array<Transform, 4>{
903 Transform::NONE,
904 Transform::ROT_90,
905 Transform::ROT_180,
906 Transform::ROT_270,
907 };
908
ramindani431aad42022-02-01 21:44:29 +0000909 const auto& [status, displayOrientation] =
910 mComposerClient->getDisplayPhysicalOrientation(getPrimaryDisplayId());
Ady Abrahamae12e382022-01-13 18:06:21 -0800911
ramindani431aad42022-02-01 21:44:29 +0000912 EXPECT_TRUE(status.isOk());
Ady Abrahamae12e382022-01-13 18:06:21 -0800913 EXPECT_NE(std::find(allowedDisplayOrientations.begin(), allowedDisplayOrientations.end(),
914 displayOrientation),
915 allowedDisplayOrientations.end());
916}
917
ramindani2740bac2021-11-24 22:58:32 +0000918TEST_P(GraphicsComposerAidlTest, SetClientTargetSlotCount) {
ramindani431aad42022-02-01 21:44:29 +0000919 EXPECT_TRUE(mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kBufferSlotCount)
920 .isOk());
ramindani2740bac2021-11-24 22:58:32 +0000921}
922
923TEST_P(GraphicsComposerAidlTest, SetActiveConfig) {
ramindani431aad42022-02-01 21:44:29 +0000924 const auto& [status, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
925 EXPECT_TRUE(status.isOk());
926
927 for (const auto& config : configs) {
928 auto display = getEditablePrimaryDisplay();
929 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config).isOk());
930 const auto& [configStatus, config1] =
931 mComposerClient->getActiveConfig(getPrimaryDisplayId());
932 EXPECT_TRUE(configStatus.isOk());
ramindani2740bac2021-11-24 22:58:32 +0000933 EXPECT_EQ(config, config1);
934 }
935}
936
937TEST_P(GraphicsComposerAidlTest, SetActiveConfigPowerCycle) {
ramindani431aad42022-02-01 21:44:29 +0000938 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
939 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
ramindani2740bac2021-11-24 22:58:32 +0000940
ramindani431aad42022-02-01 21:44:29 +0000941 const auto& [status, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
942 EXPECT_TRUE(status.isOk());
943
944 for (const auto& config : configs) {
945 auto display = getEditablePrimaryDisplay();
946 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config).isOk());
947 const auto& [config1Status, config1] =
948 mComposerClient->getActiveConfig(getPrimaryDisplayId());
949 EXPECT_TRUE(config1Status.isOk());
ramindani2740bac2021-11-24 22:58:32 +0000950 EXPECT_EQ(config, config1);
951
ramindani431aad42022-02-01 21:44:29 +0000952 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
953 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
954 const auto& [config2Status, config2] =
955 mComposerClient->getActiveConfig(getPrimaryDisplayId());
956 EXPECT_TRUE(config2Status.isOk());
957 EXPECT_EQ(config, config2);
ramindani2740bac2021-11-24 22:58:32 +0000958 }
959}
960
ramindani2740bac2021-11-24 22:58:32 +0000961TEST_P(GraphicsComposerAidlTest, SetPowerModeUnsupported) {
ramindani431aad42022-02-01 21:44:29 +0000962 const auto& [status, capabilities] =
963 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
964 ASSERT_TRUE(status.isOk());
965
Ady Abraham6679baf2021-12-08 18:28:27 -0800966 const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
967 DisplayCapability::DOZE) != capabilities.end();
968 const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
969 DisplayCapability::SUSPEND) != capabilities.end();
ramindani2740bac2021-11-24 22:58:32 +0000970
ramindani431aad42022-02-01 21:44:29 +0000971 if (!isDozeSupported) {
972 const auto& powerModeDozeStatus =
973 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE);
974 EXPECT_FALSE(powerModeDozeStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000975 EXPECT_NO_FATAL_FAILURE(
976 assertServiceSpecificError(powerModeDozeStatus, IComposerClient::EX_UNSUPPORTED));
ramindani431aad42022-02-01 21:44:29 +0000977
978 const auto& powerModeDozeSuspendStatus =
979 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE_SUSPEND);
980 EXPECT_FALSE(powerModeDozeSuspendStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000981 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeDozeSuspendStatus,
982 IComposerClient::EX_UNSUPPORTED));
ramindani2740bac2021-11-24 22:58:32 +0000983 }
Ady Abraham6679baf2021-12-08 18:28:27 -0800984
985 if (!isSuspendSupported) {
ramindani431aad42022-02-01 21:44:29 +0000986 const auto& powerModeSuspendStatus =
987 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON_SUSPEND);
988 EXPECT_FALSE(powerModeSuspendStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000989 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeSuspendStatus,
990 IComposerClient::EX_UNSUPPORTED));
Ady Abraham6679baf2021-12-08 18:28:27 -0800991
ramindani431aad42022-02-01 21:44:29 +0000992 const auto& powerModeDozeSuspendStatus =
993 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE_SUSPEND);
994 EXPECT_FALSE(powerModeDozeSuspendStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000995 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeDozeSuspendStatus,
996 IComposerClient::EX_UNSUPPORTED));
Ady Abraham6679baf2021-12-08 18:28:27 -0800997 }
ramindani2740bac2021-11-24 22:58:32 +0000998}
999
1000TEST_P(GraphicsComposerAidlTest, SetVsyncEnabled) {
ramindani431aad42022-02-01 21:44:29 +00001001 mComposerClient->setVsyncAllowed(true);
ramindani2740bac2021-11-24 22:58:32 +00001002
ramindani431aad42022-02-01 21:44:29 +00001003 EXPECT_TRUE(mComposerClient->setVsync(getPrimaryDisplayId(), true).isOk());
ramindani2740bac2021-11-24 22:58:32 +00001004 usleep(60 * 1000);
ramindani431aad42022-02-01 21:44:29 +00001005 EXPECT_TRUE(mComposerClient->setVsync(getPrimaryDisplayId(), false).isOk());
ramindani2740bac2021-11-24 22:58:32 +00001006
ramindani431aad42022-02-01 21:44:29 +00001007 mComposerClient->setVsyncAllowed(false);
ramindani2740bac2021-11-24 22:58:32 +00001008}
1009
ramindanic2b8d082021-11-06 02:03:50 +00001010TEST_P(GraphicsComposerAidlTest, SetPowerMode) {
ramindani431aad42022-02-01 21:44:29 +00001011 const auto& [status, capabilities] =
1012 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
1013 ASSERT_TRUE(status.isOk());
1014
Ady Abraham6679baf2021-12-08 18:28:27 -08001015 const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
1016 DisplayCapability::DOZE) != capabilities.end();
1017 const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
1018 DisplayCapability::SUSPEND) != capabilities.end();
1019
ramindanic2b8d082021-11-06 02:03:50 +00001020 std::vector<PowerMode> modes;
1021 modes.push_back(PowerMode::OFF);
ramindanic2b8d082021-11-06 02:03:50 +00001022 modes.push_back(PowerMode::ON);
1023
Ady Abraham6679baf2021-12-08 18:28:27 -08001024 if (isSuspendSupported) {
1025 modes.push_back(PowerMode::ON_SUSPEND);
1026 }
1027
ramindani770d7082021-11-30 00:36:42 +00001028 if (isDozeSupported) {
1029 modes.push_back(PowerMode::DOZE);
Ady Abraham6679baf2021-12-08 18:28:27 -08001030 }
1031
1032 if (isSuspendSupported && isDozeSupported) {
ramindani770d7082021-11-30 00:36:42 +00001033 modes.push_back(PowerMode::DOZE_SUSPEND);
1034 }
1035
ramindanic2b8d082021-11-06 02:03:50 +00001036 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001037 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindanic2b8d082021-11-06 02:03:50 +00001038 }
1039}
1040
1041TEST_P(GraphicsComposerAidlTest, SetPowerModeVariations) {
ramindani431aad42022-02-01 21:44:29 +00001042 const auto& [status, capabilities] =
1043 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
1044 ASSERT_TRUE(status.isOk());
1045
Ady Abraham6679baf2021-12-08 18:28:27 -08001046 const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
1047 DisplayCapability::DOZE) != capabilities.end();
1048 const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
1049 DisplayCapability::SUSPEND) != capabilities.end();
1050
ramindanic2b8d082021-11-06 02:03:50 +00001051 std::vector<PowerMode> modes;
1052
1053 modes.push_back(PowerMode::OFF);
ramindani770d7082021-11-30 00:36:42 +00001054 modes.push_back(PowerMode::ON);
ramindanic2b8d082021-11-06 02:03:50 +00001055 modes.push_back(PowerMode::OFF);
ramindanic2b8d082021-11-06 02:03:50 +00001056 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001057 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindanic2b8d082021-11-06 02:03:50 +00001058 }
ramindani770d7082021-11-30 00:36:42 +00001059 modes.clear();
ramindanic2b8d082021-11-06 02:03:50 +00001060
ramindani770d7082021-11-30 00:36:42 +00001061 modes.push_back(PowerMode::OFF);
1062 modes.push_back(PowerMode::OFF);
1063 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001064 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindani770d7082021-11-30 00:36:42 +00001065 }
ramindanic2b8d082021-11-06 02:03:50 +00001066 modes.clear();
1067
1068 modes.push_back(PowerMode::ON);
1069 modes.push_back(PowerMode::ON);
ramindanic2b8d082021-11-06 02:03:50 +00001070 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001071 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindanic2b8d082021-11-06 02:03:50 +00001072 }
ramindanic2b8d082021-11-06 02:03:50 +00001073 modes.clear();
1074
Ady Abraham6679baf2021-12-08 18:28:27 -08001075 if (isSuspendSupported) {
1076 modes.push_back(PowerMode::ON_SUSPEND);
1077 modes.push_back(PowerMode::ON_SUSPEND);
1078 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001079 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
Ady Abraham6679baf2021-12-08 18:28:27 -08001080 }
1081 modes.clear();
ramindanic2b8d082021-11-06 02:03:50 +00001082 }
1083
ramindanic2b8d082021-11-06 02:03:50 +00001084 if (isDozeSupported) {
ramindanic2b8d082021-11-06 02:03:50 +00001085 modes.push_back(PowerMode::DOZE);
1086 modes.push_back(PowerMode::DOZE);
ramindanic2b8d082021-11-06 02:03:50 +00001087 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001088 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindanic2b8d082021-11-06 02:03:50 +00001089 }
ramindanic2b8d082021-11-06 02:03:50 +00001090 modes.clear();
Ady Abraham6679baf2021-12-08 18:28:27 -08001091 }
ramindanic2b8d082021-11-06 02:03:50 +00001092
Ady Abraham6679baf2021-12-08 18:28:27 -08001093 if (isSuspendSupported && isDozeSupported) {
ramindanic2b8d082021-11-06 02:03:50 +00001094 modes.push_back(PowerMode::DOZE_SUSPEND);
1095 modes.push_back(PowerMode::DOZE_SUSPEND);
ramindanic2b8d082021-11-06 02:03:50 +00001096 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001097 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindanic2b8d082021-11-06 02:03:50 +00001098 }
Ady Abraham6679baf2021-12-08 18:28:27 -08001099 modes.clear();
ramindanic2b8d082021-11-06 02:03:50 +00001100 }
1101}
1102
ramindani431aad42022-02-01 21:44:29 +00001103TEST_P(GraphicsComposerAidlTest, SetPowerMode_BadDisplay) {
1104 const auto& status = mComposerClient->setPowerMode(getInvalidDisplayId(), PowerMode::ON);
ramindanic2b8d082021-11-06 02:03:50 +00001105
ramindani431aad42022-02-01 21:44:29 +00001106 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00001107 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindanic2b8d082021-11-06 02:03:50 +00001108}
1109
ramindani431aad42022-02-01 21:44:29 +00001110TEST_P(GraphicsComposerAidlTest, SetPowerMode_BadParameter) {
1111 const auto& status =
1112 mComposerClient->setPowerMode(getPrimaryDisplayId(), static_cast<PowerMode>(-1));
ramindanic2b8d082021-11-06 02:03:50 +00001113
ramindani431aad42022-02-01 21:44:29 +00001114 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00001115 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
ramindanic2b8d082021-11-06 02:03:50 +00001116}
1117
ramindanic2b8d082021-11-06 02:03:50 +00001118TEST_P(GraphicsComposerAidlTest, GetDataspaceSaturationMatrix) {
ramindani431aad42022-02-01 21:44:29 +00001119 const auto& [status, matrix] =
1120 mComposerClient->getDataspaceSaturationMatrix(common::Dataspace::SRGB_LINEAR);
1121 ASSERT_TRUE(status.isOk());
1122 ASSERT_EQ(16, matrix.size()); // matrix should not be empty if call succeeded.
ramindanideb059e2021-11-18 01:57:25 +00001123
ramindanic2b8d082021-11-06 02:03:50 +00001124 // the last row is known
ramindani431aad42022-02-01 21:44:29 +00001125 EXPECT_EQ(0.0f, matrix[12]);
1126 EXPECT_EQ(0.0f, matrix[13]);
1127 EXPECT_EQ(0.0f, matrix[14]);
1128 EXPECT_EQ(1.0f, matrix[15]);
ramindanic2b8d082021-11-06 02:03:50 +00001129}
1130
ramindani431aad42022-02-01 21:44:29 +00001131TEST_P(GraphicsComposerAidlTest, GetDataspaceSaturationMatrix_BadParameter) {
1132 const auto& [status, matrix] =
1133 mComposerClient->getDataspaceSaturationMatrix(common::Dataspace::UNKNOWN);
ramindanic2b8d082021-11-06 02:03:50 +00001134
ramindani431aad42022-02-01 21:44:29 +00001135 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00001136 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
ramindanic2b8d082021-11-06 02:03:50 +00001137}
1138
ramindani12423f52023-06-14 20:04:51 -07001139/*
1140 * Test that no two display configs are exactly the same.
1141 */
1142TEST_P(GraphicsComposerAidlTest, GetDisplayConfigNoRepetitions) {
1143 for (const auto& display : mDisplays) {
1144 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
1145 for (std::vector<int>::size_type i = 0; i < configs.size(); i++) {
1146 for (std::vector<int>::size_type j = i + 1; j < configs.size(); j++) {
1147 const auto& [widthStatus1, width1] = mComposerClient->getDisplayAttribute(
1148 display.getDisplayId(), configs[i], DisplayAttribute::WIDTH);
1149 const auto& [heightStatus1, height1] = mComposerClient->getDisplayAttribute(
1150 display.getDisplayId(), configs[i], DisplayAttribute::HEIGHT);
1151 const auto& [vsyncPeriodStatus1, vsyncPeriod1] =
1152 mComposerClient->getDisplayAttribute(display.getDisplayId(), configs[i],
1153 DisplayAttribute::VSYNC_PERIOD);
1154 const auto& [groupStatus1, group1] = mComposerClient->getDisplayAttribute(
1155 display.getDisplayId(), configs[i], DisplayAttribute::CONFIG_GROUP);
1156
1157 const auto& [widthStatus2, width2] = mComposerClient->getDisplayAttribute(
1158 display.getDisplayId(), configs[j], DisplayAttribute::WIDTH);
1159 const auto& [heightStatus2, height2] = mComposerClient->getDisplayAttribute(
1160 display.getDisplayId(), configs[j], DisplayAttribute::HEIGHT);
1161 const auto& [vsyncPeriodStatus2, vsyncPeriod2] =
1162 mComposerClient->getDisplayAttribute(display.getDisplayId(), configs[j],
1163 DisplayAttribute::VSYNC_PERIOD);
1164 const auto& [groupStatus2, group2] = mComposerClient->getDisplayAttribute(
1165 display.getDisplayId(), configs[j], DisplayAttribute::CONFIG_GROUP);
1166
1167 ASSERT_FALSE(width1 == width2 && height1 == height2 &&
1168 vsyncPeriod1 == vsyncPeriod2 && group1 == group2);
1169 }
1170 }
1171 }
1172}
1173
1174class GraphicsComposerAidlV2Test : public GraphicsComposerAidlTest {
1175 protected:
1176 void SetUp() override {
1177 GraphicsComposerAidlTest::SetUp();
1178 if (getInterfaceVersion() <= 1) {
1179 GTEST_SKIP() << "Device interface version is expected to be >= 2";
1180 }
1181 }
1182};
1183
1184TEST_P(GraphicsComposerAidlV2Test, GetOverlaySupport) {
1185 const auto& [status, properties] = mComposerClient->getOverlaySupport();
1186 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
1187 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
1188 GTEST_SUCCEED() << "getOverlaySupport is not supported";
1189 return;
1190 }
1191
1192 ASSERT_TRUE(status.isOk());
1193 for (const auto& i : properties.combinations) {
1194 for (const auto standard : i.standards) {
1195 const auto val = static_cast<int32_t>(standard) &
1196 static_cast<int32_t>(common::Dataspace::STANDARD_MASK);
1197 ASSERT_TRUE(val == static_cast<int32_t>(standard));
1198 }
1199 for (const auto transfer : i.transfers) {
1200 const auto val = static_cast<int32_t>(transfer) &
1201 static_cast<int32_t>(common::Dataspace::TRANSFER_MASK);
1202 ASSERT_TRUE(val == static_cast<int32_t>(transfer));
1203 }
1204 for (const auto range : i.ranges) {
1205 const auto val = static_cast<int32_t>(range) &
1206 static_cast<int32_t>(common::Dataspace::RANGE_MASK);
1207 ASSERT_TRUE(val == static_cast<int32_t>(range));
1208 }
1209 }
1210}
1211
ramindani02fe4772023-06-30 18:04:41 -07001212class GraphicsComposerAidlV3Test : public GraphicsComposerAidlTest {
1213 protected:
1214 void SetUp() override {
1215 GraphicsComposerAidlTest::SetUp();
1216 if (getInterfaceVersion() <= 2) {
1217 GTEST_SKIP() << "Device interface version is expected to be >= 3";
1218 }
1219 }
1220};
1221
1222TEST_P(GraphicsComposerAidlV3Test, GetDisplayConfigurations) {
1223 for (const auto& display : mDisplays) {
1224 const auto& [status, displayConfigurations] =
1225 mComposerClient->getDisplayConfigurations(display.getDisplayId());
1226 EXPECT_TRUE(status.isOk());
1227 EXPECT_FALSE(displayConfigurations.empty());
1228
1229 for (const auto& displayConfig : displayConfigurations) {
1230 EXPECT_NE(-1, displayConfig.width);
1231 EXPECT_NE(-1, displayConfig.height);
1232 EXPECT_NE(-1, displayConfig.vsyncPeriod);
1233 EXPECT_NE(-1, displayConfig.configGroup);
1234 if (displayConfig.dpi) {
ramindani2b2ec502023-08-25 18:47:38 -07001235 EXPECT_NE(-1.f, displayConfig.dpi->x);
1236 EXPECT_NE(-1.f, displayConfig.dpi->y);
ramindani02fe4772023-06-30 18:04:41 -07001237 }
ramindani2704c5f2023-07-18 20:53:24 -07001238 if (displayConfig.vrrConfig) {
1239 const auto& vrrConfig = *displayConfig.vrrConfig;
1240 EXPECT_GE(vrrConfig.minFrameIntervalNs, displayConfig.vsyncPeriod);
1241
ramindani2b2ec502023-08-25 18:47:38 -07001242 EXPECT_EQ(1, std::count_if(
1243 displayConfigurations.cbegin(), displayConfigurations.cend(),
1244 [displayConfig](const auto& config) {
1245 return config.configGroup == displayConfig.configGroup;
1246 }))
1247 << "There should be only one VRR mode in one ConfigGroup";
1248
ramindani2704c5f2023-07-18 20:53:24 -07001249 const auto verifyFrameIntervalIsDivisorOfVsync = [&](int32_t frameIntervalNs) {
1250 constexpr auto kThreshold = 0.05f; // 5%
1251 const auto ratio =
1252 static_cast<float>(frameIntervalNs) / displayConfig.vsyncPeriod;
1253 return ratio - std::round(ratio) <= kThreshold;
1254 };
1255
1256 EXPECT_TRUE(verifyFrameIntervalIsDivisorOfVsync(vrrConfig.minFrameIntervalNs));
1257
1258 if (vrrConfig.frameIntervalPowerHints) {
1259 const auto& frameIntervalPowerHints = *vrrConfig.frameIntervalPowerHints;
1260 EXPECT_FALSE(frameIntervalPowerHints.empty());
1261
1262 const auto minFrameInterval = *min_element(frameIntervalPowerHints.cbegin(),
1263 frameIntervalPowerHints.cend());
1264 EXPECT_LE(minFrameInterval->frameIntervalNs,
1265 VtsComposerClient::kMaxFrameIntervalNs);
1266
1267 EXPECT_TRUE(std::all_of(frameIntervalPowerHints.cbegin(),
1268 frameIntervalPowerHints.cend(),
1269 [&](const auto& frameIntervalPowerHint) {
1270 return verifyFrameIntervalIsDivisorOfVsync(
1271 frameIntervalPowerHint->frameIntervalNs);
1272 }));
1273 }
1274
1275 if (vrrConfig.notifyExpectedPresentConfig) {
1276 const auto& notifyExpectedPresentConfig =
1277 *vrrConfig.notifyExpectedPresentConfig;
Ram Indani82426a42023-09-01 20:02:50 +00001278 EXPECT_GT(0, notifyExpectedPresentConfig.notifyExpectedPresentHeadsUpNs);
1279 EXPECT_GE(0, notifyExpectedPresentConfig.notifyExpectedPresentTimeoutNs);
ramindani2704c5f2023-07-18 20:53:24 -07001280 }
1281 }
ramindani02fe4772023-06-30 18:04:41 -07001282 }
1283 }
1284}
1285
1286TEST_P(GraphicsComposerAidlV3Test, GetDisplayConfigsIsSubsetOfGetDisplayConfigurations) {
1287 for (const auto& display : mDisplays) {
1288 const auto& [status, displayConfigurations] =
1289 mComposerClient->getDisplayConfigurations(display.getDisplayId());
1290 EXPECT_TRUE(status.isOk());
1291
1292 const auto& [legacyConfigStatus, legacyConfigs] =
1293 mComposerClient->getDisplayConfigs(display.getDisplayId());
1294 EXPECT_TRUE(legacyConfigStatus.isOk());
1295 EXPECT_FALSE(legacyConfigs.empty());
1296 EXPECT_TRUE(legacyConfigs.size() <= displayConfigurations.size());
1297
1298 for (const auto legacyConfigId : legacyConfigs) {
1299 const auto& legacyWidth = mComposerClient->getDisplayAttribute(
1300 display.getDisplayId(), legacyConfigId, DisplayAttribute::WIDTH);
1301 const auto& legacyHeight = mComposerClient->getDisplayAttribute(
1302 display.getDisplayId(), legacyConfigId, DisplayAttribute::HEIGHT);
1303 const auto& legacyVsyncPeriod = mComposerClient->getDisplayAttribute(
1304 display.getDisplayId(), legacyConfigId, DisplayAttribute::VSYNC_PERIOD);
1305 const auto& legacyConfigGroup = mComposerClient->getDisplayAttribute(
1306 display.getDisplayId(), legacyConfigId, DisplayAttribute::CONFIG_GROUP);
1307 const auto& legacyDpiX = mComposerClient->getDisplayAttribute(
1308 display.getDisplayId(), legacyConfigId, DisplayAttribute::DPI_X);
1309 const auto& legacyDpiY = mComposerClient->getDisplayAttribute(
1310 display.getDisplayId(), legacyConfigId, DisplayAttribute::DPI_Y);
1311
1312 EXPECT_TRUE(legacyWidth.first.isOk() && legacyHeight.first.isOk() &&
1313 legacyVsyncPeriod.first.isOk() && legacyConfigGroup.first.isOk());
1314
1315 EXPECT_TRUE(std::any_of(
1316 displayConfigurations.begin(), displayConfigurations.end(),
1317 [&](const auto& displayConfiguration) {
1318 const bool requiredAttributesPredicate =
1319 displayConfiguration.configId == legacyConfigId &&
1320 displayConfiguration.width == legacyWidth.second &&
1321 displayConfiguration.height == legacyHeight.second &&
1322 displayConfiguration.vsyncPeriod == legacyVsyncPeriod.second &&
1323 displayConfiguration.configGroup == legacyConfigGroup.second;
1324
1325 if (!requiredAttributesPredicate) {
1326 // Required attributes did not match
1327 return false;
1328 }
1329
1330 // Check optional attributes
1331 const auto& [legacyDpiXStatus, legacyDpiXValue] = legacyDpiX;
1332 const auto& [legacyDpiYStatus, legacyDpiYValue] = legacyDpiY;
1333 if (displayConfiguration.dpi) {
1334 if (!legacyDpiXStatus.isOk() || !legacyDpiYStatus.isOk()) {
1335 // getDisplayAttribute failed for optional attributes
1336 return false;
1337 }
1338
1339 // DPI values in DisplayConfigurations are not scaled (* 1000.f)
1340 // the way they are in the legacy DisplayConfigs.
1341 constexpr float kEpsilon = 0.001f;
1342 return std::abs(displayConfiguration.dpi->x -
1343 legacyDpiXValue / 1000.f) < kEpsilon &&
1344 std::abs(displayConfiguration.dpi->y -
1345 legacyDpiYValue / 1000.f) < kEpsilon;
1346 } else {
1347 return !legacyDpiXStatus.isOk() && !legacyDpiYStatus.isOk() &&
1348 EX_SERVICE_SPECIFIC == legacyDpiXStatus.getExceptionCode() &&
1349 EX_SERVICE_SPECIFIC == legacyDpiYStatus.getExceptionCode() &&
1350 IComposerClient::EX_UNSUPPORTED ==
1351 legacyDpiXStatus.getServiceSpecificError() &&
1352 IComposerClient::EX_UNSUPPORTED ==
1353 legacyDpiYStatus.getServiceSpecificError();
1354 }
1355 }));
1356 }
1357 }
1358}
1359
ramindani2704c5f2023-07-18 20:53:24 -07001360// TODO(b/291792736) Add detailed VTS test cases for NotifyExpectedPresent
1361TEST_P(GraphicsComposerAidlV3Test, NotifyExpectedPresent) {
1362 for (const auto& display : mDisplays) {
1363 EXPECT_TRUE(mComposerClient
1364 ->notifyExpectedPresent(display.getDisplayId(),
1365 ClockMonotonicTimestamp{0},
1366 std::chrono::nanoseconds{8ms}.count())
1367 .isOk());
1368 }
1369}
1370
ramindanidcfe3a82021-11-29 17:00:31 +00001371// Tests for Command.
1372class GraphicsComposerAidlCommandTest : public GraphicsComposerAidlTest {
1373 protected:
ramindanidcfe3a82021-11-29 17:00:31 +00001374 void TearDown() override {
Ady Abraham3192f3d2021-12-03 16:08:56 -08001375 const auto errors = mReader.takeErrors();
1376 ASSERT_TRUE(mReader.takeErrors().empty());
ramindani431aad42022-02-01 21:44:29 +00001377 ASSERT_TRUE(mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty());
Ady Abraham3192f3d2021-12-03 16:08:56 -08001378
ramindanidcfe3a82021-11-29 17:00:31 +00001379 ASSERT_NO_FATAL_FAILURE(GraphicsComposerAidlTest::TearDown());
1380 }
1381
1382 void execute() {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001383 std::vector<CommandResultPayload> payloads;
1384 for (auto& [_, writer] : mWriters) {
Joen Chene0a962c2023-08-28 09:49:11 +00001385 executeInternal(writer, payloads);
ramindanidcfe3a82021-11-29 17:00:31 +00001386 }
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001387 mReader.parse(std::move(payloads));
ramindanidcfe3a82021-11-29 17:00:31 +00001388 }
1389
Joen Chene0a962c2023-08-28 09:49:11 +00001390 void execute(ComposerClientWriter& writer, ComposerClientReader& reader) {
1391 std::vector<CommandResultPayload> payloads;
1392 executeInternal(writer, payloads);
1393 reader.parse(std::move(payloads));
1394 }
1395
ramindanidcfe3a82021-11-29 17:00:31 +00001396 static inline auto toTimePoint(nsecs_t time) {
1397 return std::chrono::time_point<std::chrono::steady_clock>(std::chrono::nanoseconds(time));
1398 }
1399
ramindanidcfe3a82021-11-29 17:00:31 +00001400 void forEachTwoConfigs(int64_t display, std::function<void(int32_t, int32_t)> func) {
ramindani431aad42022-02-01 21:44:29 +00001401 const auto& [status, displayConfigs] = mComposerClient->getDisplayConfigs(display);
1402 ASSERT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001403 for (const int32_t config1 : displayConfigs) {
1404 for (const int32_t config2 : displayConfigs) {
1405 if (config1 != config2) {
1406 func(config1, config2);
1407 }
1408 }
1409 }
1410 }
1411
1412 void waitForVsyncPeriodChange(int64_t display, const VsyncPeriodChangeTimeline& timeline,
1413 int64_t desiredTimeNanos, int64_t oldPeriodNanos,
1414 int64_t newPeriodNanos) {
1415 const auto kChangeDeadline = toTimePoint(timeline.newVsyncAppliedTimeNanos) + 100ms;
1416 while (std::chrono::steady_clock::now() <= kChangeDeadline) {
ramindani431aad42022-02-01 21:44:29 +00001417 const auto& [status, vsyncPeriodNanos] =
1418 mComposerClient->getDisplayVsyncPeriod(display);
1419 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001420 if (systemTime() <= desiredTimeNanos) {
1421 EXPECT_EQ(vsyncPeriodNanos, oldPeriodNanos);
1422 } else if (vsyncPeriodNanos == newPeriodNanos) {
1423 break;
1424 }
1425 std::this_thread::sleep_for(std::chrono::nanoseconds(oldPeriodNanos));
1426 }
1427 }
1428
ramindani9dd8c482023-02-21 18:07:56 -08001429 bool checkIfCallbackRefreshRateChangedDebugEnabledReceived(
1430 std::function<bool(RefreshRateChangedDebugData)> filter) {
1431 const auto list = mComposerClient->takeListOfRefreshRateChangedDebugData();
1432 return std::any_of(list.begin(), list.end(), [&](auto refreshRateChangedDebugData) {
1433 return filter(refreshRateChangedDebugData);
1434 });
1435 }
1436
Brian Lindahl25e0d092022-12-09 00:32:11 -07001437 sp<GraphicBuffer> allocate(uint32_t width, uint32_t height,
1438 ::android::PixelFormat pixelFormat) {
Brian Lindahl14bd07b2023-01-17 14:54:39 -07001439 return sp<GraphicBuffer>::make(
Brian Lindahl25e0d092022-12-09 00:32:11 -07001440 width, height, pixelFormat, /*layerCount*/ 1U,
1441 static_cast<uint64_t>(common::BufferUsage::CPU_WRITE_OFTEN) |
1442 static_cast<uint64_t>(common::BufferUsage::CPU_READ_OFTEN) |
1443 static_cast<uint64_t>(common::BufferUsage::COMPOSER_OVERLAY),
Brian Lindahl14bd07b2023-01-17 14:54:39 -07001444 "VtsHalGraphicsComposer3_TargetTest");
Brian Lindahlca3eef22022-12-09 00:32:11 -07001445 }
1446
Brian Lindahl25e0d092022-12-09 00:32:11 -07001447 sp<GraphicBuffer> allocate(::android::PixelFormat pixelFormat) {
1448 return allocate(static_cast<uint32_t>(getPrimaryDisplay().getDisplayWidth()),
1449 static_cast<uint32_t>(getPrimaryDisplay().getDisplayHeight()), pixelFormat);
1450 }
1451
ramindanidcfe3a82021-11-29 17:00:31 +00001452 void sendRefreshFrame(const VtsDisplay& display, const VsyncPeriodChangeTimeline* timeline) {
1453 if (timeline != nullptr) {
1454 // Refresh time should be before newVsyncAppliedTimeNanos
1455 EXPECT_LT(timeline->refreshTimeNanos, timeline->newVsyncAppliedTimeNanos);
1456
1457 std::this_thread::sleep_until(toTimePoint(timeline->refreshTimeNanos));
1458 }
1459
ramindani431aad42022-02-01 21:44:29 +00001460 EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::ON).isOk());
1461 EXPECT_TRUE(mComposerClient
1462 ->setColorMode(display.getDisplayId(), ColorMode::NATIVE,
1463 RenderIntent::COLORIMETRIC)
1464 .isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001465
ramindani431aad42022-02-01 21:44:29 +00001466 const auto& [status, layer] =
1467 mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount);
1468 EXPECT_TRUE(status.isOk());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001469 auto& writer = getWriter(display.getDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001470 {
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001471 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindanidcfe3a82021-11-29 17:00:31 +00001472 ASSERT_NE(nullptr, buffer);
1473 ASSERT_EQ(::android::OK, buffer->initCheck());
1474 ASSERT_NE(nullptr, buffer->handle);
1475
ramindani431aad42022-02-01 21:44:29 +00001476 configureLayer(display, layer, Composition::DEVICE, display.getFrameRect(),
1477 display.getCrop());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001478 writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, buffer->handle,
1479 /*acquireFence*/ -1);
1480 writer.setLayerDataspace(display.getDisplayId(), layer, common::Dataspace::UNKNOWN);
ramindanidcfe3a82021-11-29 17:00:31 +00001481
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001482 writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp);
ramindanidcfe3a82021-11-29 17:00:31 +00001483 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001484 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001485
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001486 writer.presentDisplay(display.getDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001487 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001488 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001489 }
1490
1491 {
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001492 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindanidcfe3a82021-11-29 17:00:31 +00001493 ASSERT_NE(nullptr, buffer->handle);
1494
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001495 writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, buffer->handle,
1496 /*acquireFence*/ -1);
1497 writer.setLayerSurfaceDamage(display.getDisplayId(), layer,
1498 std::vector<Rect>(1, {0, 0, 10, 10}));
1499 writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp);
ramindanidcfe3a82021-11-29 17:00:31 +00001500 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001501 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001502
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001503 writer.presentDisplay(display.getDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001504 execute();
1505 }
1506
ramindani431aad42022-02-01 21:44:29 +00001507 EXPECT_TRUE(mComposerClient->destroyLayer(display.getDisplayId(), layer).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001508 }
1509
Ady Abraham72c5b502021-12-10 17:23:39 -08001510 sp<::android::Fence> presentAndGetFence(
1511 std::optional<ClockMonotonicTimestamp> expectedPresentTime) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001512 auto& writer = getWriter(getPrimaryDisplayId());
1513 writer.validateDisplay(getPrimaryDisplayId(), expectedPresentTime);
Ady Abraham72c5b502021-12-10 17:23:39 -08001514 execute();
1515 EXPECT_TRUE(mReader.takeErrors().empty());
1516
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001517 writer.presentDisplay(getPrimaryDisplayId());
Ady Abraham72c5b502021-12-10 17:23:39 -08001518 execute();
1519 EXPECT_TRUE(mReader.takeErrors().empty());
1520
ramindani431aad42022-02-01 21:44:29 +00001521 auto presentFence = mReader.takePresentFence(getPrimaryDisplayId());
Ady Abraham46219f52021-12-20 09:44:31 -08001522 // take ownership
1523 const int fenceOwner = presentFence.get();
1524 *presentFence.getR() = -1;
1525 EXPECT_NE(-1, fenceOwner);
1526 return sp<::android::Fence>::make(fenceOwner);
Ady Abraham72c5b502021-12-10 17:23:39 -08001527 }
1528
1529 int32_t getVsyncPeriod() {
ramindani431aad42022-02-01 21:44:29 +00001530 const auto& [status, activeConfig] =
1531 mComposerClient->getActiveConfig(getPrimaryDisplayId());
1532 EXPECT_TRUE(status.isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001533
ramindani431aad42022-02-01 21:44:29 +00001534 const auto& [vsyncPeriodStatus, vsyncPeriod] = mComposerClient->getDisplayAttribute(
1535 getPrimaryDisplayId(), activeConfig, DisplayAttribute::VSYNC_PERIOD);
1536 EXPECT_TRUE(vsyncPeriodStatus.isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001537 return vsyncPeriod;
1538 }
1539
ramindani9dd8c482023-02-21 18:07:56 -08001540 int64_t createOnScreenLayer(Composition composition = Composition::DEVICE) {
ramindani431aad42022-02-01 21:44:29 +00001541 const auto& [status, layer] =
1542 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1543 EXPECT_TRUE(status.isOk());
1544 Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
1545 getPrimaryDisplay().getDisplayHeight()};
1546 FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
1547 (float)getPrimaryDisplay().getDisplayHeight()};
ramindani9dd8c482023-02-21 18:07:56 -08001548 configureLayer(getPrimaryDisplay(), layer, composition, displayFrame, cropRect);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001549 auto& writer = getWriter(getPrimaryDisplayId());
1550 writer.setLayerDataspace(getPrimaryDisplayId(), layer, common::Dataspace::UNKNOWN);
Ady Abraham72c5b502021-12-10 17:23:39 -08001551 return layer;
1552 }
1553
ramindani9dd8c482023-02-21 18:07:56 -08001554 void sendBufferUpdate(int64_t layer) {
1555 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1556 ASSERT_NE(nullptr, buffer->handle);
1557
1558 auto& writer = getWriter(getPrimaryDisplayId());
1559 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer->handle,
1560 /*acquireFence*/ -1);
1561
1562 const sp<::android::Fence> presentFence =
1563 presentAndGetFence(ComposerClientWriter::kNoTimestamp);
1564 presentFence->waitForever(LOG_TAG);
1565 }
1566
Midas Chiena0b56bd2022-01-13 23:27:33 +08001567 bool hasDisplayCapability(int64_t display, DisplayCapability cap) {
ramindani431aad42022-02-01 21:44:29 +00001568 const auto& [status, capabilities] = mComposerClient->getDisplayCapabilities(display);
1569 EXPECT_TRUE(status.isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08001570
1571 return std::find(capabilities.begin(), capabilities.end(), cap) != capabilities.end();
1572 }
1573
ramindanidcfe3a82021-11-29 17:00:31 +00001574 void Test_setActiveConfigWithConstraints(const TestParameters& params) {
1575 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +00001576 forEachTwoConfigs(display.getDisplayId(), [&](int32_t config1, int32_t config2) {
1577 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001578 sendRefreshFrame(display, nullptr);
1579
ramindani431aad42022-02-01 21:44:29 +00001580 const auto displayConfigGroup1 = display.getDisplayConfig(config1);
1581 int32_t vsyncPeriod1 = displayConfigGroup1.vsyncPeriod;
1582 int32_t configGroup1 = displayConfigGroup1.configGroup;
1583
1584 const auto displayConfigGroup2 = display.getDisplayConfig(config2);
1585 int32_t vsyncPeriod2 = displayConfigGroup2.vsyncPeriod;
1586 int32_t configGroup2 = displayConfigGroup2.configGroup;
ramindanidcfe3a82021-11-29 17:00:31 +00001587
1588 if (vsyncPeriod1 == vsyncPeriod2) {
1589 return; // continue
1590 }
1591
1592 // We don't allow delayed change when changing config groups
1593 if (params.delayForChange > 0 && configGroup1 != configGroup2) {
1594 return; // continue
1595 }
1596
ramindanidcfe3a82021-11-29 17:00:31 +00001597 VsyncPeriodChangeConstraints constraints = {
1598 .desiredTimeNanos = systemTime() + params.delayForChange,
1599 .seamlessRequired = false};
ramindani431aad42022-02-01 21:44:29 +00001600 const auto& [status, timeline] = mComposerClient->setActiveConfigWithConstraints(
1601 &display, config2, constraints);
1602 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001603
1604 EXPECT_TRUE(timeline.newVsyncAppliedTimeNanos >= constraints.desiredTimeNanos);
1605 // Refresh rate should change within a reasonable time
1606 constexpr std::chrono::nanoseconds kReasonableTimeForChange = 1s; // 1 second
1607 EXPECT_TRUE(timeline.newVsyncAppliedTimeNanos - constraints.desiredTimeNanos <=
1608 kReasonableTimeForChange.count());
1609
1610 if (timeline.refreshRequired) {
1611 if (params.refreshMiss) {
1612 // Miss the refresh frame on purpose to make sure the implementation sends a
1613 // callback
1614 std::this_thread::sleep_until(toTimePoint(timeline.refreshTimeNanos) +
1615 100ms);
1616 }
1617 sendRefreshFrame(display, &timeline);
1618 }
ramindani431aad42022-02-01 21:44:29 +00001619 waitForVsyncPeriodChange(display.getDisplayId(), timeline,
1620 constraints.desiredTimeNanos, vsyncPeriod1, vsyncPeriod2);
ramindanidcfe3a82021-11-29 17:00:31 +00001621
1622 // At this point the refresh rate should have changed already, however in rare
1623 // cases the implementation might have missed the deadline. In this case a new
1624 // timeline should have been provided.
ramindani431aad42022-02-01 21:44:29 +00001625 auto newTimeline = mComposerClient->takeLastVsyncPeriodChangeTimeline();
ramindanidcfe3a82021-11-29 17:00:31 +00001626 if (timeline.refreshRequired && params.refreshMiss) {
1627 EXPECT_TRUE(newTimeline.has_value());
1628 }
1629
1630 if (newTimeline.has_value()) {
1631 if (newTimeline->refreshRequired) {
1632 sendRefreshFrame(display, &newTimeline.value());
1633 }
ramindani431aad42022-02-01 21:44:29 +00001634 waitForVsyncPeriodChange(display.getDisplayId(), newTimeline.value(),
ramindanidcfe3a82021-11-29 17:00:31 +00001635 constraints.desiredTimeNanos, vsyncPeriod1,
1636 vsyncPeriod2);
1637 }
1638
ramindani431aad42022-02-01 21:44:29 +00001639 const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanos] =
1640 mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
1641 EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001642 EXPECT_EQ(vsyncPeriodNanos, vsyncPeriod2);
1643 });
1644 }
1645 }
1646
Ady Abraham72c5b502021-12-10 17:23:39 -08001647 void Test_expectedPresentTime(std::optional<int> framesDelay) {
Jason Macnak325e8232022-01-24 14:48:55 -08001648 if (hasCapability(Capability::PRESENT_FENCE_IS_NOT_RELIABLE)) {
1649 GTEST_SUCCEED() << "Device has unreliable present fences capability, skipping";
1650 return;
1651 }
1652
ramindani431aad42022-02-01 21:44:29 +00001653 ASSERT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001654
1655 const auto vsyncPeriod = getVsyncPeriod();
1656
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001657 const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1658 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
Ady Abraham72c5b502021-12-10 17:23:39 -08001659 ASSERT_NE(nullptr, buffer1);
1660 ASSERT_NE(nullptr, buffer2);
1661
1662 const auto layer = createOnScreenLayer();
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001663 auto& writer = getWriter(getPrimaryDisplayId());
1664 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer1->handle,
1665 /*acquireFence*/ -1);
Ady Abraham72c5b502021-12-10 17:23:39 -08001666 const sp<::android::Fence> presentFence1 =
1667 presentAndGetFence(ComposerClientWriter::kNoTimestamp);
1668 presentFence1->waitForever(LOG_TAG);
1669
1670 auto expectedPresentTime = presentFence1->getSignalTime() + vsyncPeriod;
1671 if (framesDelay.has_value()) {
1672 expectedPresentTime += *framesDelay * vsyncPeriod;
1673 }
1674
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001675 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer2->handle,
1676 /*acquireFence*/ -1);
Ady Abraham72c5b502021-12-10 17:23:39 -08001677 const auto setExpectedPresentTime = [&]() -> std::optional<ClockMonotonicTimestamp> {
1678 if (!framesDelay.has_value()) {
1679 return ComposerClientWriter::kNoTimestamp;
1680 } else if (*framesDelay == 0) {
1681 return ClockMonotonicTimestamp{0};
1682 }
1683 return ClockMonotonicTimestamp{expectedPresentTime};
1684 }();
1685
1686 const sp<::android::Fence> presentFence2 = presentAndGetFence(setExpectedPresentTime);
1687 presentFence2->waitForever(LOG_TAG);
1688
1689 const auto actualPresentTime = presentFence2->getSignalTime();
Ady Abrahamdf084f32022-01-10 14:10:23 -08001690 EXPECT_GE(actualPresentTime, expectedPresentTime - vsyncPeriod / 2);
Ady Abraham72c5b502021-12-10 17:23:39 -08001691
ramindani431aad42022-02-01 21:44:29 +00001692 ASSERT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001693 }
1694
ramindani431aad42022-02-01 21:44:29 +00001695 void configureLayer(const VtsDisplay& display, int64_t layer, Composition composition,
1696 const Rect& displayFrame, const FRect& cropRect) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001697 auto& writer = getWriter(display.getDisplayId());
1698 writer.setLayerCompositionType(display.getDisplayId(), layer, composition);
1699 writer.setLayerDisplayFrame(display.getDisplayId(), layer, displayFrame);
1700 writer.setLayerPlaneAlpha(display.getDisplayId(), layer, /*alpha*/ 1);
1701 writer.setLayerSourceCrop(display.getDisplayId(), layer, cropRect);
1702 writer.setLayerTransform(display.getDisplayId(), layer, static_cast<Transform>(0));
1703 writer.setLayerVisibleRegion(display.getDisplayId(), layer,
1704 std::vector<Rect>(1, displayFrame));
1705 writer.setLayerZOrder(display.getDisplayId(), layer, /*z*/ 10);
1706 writer.setLayerBlendMode(display.getDisplayId(), layer, BlendMode::NONE);
1707 writer.setLayerSurfaceDamage(display.getDisplayId(), layer,
1708 std::vector<Rect>(1, displayFrame));
ramindani431aad42022-02-01 21:44:29 +00001709 }
ramindanidcfe3a82021-11-29 17:00:31 +00001710 // clang-format off
1711 const std::array<float, 16> kIdentity = {{
1712 1.0f, 0.0f, 0.0f, 0.0f,
1713 0.0f, 1.0f, 0.0f, 0.0f,
1714 0.0f, 0.0f, 1.0f, 0.0f,
1715 0.0f, 0.0f, 0.0f, 1.0f,
1716 }};
1717 // clang-format on
1718
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001719 ComposerClientWriter& getWriter(int64_t display) {
Joen Chene0a962c2023-08-28 09:49:11 +00001720 std::lock_guard guard{mWritersMutex};
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001721 auto [it, _] = mWriters.try_emplace(display, display);
1722 return it->second;
1723 }
1724
Ady Abraham91c9d1a2021-12-15 18:14:45 -08001725 ComposerClientReader mReader;
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001726
1727 private:
Joen Chene0a962c2023-08-28 09:49:11 +00001728 void executeInternal(ComposerClientWriter& writer,
1729 std::vector<CommandResultPayload>& payloads) {
1730 auto commands = writer.takePendingCommands();
1731 if (commands.empty()) {
1732 return;
1733 }
1734
1735 auto [status, results] = mComposerClient->executeCommands(commands);
1736 ASSERT_TRUE(status.isOk()) << "executeCommands failed " << status.getDescription();
1737
1738 payloads.reserve(payloads.size() + results.size());
1739 payloads.insert(payloads.end(), std::make_move_iterator(results.begin()),
1740 std::make_move_iterator(results.end()));
1741 }
1742
1743 // Guards access to the map itself. Callers must ensure not to attempt to
1744 // - modify the same writer from multiple threads
1745 // - insert a new writer into the map during concurrent access, which would invalidate
1746 // references from other threads
1747 std::mutex mWritersMutex;
1748 std::unordered_map<int64_t, ComposerClientWriter> mWriters GUARDED_BY(mWritersMutex);
ramindanidcfe3a82021-11-29 17:00:31 +00001749};
1750
ramindani431aad42022-02-01 21:44:29 +00001751TEST_P(GraphicsComposerAidlCommandTest, SetColorTransform) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001752 auto& writer = getWriter(getPrimaryDisplayId());
1753 writer.setColorTransform(getPrimaryDisplayId(), kIdentity.data());
ramindanidcfe3a82021-11-29 17:00:31 +00001754 execute();
1755}
1756
1757TEST_P(GraphicsComposerAidlCommandTest, SetLayerColorTransform) {
ramindani431aad42022-02-01 21:44:29 +00001758 const auto& [status, layer] =
1759 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1760 EXPECT_TRUE(status.isOk());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001761 auto& writer = getWriter(getPrimaryDisplayId());
1762 writer.setLayerColorTransform(getPrimaryDisplayId(), layer, kIdentity.data());
ramindanidcfe3a82021-11-29 17:00:31 +00001763 execute();
1764
Ady Abraham3192f3d2021-12-03 16:08:56 -08001765 const auto errors = mReader.takeErrors();
Jason Macnak062bc9a2022-01-20 15:00:09 -08001766 if (errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_UNSUPPORTED) {
ramindanidcfe3a82021-11-29 17:00:31 +00001767 GTEST_SUCCEED() << "setLayerColorTransform is not supported";
1768 return;
1769 }
1770}
1771
Alec Mouri60564e12021-12-09 18:48:20 -08001772TEST_P(GraphicsComposerAidlCommandTest, SetDisplayBrightness) {
ramindani431aad42022-02-01 21:44:29 +00001773 const auto& [status, capabilities] =
1774 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
1775 ASSERT_TRUE(status.isOk());
Alec Mouri60564e12021-12-09 18:48:20 -08001776 bool brightnessSupport = std::find(capabilities.begin(), capabilities.end(),
1777 DisplayCapability::BRIGHTNESS) != capabilities.end();
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001778 auto& writer = getWriter(getPrimaryDisplayId());
Alec Mouri60564e12021-12-09 18:48:20 -08001779 if (!brightnessSupport) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001780 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.5f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001781 execute();
1782 const auto errors = mReader.takeErrors();
1783 EXPECT_EQ(1, errors.size());
Jason Macnak062bc9a2022-01-20 15:00:09 -08001784 EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, errors[0].errorCode);
Alec Mouri60564e12021-12-09 18:48:20 -08001785 GTEST_SUCCEED() << "SetDisplayBrightness is not supported";
1786 return;
1787 }
1788
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001789 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001790 execute();
1791 EXPECT_TRUE(mReader.takeErrors().empty());
1792
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001793 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.5f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001794 execute();
1795 EXPECT_TRUE(mReader.takeErrors().empty());
1796
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001797 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 1.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001798 execute();
1799 EXPECT_TRUE(mReader.takeErrors().empty());
1800
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001801 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ -1.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001802 execute();
1803 EXPECT_TRUE(mReader.takeErrors().empty());
1804
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001805 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 2.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001806 execute();
1807 {
1808 const auto errors = mReader.takeErrors();
ramindanib3bdf052022-01-12 18:27:05 +00001809 ASSERT_EQ(1, errors.size());
Alec Mouri60564e12021-12-09 18:48:20 -08001810 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
1811 }
1812
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001813 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ -2.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001814 execute();
1815 {
1816 const auto errors = mReader.takeErrors();
ramindanib3bdf052022-01-12 18:27:05 +00001817 ASSERT_EQ(1, errors.size());
Alec Mouri60564e12021-12-09 18:48:20 -08001818 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
1819 }
1820}
1821
ramindani431aad42022-02-01 21:44:29 +00001822TEST_P(GraphicsComposerAidlCommandTest, SetClientTarget) {
1823 EXPECT_TRUE(mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kBufferSlotCount)
1824 .isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001825
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001826 auto& writer = getWriter(getPrimaryDisplayId());
1827 writer.setClientTarget(getPrimaryDisplayId(), /*slot*/ 0, nullptr, /*acquireFence*/ -1,
1828 Dataspace::UNKNOWN, std::vector<Rect>());
ramindanidcfe3a82021-11-29 17:00:31 +00001829
1830 execute();
1831}
1832
ramindani431aad42022-02-01 21:44:29 +00001833TEST_P(GraphicsComposerAidlCommandTest, SetOutputBuffer) {
1834 const auto& [status, virtualDisplayCount] = mComposerClient->getMaxVirtualDisplayCount();
1835 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001836 if (virtualDisplayCount == 0) {
1837 GTEST_SUCCEED() << "no virtual display support";
1838 return;
1839 }
1840
ramindani431aad42022-02-01 21:44:29 +00001841 const auto& [displayStatus, display] = mComposerClient->createVirtualDisplay(
1842 /*width*/ 64, /*height*/ 64, common::PixelFormat::IMPLEMENTATION_DEFINED,
1843 kBufferSlotCount);
1844 EXPECT_TRUE(displayStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001845
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001846 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001847 const auto handle = buffer->handle;
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001848 auto& writer = getWriter(display.display);
1849 writer.setOutputBuffer(display.display, /*slot*/ 0, handle, /*releaseFence*/ -1);
ramindanidcfe3a82021-11-29 17:00:31 +00001850 execute();
1851}
1852
ramindani431aad42022-02-01 21:44:29 +00001853TEST_P(GraphicsComposerAidlCommandTest, ValidDisplay) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001854 auto& writer = getWriter(getPrimaryDisplayId());
1855 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
ramindanidcfe3a82021-11-29 17:00:31 +00001856 execute();
1857}
1858
ramindani431aad42022-02-01 21:44:29 +00001859TEST_P(GraphicsComposerAidlCommandTest, AcceptDisplayChanges) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001860 auto& writer = getWriter(getPrimaryDisplayId());
1861 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
1862 writer.acceptDisplayChanges(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001863 execute();
1864}
1865
ramindani431aad42022-02-01 21:44:29 +00001866TEST_P(GraphicsComposerAidlCommandTest, PresentDisplay) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001867 auto& writer = getWriter(getPrimaryDisplayId());
1868 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
1869 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001870 execute();
1871}
1872
1873/**
1874 * Test IComposerClient::Command::PRESENT_DISPLAY
1875 *
1876 * Test that IComposerClient::Command::PRESENT_DISPLAY works without
1877 * additional call to validateDisplay when only the layer buffer handle and
1878 * surface damage have been set
1879 */
ramindani431aad42022-02-01 21:44:29 +00001880TEST_P(GraphicsComposerAidlCommandTest, PresentDisplayNoLayerStateChanges) {
ramindani431aad42022-02-01 21:44:29 +00001881 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001882
ramindani431aad42022-02-01 21:44:29 +00001883 const auto& [renderIntentsStatus, renderIntents] =
1884 mComposerClient->getRenderIntents(getPrimaryDisplayId(), ColorMode::NATIVE);
1885 EXPECT_TRUE(renderIntentsStatus.isOk());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001886 auto& writer = getWriter(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001887 for (auto intent : renderIntents) {
ramindani431aad42022-02-01 21:44:29 +00001888 EXPECT_TRUE(mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE, intent)
1889 .isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001890
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001891 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001892 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001893 ASSERT_NE(nullptr, handle);
1894
ramindani431aad42022-02-01 21:44:29 +00001895 const auto& [layerStatus, layer] =
1896 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1897 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001898
ramindani431aad42022-02-01 21:44:29 +00001899 Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
1900 getPrimaryDisplay().getDisplayHeight()};
1901 FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
1902 (float)getPrimaryDisplay().getDisplayHeight()};
1903 configureLayer(getPrimaryDisplay(), layer, Composition::CURSOR, displayFrame, cropRect);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001904 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle,
1905 /*acquireFence*/ -1);
1906 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
1907 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
ramindanidcfe3a82021-11-29 17:00:31 +00001908 execute();
ramindani431aad42022-02-01 21:44:29 +00001909 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
ramindanidcfe3a82021-11-29 17:00:31 +00001910 GTEST_SUCCEED() << "Composition change requested, skipping test";
1911 return;
1912 }
1913
Ady Abraham3192f3d2021-12-03 16:08:56 -08001914 ASSERT_TRUE(mReader.takeErrors().empty());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001915 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001916 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001917 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001918
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001919 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001920 const auto handle2 = buffer2->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001921 ASSERT_NE(nullptr, handle2);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001922 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle2,
1923 /*acquireFence*/ -1);
1924 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer,
1925 std::vector<Rect>(1, {0, 0, 10, 10}));
1926 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001927 execute();
1928 }
1929}
1930
ramindani431aad42022-02-01 21:44:29 +00001931TEST_P(GraphicsComposerAidlCommandTest, SetLayerCursorPosition) {
1932 const auto& [layerStatus, layer] =
1933 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1934 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001935
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001936 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001937 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001938 ASSERT_NE(nullptr, handle);
ramindanidcfe3a82021-11-29 17:00:31 +00001939
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001940 auto& writer = getWriter(getPrimaryDisplayId());
1941 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle, /*acquireFence*/ -1);
ramindani431aad42022-02-01 21:44:29 +00001942
1943 Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
1944 getPrimaryDisplay().getDisplayHeight()};
1945 FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
1946 (float)getPrimaryDisplay().getDisplayHeight()};
1947 configureLayer(getPrimaryDisplay(), layer, Composition::CURSOR, displayFrame, cropRect);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001948 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
1949 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
ramindanidcfe3a82021-11-29 17:00:31 +00001950
1951 execute();
Ady Abraham46219f52021-12-20 09:44:31 -08001952
ramindani431aad42022-02-01 21:44:29 +00001953 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
ramindanidcfe3a82021-11-29 17:00:31 +00001954 GTEST_SUCCEED() << "Composition change requested, skipping test";
1955 return;
1956 }
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001957 writer.presentDisplay(getPrimaryDisplayId());
Ady Abraham3192f3d2021-12-03 16:08:56 -08001958 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001959
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001960 writer.setLayerCursorPosition(getPrimaryDisplayId(), layer, /*x*/ 1, /*y*/ 1);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001961 execute();
1962
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001963 writer.setLayerCursorPosition(getPrimaryDisplayId(), layer, /*x*/ 0, /*y*/ 0);
1964 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
1965 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001966 execute();
1967}
1968
ramindani431aad42022-02-01 21:44:29 +00001969TEST_P(GraphicsComposerAidlCommandTest, SetLayerBuffer) {
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001970 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001971 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001972 ASSERT_NE(nullptr, handle);
1973
ramindani431aad42022-02-01 21:44:29 +00001974 const auto& [layerStatus, layer] =
1975 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1976 EXPECT_TRUE(layerStatus.isOk());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001977 auto& writer = getWriter(getPrimaryDisplayId());
1978 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle, /*acquireFence*/ -1);
ramindanidcfe3a82021-11-29 17:00:31 +00001979 execute();
1980}
1981
Brian Lindahl25e0d092022-12-09 00:32:11 -07001982TEST_P(GraphicsComposerAidlCommandTest, SetLayerBufferMultipleTimes) {
1983 const auto& [layerStatus, layer] =
1984 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1985 EXPECT_TRUE(layerStatus.isOk());
1986 auto& writer = getWriter(getPrimaryDisplayId());
1987
1988 // Setup 3 buffers in the buffer cache, with the last buffer being active. Then, emulate the
1989 // Android platform code that clears all 3 buffer slots by setting all but the active buffer
1990 // slot to a placeholder buffer, and then restoring the active buffer.
1991
1992 // This is used on HALs that don't support setLayerBufferSlotsToClear (version <= 3.1).
1993
1994 const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1995 ASSERT_NE(nullptr, buffer1);
1996 const auto handle1 = buffer1->handle;
1997 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle1, /*acquireFence*/ -1);
1998 execute();
1999 ASSERT_TRUE(mReader.takeErrors().empty());
2000
2001 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2002 ASSERT_NE(nullptr, buffer2);
2003 const auto handle2 = buffer2->handle;
2004 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 1, handle2, /*acquireFence*/ -1);
2005 execute();
2006 ASSERT_TRUE(mReader.takeErrors().empty());
2007
2008 const auto buffer3 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2009 ASSERT_NE(nullptr, buffer3);
2010 const auto handle3 = buffer3->handle;
2011 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 2, handle3, /*acquireFence*/ -1);
2012 execute();
2013 ASSERT_TRUE(mReader.takeErrors().empty());
2014
2015 // Older versions of the HAL clear all but the active buffer slot with a placeholder buffer,
2016 // and then restoring the current active buffer at the end
2017 auto clearSlotBuffer = allocate(1u, 1u, ::android::PIXEL_FORMAT_RGB_888);
2018 ASSERT_NE(nullptr, clearSlotBuffer);
2019 auto clearSlotBufferHandle = clearSlotBuffer->handle;
2020
2021 // clear buffer slots 0 and 1 with new layer commands... and then...
2022 writer.setLayerBufferWithNewCommand(getPrimaryDisplayId(), layer, /* slot */ 0,
2023 clearSlotBufferHandle, /*acquireFence*/ -1);
2024 writer.setLayerBufferWithNewCommand(getPrimaryDisplayId(), layer, /* slot */ 1,
2025 clearSlotBufferHandle, /*acquireFence*/ -1);
2026 // ...reset the layer buffer to the current active buffer slot with a final new command
2027 writer.setLayerBufferWithNewCommand(getPrimaryDisplayId(), layer, /*slot*/ 2, nullptr,
2028 /*acquireFence*/ -1);
2029 execute();
2030 ASSERT_TRUE(mReader.takeErrors().empty());
2031}
2032
ramindani431aad42022-02-01 21:44:29 +00002033TEST_P(GraphicsComposerAidlCommandTest, SetLayerSurfaceDamage) {
2034 const auto& [layerStatus, layer] =
2035 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2036 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002037
2038 Rect empty{0, 0, 0, 0};
2039 Rect unit{0, 0, 1, 1};
2040
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002041 auto& writer = getWriter(getPrimaryDisplayId());
2042 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
ramindanidcfe3a82021-11-29 17:00:31 +00002043 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002044 ASSERT_TRUE(mReader.takeErrors().empty());
2045
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002046 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
Ady Abraham3192f3d2021-12-03 16:08:56 -08002047 execute();
2048 ASSERT_TRUE(mReader.takeErrors().empty());
2049
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002050 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>());
Ady Abraham3192f3d2021-12-03 16:08:56 -08002051 execute();
2052 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002053}
2054
ramindani431aad42022-02-01 21:44:29 +00002055TEST_P(GraphicsComposerAidlCommandTest, SetLayerBlockingRegion) {
2056 const auto& [layerStatus, layer] =
2057 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2058 EXPECT_TRUE(layerStatus.isOk());
Leon Scroggins III03318152022-01-13 12:24:19 -05002059
2060 Rect empty{0, 0, 0, 0};
2061 Rect unit{0, 0, 1, 1};
2062
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002063 auto& writer = getWriter(getPrimaryDisplayId());
2064 writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
Leon Scroggins III03318152022-01-13 12:24:19 -05002065 execute();
2066 ASSERT_TRUE(mReader.takeErrors().empty());
2067
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002068 writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
Leon Scroggins III03318152022-01-13 12:24:19 -05002069 execute();
2070 ASSERT_TRUE(mReader.takeErrors().empty());
2071
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002072 writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>());
Leon Scroggins III03318152022-01-13 12:24:19 -05002073 execute();
2074 ASSERT_TRUE(mReader.takeErrors().empty());
2075}
2076
ramindani431aad42022-02-01 21:44:29 +00002077TEST_P(GraphicsComposerAidlCommandTest, SetLayerBlendMode) {
2078 const auto& [layerStatus, layer] =
2079 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2080 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002081
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002082 auto& writer = getWriter(getPrimaryDisplayId());
2083 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::NONE);
ramindanidcfe3a82021-11-29 17:00:31 +00002084 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002085 ASSERT_TRUE(mReader.takeErrors().empty());
2086
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002087 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::PREMULTIPLIED);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002088 execute();
2089 ASSERT_TRUE(mReader.takeErrors().empty());
2090
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002091 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::COVERAGE);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002092 execute();
2093 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002094}
2095
ramindani431aad42022-02-01 21:44:29 +00002096TEST_P(GraphicsComposerAidlCommandTest, SetLayerColor) {
2097 const auto& [layerStatus, layer] =
2098 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2099 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002100
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002101 auto& writer = getWriter(getPrimaryDisplayId());
2102 writer.setLayerColor(getPrimaryDisplayId(), layer, Color{1.0f, 1.0f, 1.0f, 1.0f});
ramindanidcfe3a82021-11-29 17:00:31 +00002103 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002104 ASSERT_TRUE(mReader.takeErrors().empty());
2105
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002106 writer.setLayerColor(getPrimaryDisplayId(), layer, Color{0.0f, 0.0f, 0.0f, 0.0f});
Ady Abraham3192f3d2021-12-03 16:08:56 -08002107 execute();
2108 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002109}
2110
ramindani431aad42022-02-01 21:44:29 +00002111TEST_P(GraphicsComposerAidlCommandTest, SetLayerCompositionType) {
2112 const auto& [layerStatus, layer] =
2113 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2114 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002115
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002116 auto& writer = getWriter(getPrimaryDisplayId());
2117 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::CLIENT);
ramindanidcfe3a82021-11-29 17:00:31 +00002118 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002119 ASSERT_TRUE(mReader.takeErrors().empty());
2120
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002121 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::DEVICE);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002122 execute();
2123 ASSERT_TRUE(mReader.takeErrors().empty());
2124
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002125 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::SOLID_COLOR);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002126 execute();
2127 ASSERT_TRUE(mReader.takeErrors().empty());
2128
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002129 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::CURSOR);
ramindani431aad42022-02-01 21:44:29 +00002130 execute();
2131}
2132
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002133TEST_P(GraphicsComposerAidlCommandTest, DisplayDecoration) {
2134 for (VtsDisplay& display : mDisplays) {
2135 const auto [layerStatus, layer] =
2136 mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount);
2137 EXPECT_TRUE(layerStatus.isOk());
2138
2139 const auto [error, support] =
2140 mComposerClient->getDisplayDecorationSupport(display.getDisplayId());
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002141
Leon Scroggins III91590872022-02-23 09:51:21 -05002142 const auto format = (error.isOk() && support) ? support->format
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002143 : aidl::android::hardware::graphics::common::PixelFormat::RGBA_8888;
2144 const auto decorBuffer = allocate(static_cast<::android::PixelFormat>(format));
2145 ASSERT_NE(nullptr, decorBuffer);
2146 if (::android::OK != decorBuffer->initCheck()) {
2147 if (support) {
2148 FAIL() << "Device advertised display decoration support with format "
2149 << aidl::android::hardware::graphics::common::toString(format)
2150 << " but failed to allocate it!";
2151 } else {
2152 FAIL() << "Device advertised NO display decoration support, but it should "
2153 << "still be able to allocate "
2154 << aidl::android::hardware::graphics::common::toString(format);
2155 }
2156 }
2157
Midas Chien7d55d422022-06-07 02:32:28 +08002158 configureLayer(display, layer, Composition::DISPLAY_DECORATION, display.getFrameRect(),
2159 display.getCrop());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002160 auto& writer = getWriter(display.getDisplayId());
2161 writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, decorBuffer->handle,
2162 /*acquireFence*/ -1);
2163 writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp);
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002164 execute();
2165 if (support) {
2166 ASSERT_TRUE(mReader.takeErrors().empty());
2167 } else {
2168 const auto errors = mReader.takeErrors();
2169 ASSERT_EQ(1, errors.size());
Leon Scroggins III6455e792022-02-24 12:18:58 -05002170 EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, errors[0].errorCode);
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002171 }
2172 }
2173}
2174
ramindani431aad42022-02-01 21:44:29 +00002175TEST_P(GraphicsComposerAidlCommandTest, SetLayerDataspace) {
2176 const auto& [layerStatus, layer] =
2177 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2178 EXPECT_TRUE(layerStatus.isOk());
2179
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002180 auto& writer = getWriter(getPrimaryDisplayId());
2181 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
ramindani431aad42022-02-01 21:44:29 +00002182 execute();
2183}
2184
2185TEST_P(GraphicsComposerAidlCommandTest, SetLayerDisplayFrame) {
2186 const auto& [layerStatus, layer] =
2187 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2188 EXPECT_TRUE(layerStatus.isOk());
2189
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002190 auto& writer = getWriter(getPrimaryDisplayId());
2191 writer.setLayerDisplayFrame(getPrimaryDisplayId(), layer, Rect{0, 0, 1, 1});
ramindani431aad42022-02-01 21:44:29 +00002192 execute();
2193}
2194
2195TEST_P(GraphicsComposerAidlCommandTest, SetLayerPlaneAlpha) {
2196 const auto& [layerStatus, layer] =
2197 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2198 EXPECT_TRUE(layerStatus.isOk());
2199
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002200 auto& writer = getWriter(getPrimaryDisplayId());
2201 writer.setLayerPlaneAlpha(getPrimaryDisplayId(), layer, /*alpha*/ 0.0f);
ramindani431aad42022-02-01 21:44:29 +00002202 execute();
2203 ASSERT_TRUE(mReader.takeErrors().empty());
2204
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002205 writer.setLayerPlaneAlpha(getPrimaryDisplayId(), layer, /*alpha*/ 1.0f);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002206 execute();
2207 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002208}
2209
ramindani431aad42022-02-01 21:44:29 +00002210TEST_P(GraphicsComposerAidlCommandTest, SetLayerSidebandStream) {
Jason Macnak325e8232022-01-24 14:48:55 -08002211 if (!hasCapability(Capability::SIDEBAND_STREAM)) {
ramindanidcfe3a82021-11-29 17:00:31 +00002212 GTEST_SUCCEED() << "no sideband stream support";
2213 return;
2214 }
2215
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002216 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00002217 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00002218 ASSERT_NE(nullptr, handle);
2219
ramindani431aad42022-02-01 21:44:29 +00002220 const auto& [layerStatus, layer] =
2221 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2222 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002223
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002224 auto& writer = getWriter(getPrimaryDisplayId());
2225 writer.setLayerSidebandStream(getPrimaryDisplayId(), layer, handle);
ramindanidcfe3a82021-11-29 17:00:31 +00002226 execute();
2227}
2228
ramindani431aad42022-02-01 21:44:29 +00002229TEST_P(GraphicsComposerAidlCommandTest, SetLayerSourceCrop) {
2230 const auto& [layerStatus, layer] =
2231 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2232 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002233
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002234 auto& writer = getWriter(getPrimaryDisplayId());
2235 writer.setLayerSourceCrop(getPrimaryDisplayId(), layer, FRect{0.0f, 0.0f, 1.0f, 1.0f});
ramindanidcfe3a82021-11-29 17:00:31 +00002236 execute();
2237}
2238
ramindani431aad42022-02-01 21:44:29 +00002239TEST_P(GraphicsComposerAidlCommandTest, SetLayerTransform) {
2240 const auto& [layerStatus, layer] =
2241 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2242 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002243
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002244 auto& writer = getWriter(getPrimaryDisplayId());
2245 writer.setLayerTransform(getPrimaryDisplayId(), layer, static_cast<Transform>(0));
ramindanidcfe3a82021-11-29 17:00:31 +00002246 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002247 ASSERT_TRUE(mReader.takeErrors().empty());
2248
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002249 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::FLIP_H);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002250 execute();
2251 ASSERT_TRUE(mReader.takeErrors().empty());
2252
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002253 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::FLIP_V);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002254 execute();
2255 ASSERT_TRUE(mReader.takeErrors().empty());
2256
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002257 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_90);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002258 execute();
2259 ASSERT_TRUE(mReader.takeErrors().empty());
2260
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002261 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_180);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002262 execute();
2263 ASSERT_TRUE(mReader.takeErrors().empty());
2264
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002265 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_270);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002266 execute();
2267 ASSERT_TRUE(mReader.takeErrors().empty());
2268
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002269 writer.setLayerTransform(getPrimaryDisplayId(), layer,
2270 static_cast<Transform>(static_cast<int>(Transform::FLIP_H) |
2271 static_cast<int>(Transform::ROT_90)));
Ady Abraham3192f3d2021-12-03 16:08:56 -08002272 execute();
2273 ASSERT_TRUE(mReader.takeErrors().empty());
2274
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002275 writer.setLayerTransform(getPrimaryDisplayId(), layer,
2276 static_cast<Transform>(static_cast<int>(Transform::FLIP_V) |
2277 static_cast<int>(Transform::ROT_90)));
Ady Abraham3192f3d2021-12-03 16:08:56 -08002278 execute();
2279 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002280}
2281
ramindani431aad42022-02-01 21:44:29 +00002282TEST_P(GraphicsComposerAidlCommandTest, SetLayerVisibleRegion) {
2283 const auto& [layerStatus, layer] =
2284 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2285 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002286
2287 Rect empty{0, 0, 0, 0};
2288 Rect unit{0, 0, 1, 1};
2289
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002290 auto& writer = getWriter(getPrimaryDisplayId());
2291 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
ramindanidcfe3a82021-11-29 17:00:31 +00002292 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002293 ASSERT_TRUE(mReader.takeErrors().empty());
2294
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002295 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
Ady Abraham3192f3d2021-12-03 16:08:56 -08002296 execute();
2297 ASSERT_TRUE(mReader.takeErrors().empty());
2298
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002299 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>());
Ady Abraham3192f3d2021-12-03 16:08:56 -08002300 execute();
2301 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002302}
2303
ramindani431aad42022-02-01 21:44:29 +00002304TEST_P(GraphicsComposerAidlCommandTest, SetLayerZOrder) {
2305 const auto& [layerStatus, layer] =
2306 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2307 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002308
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002309 auto& writer = getWriter(getPrimaryDisplayId());
2310 writer.setLayerZOrder(getPrimaryDisplayId(), layer, /*z*/ 10);
ramindanidcfe3a82021-11-29 17:00:31 +00002311 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002312 ASSERT_TRUE(mReader.takeErrors().empty());
2313
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002314 writer.setLayerZOrder(getPrimaryDisplayId(), layer, /*z*/ 0);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002315 execute();
2316 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002317}
2318
ramindani431aad42022-02-01 21:44:29 +00002319TEST_P(GraphicsComposerAidlCommandTest, SetLayerPerFrameMetadata) {
2320 const auto& [layerStatus, layer] =
2321 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2322 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002323
ramindanidcfe3a82021-11-29 17:00:31 +00002324 /**
2325 * DISPLAY_P3 is a color space that uses the DCI_P3 primaries,
2326 * the D65 white point and the SRGB transfer functions.
2327 * Rendering Intent: Colorimetric
2328 * Primaries:
2329 * x y
2330 * green 0.265 0.690
2331 * blue 0.150 0.060
2332 * red 0.680 0.320
2333 * white (D65) 0.3127 0.3290
2334 */
2335
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002336 auto& writer = getWriter(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00002337 std::vector<PerFrameMetadata> aidlMetadata;
2338 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X, 0.680f});
2339 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y, 0.320f});
2340 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X, 0.265f});
2341 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y, 0.690f});
2342 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X, 0.150f});
2343 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y, 0.060f});
2344 aidlMetadata.push_back({PerFrameMetadataKey::WHITE_POINT_X, 0.3127f});
2345 aidlMetadata.push_back({PerFrameMetadataKey::WHITE_POINT_Y, 0.3290f});
2346 aidlMetadata.push_back({PerFrameMetadataKey::MAX_LUMINANCE, 100.0f});
2347 aidlMetadata.push_back({PerFrameMetadataKey::MIN_LUMINANCE, 0.1f});
2348 aidlMetadata.push_back({PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL, 78.0});
2349 aidlMetadata.push_back({PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL, 62.0});
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002350 writer.setLayerPerFrameMetadata(getPrimaryDisplayId(), layer, aidlMetadata);
ramindanidcfe3a82021-11-29 17:00:31 +00002351 execute();
2352
Ady Abraham3192f3d2021-12-03 16:08:56 -08002353 const auto errors = mReader.takeErrors();
2354 if (errors.size() == 1 && errors[0].errorCode == EX_UNSUPPORTED_OPERATION) {
ramindanidcfe3a82021-11-29 17:00:31 +00002355 GTEST_SUCCEED() << "SetLayerPerFrameMetadata is not supported";
ramindani431aad42022-02-01 21:44:29 +00002356 EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002357 return;
2358 }
2359
ramindani431aad42022-02-01 21:44:29 +00002360 EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002361}
2362
Alec Mourib1f16722022-02-07 13:03:44 -08002363TEST_P(GraphicsComposerAidlCommandTest, setLayerBrightness) {
ramindani431aad42022-02-01 21:44:29 +00002364 const auto& [layerStatus, layer] =
2365 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
Alec Mouri95e490b2022-01-06 13:46:58 -08002366
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002367 auto& writer = getWriter(getPrimaryDisplayId());
2368 writer.setLayerBrightness(getPrimaryDisplayId(), layer, 0.2f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002369 execute();
2370 ASSERT_TRUE(mReader.takeErrors().empty());
2371
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002372 writer.setLayerBrightness(getPrimaryDisplayId(), layer, 1.f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002373 execute();
2374 ASSERT_TRUE(mReader.takeErrors().empty());
2375
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002376 writer.setLayerBrightness(getPrimaryDisplayId(), layer, 0.f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002377 execute();
2378 ASSERT_TRUE(mReader.takeErrors().empty());
2379
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002380 writer.setLayerBrightness(getPrimaryDisplayId(), layer, -1.f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002381 execute();
Alec Mourib1f16722022-02-07 13:03:44 -08002382 {
2383 const auto errors = mReader.takeErrors();
2384 ASSERT_EQ(1, errors.size());
2385 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
2386 }
2387
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002388 writer.setLayerBrightness(getPrimaryDisplayId(), layer, std::nanf(""));
Alec Mourib1f16722022-02-07 13:03:44 -08002389 execute();
2390 {
2391 const auto errors = mReader.takeErrors();
2392 ASSERT_EQ(1, errors.size());
2393 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
2394 }
Alec Mouri95e490b2022-01-06 13:46:58 -08002395}
2396
ramindani431aad42022-02-01 21:44:29 +00002397TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints) {
ramindanidcfe3a82021-11-29 17:00:31 +00002398 Test_setActiveConfigWithConstraints({.delayForChange = 0, .refreshMiss = false});
2399}
2400
ramindani431aad42022-02-01 21:44:29 +00002401TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_Delayed) {
ramindanidcfe3a82021-11-29 17:00:31 +00002402 Test_setActiveConfigWithConstraints({.delayForChange = 300'000'000, // 300ms
2403 .refreshMiss = false});
2404}
2405
ramindani431aad42022-02-01 21:44:29 +00002406TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_MissRefresh) {
ramindanidcfe3a82021-11-29 17:00:31 +00002407 Test_setActiveConfigWithConstraints({.delayForChange = 0, .refreshMiss = true});
2408}
2409
ramindani431aad42022-02-01 21:44:29 +00002410TEST_P(GraphicsComposerAidlCommandTest, GetDisplayVsyncPeriod) {
ramindanidcfe3a82021-11-29 17:00:31 +00002411 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +00002412 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
2413 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002414
ramindani431aad42022-02-01 21:44:29 +00002415 for (int32_t config : configs) {
2416 int32_t expectedVsyncPeriodNanos = display.getDisplayConfig(config).vsyncPeriod;
2417
ramindanidcfe3a82021-11-29 17:00:31 +00002418 VsyncPeriodChangeConstraints constraints;
2419
2420 constraints.desiredTimeNanos = systemTime();
2421 constraints.seamlessRequired = false;
ramindani431aad42022-02-01 21:44:29 +00002422
2423 const auto& [timelineStatus, timeline] =
2424 mComposerClient->setActiveConfigWithConstraints(&display, config, constraints);
2425 EXPECT_TRUE(timelineStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002426
2427 if (timeline.refreshRequired) {
2428 sendRefreshFrame(display, &timeline);
2429 }
ramindani431aad42022-02-01 21:44:29 +00002430 waitForVsyncPeriodChange(display.getDisplayId(), timeline, constraints.desiredTimeNanos,
2431 /*odPeriodNanos*/ 0, expectedVsyncPeriodNanos);
ramindanidcfe3a82021-11-29 17:00:31 +00002432
2433 int32_t vsyncPeriodNanos;
2434 int retryCount = 100;
2435 do {
2436 std::this_thread::sleep_for(10ms);
ramindani431aad42022-02-01 21:44:29 +00002437 const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanosValue] =
2438 mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
2439
2440 EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
2441 vsyncPeriodNanos = vsyncPeriodNanosValue;
ramindanidcfe3a82021-11-29 17:00:31 +00002442 --retryCount;
2443 } while (vsyncPeriodNanos != expectedVsyncPeriodNanos && retryCount > 0);
2444
2445 EXPECT_EQ(vsyncPeriodNanos, expectedVsyncPeriodNanos);
2446
2447 // Make sure that the vsync period stays the same if the active config is not
2448 // changed.
2449 auto timeout = 1ms;
2450 for (int i = 0; i < 10; i++) {
2451 std::this_thread::sleep_for(timeout);
2452 timeout *= 2;
2453 vsyncPeriodNanos = 0;
ramindani431aad42022-02-01 21:44:29 +00002454 const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanosValue] =
2455 mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
2456
2457 EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
2458 vsyncPeriodNanos = vsyncPeriodNanosValue;
ramindanidcfe3a82021-11-29 17:00:31 +00002459 EXPECT_EQ(vsyncPeriodNanos, expectedVsyncPeriodNanos);
2460 }
2461 }
2462 }
2463}
2464
ramindani431aad42022-02-01 21:44:29 +00002465TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_SeamlessNotAllowed) {
ramindanidcfe3a82021-11-29 17:00:31 +00002466 VsyncPeriodChangeConstraints constraints;
ramindanidcfe3a82021-11-29 17:00:31 +00002467 constraints.seamlessRequired = true;
2468 constraints.desiredTimeNanos = systemTime();
2469
2470 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +00002471 forEachTwoConfigs(display.getDisplayId(), [&](int32_t config1, int32_t config2) {
2472 int32_t configGroup1 = display.getDisplayConfig(config1).configGroup;
2473 int32_t configGroup2 = display.getDisplayConfig(config2).configGroup;
ramindanidcfe3a82021-11-29 17:00:31 +00002474 if (configGroup1 != configGroup2) {
ramindani431aad42022-02-01 21:44:29 +00002475 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002476 sendRefreshFrame(display, nullptr);
ramindani431aad42022-02-01 21:44:29 +00002477 const auto& [status, _] = mComposerClient->setActiveConfigWithConstraints(
2478 &display, config2, constraints);
2479 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00002480 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(
2481 status, IComposerClient::EX_SEAMLESS_NOT_ALLOWED));
ramindanidcfe3a82021-11-29 17:00:31 +00002482 }
2483 });
2484 }
2485}
2486
ramindani431aad42022-02-01 21:44:29 +00002487TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_NoTimestamp) {
2488 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ std::nullopt));
Ady Abraham72c5b502021-12-10 17:23:39 -08002489}
2490
ramindani431aad42022-02-01 21:44:29 +00002491TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_0) {
2492 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ 0));
Ady Abraham72c5b502021-12-10 17:23:39 -08002493}
2494
ramindani431aad42022-02-01 21:44:29 +00002495TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_5) {
2496 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ 5));
Ady Abraham72c5b502021-12-10 17:23:39 -08002497}
2498
ramindani431aad42022-02-01 21:44:29 +00002499TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Unsupported) {
2500 const bool hasDisplayIdleTimerSupport =
2501 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002502 if (!hasDisplayIdleTimerSupport) {
ramindani431aad42022-02-01 21:44:29 +00002503 const auto& status =
2504 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0);
2505 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00002506 EXPECT_NO_FATAL_FAILURE(
2507 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
Midas Chiena0b56bd2022-01-13 23:27:33 +08002508 }
2509}
2510
ramindani431aad42022-02-01 21:44:29 +00002511TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_BadParameter) {
2512 const bool hasDisplayIdleTimerSupport =
2513 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002514 if (!hasDisplayIdleTimerSupport) {
2515 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2516 return;
2517 }
2518
ramindani431aad42022-02-01 21:44:29 +00002519 const auto& status =
2520 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ -1);
2521 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00002522 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
Midas Chiena0b56bd2022-01-13 23:27:33 +08002523}
2524
ramindani431aad42022-02-01 21:44:29 +00002525TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Disable) {
2526 const bool hasDisplayIdleTimerSupport =
2527 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002528 if (!hasDisplayIdleTimerSupport) {
2529 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2530 return;
2531 }
2532
ramindani431aad42022-02-01 21:44:29 +00002533 EXPECT_TRUE(mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002534 std::this_thread::sleep_for(1s);
ramindani431aad42022-02-01 21:44:29 +00002535 EXPECT_EQ(0, mComposerClient->getVsyncIdleCount());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002536}
2537
ramindani431aad42022-02-01 21:44:29 +00002538TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Timeout_2) {
2539 const bool hasDisplayIdleTimerSupport =
2540 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002541 if (!hasDisplayIdleTimerSupport) {
2542 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2543 return;
2544 }
2545
ramindani431aad42022-02-01 21:44:29 +00002546 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
2547 EXPECT_TRUE(mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002548
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002549 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002550 ASSERT_NE(nullptr, buffer->handle);
2551
2552 const auto layer = createOnScreenLayer();
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002553 auto& writer = getWriter(getPrimaryDisplayId());
2554 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer->handle,
2555 /*acquireFence*/ -1);
ramindani431aad42022-02-01 21:44:29 +00002556 int32_t vsyncIdleCount = mComposerClient->getVsyncIdleCount();
Midas Chiena0b56bd2022-01-13 23:27:33 +08002557 auto earlyVsyncIdleTime = systemTime() + std::chrono::nanoseconds(2s).count();
ramindani431aad42022-02-01 21:44:29 +00002558 EXPECT_TRUE(
2559 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 2000).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002560
2561 const sp<::android::Fence> presentFence =
ramindani431aad42022-02-01 21:44:29 +00002562 presentAndGetFence(ComposerClientWriter::kNoTimestamp);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002563 presentFence->waitForever(LOG_TAG);
2564
2565 std::this_thread::sleep_for(3s);
ramindani431aad42022-02-01 21:44:29 +00002566 if (vsyncIdleCount < mComposerClient->getVsyncIdleCount()) {
2567 EXPECT_GE(mComposerClient->getVsyncIdleTime(), earlyVsyncIdleTime);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002568 }
2569
ramindani431aad42022-02-01 21:44:29 +00002570 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002571}
2572
ramindani12423f52023-06-14 20:04:51 -07002573class GraphicsComposerAidlCommandV2Test : public GraphicsComposerAidlCommandTest {
2574 protected:
2575 void SetUp() override {
2576 GraphicsComposerAidlTest::SetUp();
2577 if (getInterfaceVersion() <= 1) {
2578 GTEST_SKIP() << "Device interface version is expected to be >= 2";
2579 }
ramindani17c71102023-03-20 10:51:14 -07002580 }
ramindani12423f52023-06-14 20:04:51 -07002581};
2582/**
2583 * Test Capability::SKIP_VALIDATE
2584 *
2585 * Capability::SKIP_VALIDATE has been deprecated and should not be enabled.
2586 */
2587TEST_P(GraphicsComposerAidlCommandV2Test, SkipValidateDeprecatedTest) {
Leon Scroggins III79d7ae82023-10-11 16:03:52 -04002588#pragma clang diagnostic push
2589#pragma clang diagnostic ignored "-Wdeprecated-declarations"
ramindani12423f52023-06-14 20:04:51 -07002590 ASSERT_FALSE(hasCapability(Capability::SKIP_VALIDATE))
2591 << "Found Capability::SKIP_VALIDATE capability.";
Leon Scroggins III79d7ae82023-10-11 16:03:52 -04002592#pragma clang diagnostic pop
ramindani12423f52023-06-14 20:04:51 -07002593}
2594
2595TEST_P(GraphicsComposerAidlCommandV2Test, SetLayerBufferSlotsToClear) {
2596 // Older HAL versions use a backwards compatible way of clearing buffer slots
2597 // HAL at version 1 or lower does not have LayerCommand::bufferSlotsToClear
2598 const auto& [layerStatus, layer] =
2599 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2600 EXPECT_TRUE(layerStatus.isOk());
2601 auto& writer = getWriter(getPrimaryDisplayId());
2602
2603 // setup 3 buffers in the buffer cache, with the last buffer being active
2604 // then emulate the Android platform code that clears all 3 buffer slots
2605
2606 const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2607 ASSERT_NE(nullptr, buffer1);
2608 const auto handle1 = buffer1->handle;
2609 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle1, /*acquireFence*/ -1);
2610 execute();
2611 ASSERT_TRUE(mReader.takeErrors().empty());
2612
2613 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2614 ASSERT_NE(nullptr, buffer2);
2615 const auto handle2 = buffer2->handle;
2616 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 1, handle2, /*acquireFence*/ -1);
2617 execute();
2618 ASSERT_TRUE(mReader.takeErrors().empty());
2619
2620 const auto buffer3 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2621 ASSERT_NE(nullptr, buffer3);
2622 const auto handle3 = buffer3->handle;
2623 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 2, handle3, /*acquireFence*/ -1);
2624 execute();
2625 ASSERT_TRUE(mReader.takeErrors().empty());
2626
2627 // Ensure we can clear all 3 buffer slots, even the active buffer - it is assumed the
2628 // current active buffer's slot will be cleared, but still remain the active buffer and no
2629 // errors will occur.
2630 writer.setLayerBufferSlotsToClear(getPrimaryDisplayId(), layer, {0, 1, 2});
2631 execute();
2632 ASSERT_TRUE(mReader.takeErrors().empty());
2633}
2634
2635TEST_P(GraphicsComposerAidlCommandV2Test, SetRefreshRateChangedCallbackDebug_Unsupported) {
ramindani9dd8c482023-02-21 18:07:56 -08002636 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2637 auto status = mComposerClient->setRefreshRateChangedCallbackDebugEnabled(
2638 getPrimaryDisplayId(), /*enabled*/ true);
2639 EXPECT_FALSE(status.isOk());
2640 EXPECT_NO_FATAL_FAILURE(
2641 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
2642
2643 status = mComposerClient->setRefreshRateChangedCallbackDebugEnabled(getPrimaryDisplayId(),
2644 /*enabled*/ false);
2645 EXPECT_FALSE(status.isOk());
2646 EXPECT_NO_FATAL_FAILURE(
2647 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
2648 }
2649}
2650
ramindani12423f52023-06-14 20:04:51 -07002651TEST_P(GraphicsComposerAidlCommandV2Test, SetRefreshRateChangedCallbackDebug_Enabled) {
ramindani9dd8c482023-02-21 18:07:56 -08002652 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2653 GTEST_SUCCEED() << "Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG is not supported";
2654 return;
2655 }
2656
2657 const auto displayId = getPrimaryDisplayId();
2658 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2659 // Enable the callback
2660 ASSERT_TRUE(mComposerClient
2661 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2662 /*enabled*/ true)
2663 .isOk());
2664 std::this_thread::sleep_for(100ms);
2665
ramindani91518892023-03-03 16:55:09 +00002666 const auto displayFilter = [displayId](auto refreshRateChangedDebugData) {
2667 return displayId == refreshRateChangedDebugData.display;
2668 };
ramindani9dd8c482023-02-21 18:07:56 -08002669
2670 // Check that we immediately got a callback
ramindani91518892023-03-03 16:55:09 +00002671 EXPECT_TRUE(checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter));
ramindani9dd8c482023-02-21 18:07:56 -08002672
2673 ASSERT_TRUE(mComposerClient
2674 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2675 /*enabled*/ false)
2676 .isOk());
2677}
2678
ramindani12423f52023-06-14 20:04:51 -07002679TEST_P(GraphicsComposerAidlCommandV2Test,
ramindani9dd8c482023-02-21 18:07:56 -08002680 SetRefreshRateChangedCallbackDebugEnabled_noCallbackWhenIdle) {
2681 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2682 GTEST_SUCCEED() << "Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG is not supported";
2683 return;
2684 }
2685
2686 auto display = getEditablePrimaryDisplay();
2687 const auto displayId = display.getDisplayId();
2688
2689 if (!hasDisplayCapability(displayId, DisplayCapability::DISPLAY_IDLE_TIMER)) {
2690 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2691 return;
2692 }
2693
2694 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2695 EXPECT_TRUE(mComposerClient->setPeakRefreshRateConfig(&display).isOk());
2696
2697 ASSERT_TRUE(mComposerClient->setIdleTimerEnabled(displayId, /*timeoutMs*/ 500).isOk());
2698 // Enable the callback
2699 ASSERT_TRUE(mComposerClient
2700 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2701 /*enabled*/ true)
2702 .isOk());
2703
ramindani91518892023-03-03 16:55:09 +00002704 const auto displayFilter = [displayId](auto refreshRateChangedDebugData) {
2705 return displayId == refreshRateChangedDebugData.display;
2706 };
ramindani9dd8c482023-02-21 18:07:56 -08002707
2708 int retryCount = 3;
2709 do {
2710 // Wait for 1s so that we enter the idle state
2711 std::this_thread::sleep_for(1s);
ramindani91518892023-03-03 16:55:09 +00002712 if (!checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter)) {
ramindani9dd8c482023-02-21 18:07:56 -08002713 // DID NOT receive a callback, we are in the idle state.
2714 break;
2715 }
2716 } while (--retryCount > 0);
2717
2718 if (retryCount == 0) {
2719 GTEST_SUCCEED() << "Unable to enter the idle mode";
2720 return;
2721 }
2722
2723 // Send the REFRESH_RATE_INDICATOR update
2724 ASSERT_NO_FATAL_FAILURE(
2725 sendBufferUpdate(createOnScreenLayer(Composition::REFRESH_RATE_INDICATOR)));
2726 std::this_thread::sleep_for(1s);
ramindani91518892023-03-03 16:55:09 +00002727 EXPECT_FALSE(checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter))
ramindani9dd8c482023-02-21 18:07:56 -08002728 << "A callback should not be received for REFRESH_RATE_INDICATOR";
2729
2730 EXPECT_TRUE(mComposerClient
2731 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2732 /*enabled*/ false)
2733 .isOk());
2734}
2735
ramindani12423f52023-06-14 20:04:51 -07002736TEST_P(GraphicsComposerAidlCommandV2Test,
ramindani9dd8c482023-02-21 18:07:56 -08002737 SetRefreshRateChangedCallbackDebugEnabled_SetActiveConfigWithConstraints) {
2738 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2739 GTEST_SUCCEED() << "Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG is not supported";
2740 return;
2741 }
2742
2743 VsyncPeriodChangeConstraints constraints;
2744 constraints.seamlessRequired = false;
2745 constraints.desiredTimeNanos = systemTime();
2746
2747 for (VtsDisplay& display : mDisplays) {
2748 const auto displayId = display.getDisplayId();
2749 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2750
2751 // Enable the callback
2752 ASSERT_TRUE(mComposerClient
2753 ->setRefreshRateChangedCallbackDebugEnabled(displayId, /*enabled*/ true)
2754 .isOk());
2755
2756 forEachTwoConfigs(displayId, [&](int32_t config1, int32_t config2) {
2757 const int32_t vsyncPeriod1 = display.getDisplayConfig(config1).vsyncPeriod;
2758 const int32_t vsyncPeriod2 = display.getDisplayConfig(config2).vsyncPeriod;
2759
2760 if (vsyncPeriod1 == vsyncPeriod2) {
2761 return; // continue
2762 }
2763
2764 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
2765 sendRefreshFrame(display, nullptr);
2766
2767 const auto& [status, timeline] =
2768 mComposerClient->setActiveConfigWithConstraints(&display, config2, constraints);
2769 EXPECT_TRUE(status.isOk());
2770
2771 if (timeline.refreshRequired) {
2772 sendRefreshFrame(display, &timeline);
2773 }
2774
ramindani91518892023-03-03 16:55:09 +00002775 const auto callbackFilter = [displayId,
2776 vsyncPeriod2](auto refreshRateChangedDebugData) {
2777 constexpr int kVsyncThreshold = 1000;
2778 return displayId == refreshRateChangedDebugData.display &&
2779 std::abs(vsyncPeriod2 - refreshRateChangedDebugData.vsyncPeriodNanos) <=
2780 kVsyncThreshold;
2781 };
ramindani9dd8c482023-02-21 18:07:56 -08002782
2783 int retryCount = 3;
2784 do {
2785 std::this_thread::sleep_for(100ms);
ramindani91518892023-03-03 16:55:09 +00002786 if (checkIfCallbackRefreshRateChangedDebugEnabledReceived(callbackFilter)) {
ramindani9dd8c482023-02-21 18:07:56 -08002787 GTEST_SUCCEED() << "Received a callback successfully";
2788 break;
2789 }
2790 } while (--retryCount > 0);
2791
2792 if (retryCount == 0) {
2793 GTEST_FAIL() << "failed to get a callback for the display " << displayId
2794 << " with config " << config2;
2795 }
2796 });
2797
2798 EXPECT_TRUE(
2799 mComposerClient
2800 ->setRefreshRateChangedCallbackDebugEnabled(displayId, /*enabled*/ false)
2801 .isOk());
2802 }
2803}
2804
Joen Chene0a962c2023-08-28 09:49:11 +00002805TEST_P(GraphicsComposerAidlCommandTest, MultiThreadedPresent) {
2806 std::vector<VtsDisplay*> displays;
2807 for (auto& display : mDisplays) {
2808 if (hasDisplayCapability(display.getDisplayId(),
2809 DisplayCapability::MULTI_THREADED_PRESENT)) {
2810 displays.push_back(&display);
2811 }
2812 }
2813
2814 const size_t numDisplays = displays.size();
2815 if (numDisplays <= 1u) {
2816 GTEST_SKIP();
2817 }
2818
2819 // When multi-threaded, use a reader per display. As with mWriters, this mutex
2820 // guards access to the map.
2821 std::mutex readersMutex;
2822 std::unordered_map<int64_t, ComposerClientReader> readers;
2823 std::vector<std::thread> threads;
2824 threads.reserve(numDisplays);
2825
2826 // Each display will have a layer to present. This maps from the display to
2827 // the layer, so we can properly destroy each layer at the end.
2828 std::unordered_map<int64_t, int64_t> layers;
2829
2830 for (auto* const display : displays) {
2831 const int64_t displayId = display->getDisplayId();
2832
2833 // Ensure that all writers and readers have been added to their respective
2834 // maps initially, so that the following loop never modifies the maps. The
2835 // maps are accessed from different threads, and if the maps were modified,
2836 // this would invalidate their iterators, and therefore references to the
2837 // writers and readers.
2838 auto& writer = getWriter(displayId);
2839 {
2840 std::lock_guard guard{readersMutex};
2841 readers.try_emplace(displayId, displayId);
2842 }
2843
2844 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2845
2846 const auto& [status, layer] = mComposerClient->createLayer(displayId, kBufferSlotCount);
2847 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2848 ASSERT_NE(nullptr, buffer);
2849 ASSERT_EQ(::android::OK, buffer->initCheck());
2850 ASSERT_NE(nullptr, buffer->handle);
2851
2852 configureLayer(*display, layer, Composition::DEVICE, display->getFrameRect(),
2853 display->getCrop());
2854 writer.setLayerBuffer(displayId, layer, /*slot*/ 0, buffer->handle,
2855 /*acquireFence*/ -1);
2856 writer.setLayerDataspace(displayId, layer, common::Dataspace::UNKNOWN);
2857 layers.try_emplace(displayId, layer);
2858 }
2859
2860 for (auto* const display : displays) {
2861 const int64_t displayId = display->getDisplayId();
2862 auto& writer = getWriter(displayId);
2863 std::unique_lock lock{readersMutex};
2864 auto& reader = readers.at(displayId);
2865 lock.unlock();
2866
2867 writer.validateDisplay(displayId, ComposerClientWriter::kNoTimestamp);
2868 execute(writer, reader);
2869
2870 threads.emplace_back([this, displayId, &readers, &readersMutex]() {
2871 auto& writer = getWriter(displayId);
2872 std::unique_lock lock{readersMutex};
2873 ComposerClientReader& reader = readers.at(displayId);
2874 lock.unlock();
2875
2876 writer.presentDisplay(displayId);
2877 execute(writer, reader);
2878 ASSERT_TRUE(reader.takeErrors().empty());
2879
2880 auto presentFence = reader.takePresentFence(displayId);
2881 // take ownership
2882 const int fenceOwner = presentFence.get();
2883 *presentFence.getR() = -1;
2884 EXPECT_NE(-1, fenceOwner);
2885 const auto presentFence2 = sp<::android::Fence>::make(fenceOwner);
2886 presentFence2->waitForever(LOG_TAG);
2887 });
2888 }
2889
2890 for (auto& thread : threads) {
2891 thread.join();
2892 }
2893
2894 for (auto& [displayId, layer] : layers) {
2895 EXPECT_TRUE(mComposerClient->destroyLayer(displayId, layer).isOk());
2896 }
2897
2898 std::lock_guard guard{readersMutex};
2899 for (auto& [displayId, reader] : readers) {
2900 ASSERT_TRUE(reader.takeErrors().empty());
2901 ASSERT_TRUE(reader.takeChangedCompositionTypes(displayId).empty());
2902 }
2903}
2904
ramindanidcfe3a82021-11-29 17:00:31 +00002905GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlCommandTest);
2906INSTANTIATE_TEST_SUITE_P(
2907 PerInstance, GraphicsComposerAidlCommandTest,
2908 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
2909 ::android::PrintInstanceNameToString);
ramindanid32ae8e2021-10-01 18:48:39 +00002910GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlTest);
2911INSTANTIATE_TEST_SUITE_P(
2912 PerInstance, GraphicsComposerAidlTest,
2913 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
2914 ::android::PrintInstanceNameToString);
ramindani12423f52023-06-14 20:04:51 -07002915GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlV2Test);
2916INSTANTIATE_TEST_SUITE_P(
2917 PerInstance, GraphicsComposerAidlV2Test,
2918 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
2919 ::android::PrintInstanceNameToString);
ramindani02fe4772023-06-30 18:04:41 -07002920GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlV3Test);
2921INSTANTIATE_TEST_SUITE_P(
2922 PerInstance, GraphicsComposerAidlV3Test,
2923 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
2924 ::android::PrintInstanceNameToString);
ramindani12423f52023-06-14 20:04:51 -07002925GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlCommandV2Test);
2926INSTANTIATE_TEST_SUITE_P(
2927 PerInstance, GraphicsComposerAidlCommandV2Test,
2928 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
2929 ::android::PrintInstanceNameToString);
2930
ramindanid32ae8e2021-10-01 18:48:39 +00002931} // namespace aidl::android::hardware::graphics::composer3::vts
2932
2933int main(int argc, char** argv) {
2934 ::testing::InitGoogleTest(&argc, argv);
2935
2936 using namespace std::chrono_literals;
2937 if (!android::base::WaitForProperty("init.svc.surfaceflinger", "stopped", 10s)) {
2938 ALOGE("Failed to stop init.svc.surfaceflinger");
2939 return -1;
2940 }
ramindanibeea10e2021-12-07 21:02:49 +00002941
2942 android::ProcessState::self()->setThreadPoolMaxThreadCount(4);
2943
2944 // The binder threadpool we start will inherit sched policy and priority
2945 // of (this) creating thread. We want the binder thread pool to have
2946 // SCHED_FIFO policy and priority 1 (lowest RT priority)
2947 // Once the pool is created we reset this thread's priority back to
2948 // original.
2949 // This thread policy is based on what we do in the SurfaceFlinger while starting
2950 // the thread pool and we need to replicate that for the VTS tests.
2951 int newPriority = 0;
2952 int origPolicy = sched_getscheduler(0);
2953 struct sched_param origSchedParam;
2954
2955 int errorInPriorityModification = sched_getparam(0, &origSchedParam);
2956 if (errorInPriorityModification == 0) {
2957 int policy = SCHED_FIFO;
2958 newPriority = sched_get_priority_min(policy);
2959
2960 struct sched_param param;
2961 param.sched_priority = newPriority;
2962
2963 errorInPriorityModification = sched_setscheduler(0, policy, &param);
2964 }
2965
2966 // start the thread pool
2967 android::ProcessState::self()->startThreadPool();
2968
2969 // Reset current thread's policy and priority
2970 if (errorInPriorityModification == 0) {
2971 errorInPriorityModification = sched_setscheduler(0, origPolicy, &origSchedParam);
2972 } else {
2973 ALOGE("Failed to set VtsHalGraphicsComposer3_TargetTest binder threadpool priority to "
2974 "SCHED_FIFO");
2975 }
2976
ramindanid32ae8e2021-10-01 18:48:39 +00002977 return RUN_ALL_TESTS();
Leon Scroggins III45095052023-03-23 18:23:15 -04002978}