blob: 67c7b5a9beed5be497b3100756df810aa0ea293e [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) {
Jason Macnak325e8232022-01-24 14:48:55 -08001881 if (!hasCapability(Capability::SKIP_VALIDATE)) {
ramindanidcfe3a82021-11-29 17:00:31 +00001882 GTEST_SUCCEED() << "Device does not have skip validate capability, skipping";
1883 return;
1884 }
ramindani431aad42022-02-01 21:44:29 +00001885 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001886
ramindani431aad42022-02-01 21:44:29 +00001887 const auto& [renderIntentsStatus, renderIntents] =
1888 mComposerClient->getRenderIntents(getPrimaryDisplayId(), ColorMode::NATIVE);
1889 EXPECT_TRUE(renderIntentsStatus.isOk());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001890 auto& writer = getWriter(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001891 for (auto intent : renderIntents) {
ramindani431aad42022-02-01 21:44:29 +00001892 EXPECT_TRUE(mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE, intent)
1893 .isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001894
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001895 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001896 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001897 ASSERT_NE(nullptr, handle);
1898
ramindani431aad42022-02-01 21:44:29 +00001899 const auto& [layerStatus, layer] =
1900 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1901 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001902
ramindani431aad42022-02-01 21:44:29 +00001903 Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
1904 getPrimaryDisplay().getDisplayHeight()};
1905 FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
1906 (float)getPrimaryDisplay().getDisplayHeight()};
1907 configureLayer(getPrimaryDisplay(), layer, Composition::CURSOR, displayFrame, cropRect);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001908 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle,
1909 /*acquireFence*/ -1);
1910 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
1911 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
ramindanidcfe3a82021-11-29 17:00:31 +00001912 execute();
ramindani431aad42022-02-01 21:44:29 +00001913 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
ramindanidcfe3a82021-11-29 17:00:31 +00001914 GTEST_SUCCEED() << "Composition change requested, skipping test";
1915 return;
1916 }
1917
Ady Abraham3192f3d2021-12-03 16:08:56 -08001918 ASSERT_TRUE(mReader.takeErrors().empty());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001919 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001920 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001921 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001922
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001923 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001924 const auto handle2 = buffer2->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001925 ASSERT_NE(nullptr, handle2);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001926 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle2,
1927 /*acquireFence*/ -1);
1928 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer,
1929 std::vector<Rect>(1, {0, 0, 10, 10}));
1930 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001931 execute();
1932 }
1933}
1934
ramindani431aad42022-02-01 21:44:29 +00001935TEST_P(GraphicsComposerAidlCommandTest, SetLayerCursorPosition) {
1936 const auto& [layerStatus, layer] =
1937 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1938 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001939
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001940 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001941 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001942 ASSERT_NE(nullptr, handle);
ramindanidcfe3a82021-11-29 17:00:31 +00001943
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001944 auto& writer = getWriter(getPrimaryDisplayId());
1945 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle, /*acquireFence*/ -1);
ramindani431aad42022-02-01 21:44:29 +00001946
1947 Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
1948 getPrimaryDisplay().getDisplayHeight()};
1949 FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
1950 (float)getPrimaryDisplay().getDisplayHeight()};
1951 configureLayer(getPrimaryDisplay(), layer, Composition::CURSOR, displayFrame, cropRect);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001952 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
1953 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
ramindanidcfe3a82021-11-29 17:00:31 +00001954
1955 execute();
Ady Abraham46219f52021-12-20 09:44:31 -08001956
ramindani431aad42022-02-01 21:44:29 +00001957 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
ramindanidcfe3a82021-11-29 17:00:31 +00001958 GTEST_SUCCEED() << "Composition change requested, skipping test";
1959 return;
1960 }
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001961 writer.presentDisplay(getPrimaryDisplayId());
Ady Abraham3192f3d2021-12-03 16:08:56 -08001962 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001963
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001964 writer.setLayerCursorPosition(getPrimaryDisplayId(), layer, /*x*/ 1, /*y*/ 1);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001965 execute();
1966
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001967 writer.setLayerCursorPosition(getPrimaryDisplayId(), layer, /*x*/ 0, /*y*/ 0);
1968 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
1969 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001970 execute();
1971}
1972
ramindani431aad42022-02-01 21:44:29 +00001973TEST_P(GraphicsComposerAidlCommandTest, SetLayerBuffer) {
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001974 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001975 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001976 ASSERT_NE(nullptr, handle);
1977
ramindani431aad42022-02-01 21:44:29 +00001978 const auto& [layerStatus, layer] =
1979 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1980 EXPECT_TRUE(layerStatus.isOk());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001981 auto& writer = getWriter(getPrimaryDisplayId());
1982 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle, /*acquireFence*/ -1);
ramindanidcfe3a82021-11-29 17:00:31 +00001983 execute();
1984}
1985
Brian Lindahl25e0d092022-12-09 00:32:11 -07001986TEST_P(GraphicsComposerAidlCommandTest, SetLayerBufferMultipleTimes) {
1987 const auto& [layerStatus, layer] =
1988 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1989 EXPECT_TRUE(layerStatus.isOk());
1990 auto& writer = getWriter(getPrimaryDisplayId());
1991
1992 // Setup 3 buffers in the buffer cache, with the last buffer being active. Then, emulate the
1993 // Android platform code that clears all 3 buffer slots by setting all but the active buffer
1994 // slot to a placeholder buffer, and then restoring the active buffer.
1995
1996 // This is used on HALs that don't support setLayerBufferSlotsToClear (version <= 3.1).
1997
1998 const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1999 ASSERT_NE(nullptr, buffer1);
2000 const auto handle1 = buffer1->handle;
2001 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle1, /*acquireFence*/ -1);
2002 execute();
2003 ASSERT_TRUE(mReader.takeErrors().empty());
2004
2005 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2006 ASSERT_NE(nullptr, buffer2);
2007 const auto handle2 = buffer2->handle;
2008 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 1, handle2, /*acquireFence*/ -1);
2009 execute();
2010 ASSERT_TRUE(mReader.takeErrors().empty());
2011
2012 const auto buffer3 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2013 ASSERT_NE(nullptr, buffer3);
2014 const auto handle3 = buffer3->handle;
2015 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 2, handle3, /*acquireFence*/ -1);
2016 execute();
2017 ASSERT_TRUE(mReader.takeErrors().empty());
2018
2019 // Older versions of the HAL clear all but the active buffer slot with a placeholder buffer,
2020 // and then restoring the current active buffer at the end
2021 auto clearSlotBuffer = allocate(1u, 1u, ::android::PIXEL_FORMAT_RGB_888);
2022 ASSERT_NE(nullptr, clearSlotBuffer);
2023 auto clearSlotBufferHandle = clearSlotBuffer->handle;
2024
2025 // clear buffer slots 0 and 1 with new layer commands... and then...
2026 writer.setLayerBufferWithNewCommand(getPrimaryDisplayId(), layer, /* slot */ 0,
2027 clearSlotBufferHandle, /*acquireFence*/ -1);
2028 writer.setLayerBufferWithNewCommand(getPrimaryDisplayId(), layer, /* slot */ 1,
2029 clearSlotBufferHandle, /*acquireFence*/ -1);
2030 // ...reset the layer buffer to the current active buffer slot with a final new command
2031 writer.setLayerBufferWithNewCommand(getPrimaryDisplayId(), layer, /*slot*/ 2, nullptr,
2032 /*acquireFence*/ -1);
2033 execute();
2034 ASSERT_TRUE(mReader.takeErrors().empty());
2035}
2036
ramindani431aad42022-02-01 21:44:29 +00002037TEST_P(GraphicsComposerAidlCommandTest, SetLayerSurfaceDamage) {
2038 const auto& [layerStatus, layer] =
2039 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2040 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002041
2042 Rect empty{0, 0, 0, 0};
2043 Rect unit{0, 0, 1, 1};
2044
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002045 auto& writer = getWriter(getPrimaryDisplayId());
2046 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
ramindanidcfe3a82021-11-29 17:00:31 +00002047 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002048 ASSERT_TRUE(mReader.takeErrors().empty());
2049
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002050 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
Ady Abraham3192f3d2021-12-03 16:08:56 -08002051 execute();
2052 ASSERT_TRUE(mReader.takeErrors().empty());
2053
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002054 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>());
Ady Abraham3192f3d2021-12-03 16:08:56 -08002055 execute();
2056 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002057}
2058
ramindani431aad42022-02-01 21:44:29 +00002059TEST_P(GraphicsComposerAidlCommandTest, SetLayerBlockingRegion) {
2060 const auto& [layerStatus, layer] =
2061 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2062 EXPECT_TRUE(layerStatus.isOk());
Leon Scroggins III03318152022-01-13 12:24:19 -05002063
2064 Rect empty{0, 0, 0, 0};
2065 Rect unit{0, 0, 1, 1};
2066
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002067 auto& writer = getWriter(getPrimaryDisplayId());
2068 writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
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>(1, unit));
Leon Scroggins III03318152022-01-13 12:24:19 -05002073 execute();
2074 ASSERT_TRUE(mReader.takeErrors().empty());
2075
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002076 writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>());
Leon Scroggins III03318152022-01-13 12:24:19 -05002077 execute();
2078 ASSERT_TRUE(mReader.takeErrors().empty());
2079}
2080
ramindani431aad42022-02-01 21:44:29 +00002081TEST_P(GraphicsComposerAidlCommandTest, SetLayerBlendMode) {
2082 const auto& [layerStatus, layer] =
2083 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2084 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002085
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002086 auto& writer = getWriter(getPrimaryDisplayId());
2087 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::NONE);
ramindanidcfe3a82021-11-29 17:00:31 +00002088 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002089 ASSERT_TRUE(mReader.takeErrors().empty());
2090
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002091 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::PREMULTIPLIED);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002092 execute();
2093 ASSERT_TRUE(mReader.takeErrors().empty());
2094
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002095 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::COVERAGE);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002096 execute();
2097 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002098}
2099
ramindani431aad42022-02-01 21:44:29 +00002100TEST_P(GraphicsComposerAidlCommandTest, SetLayerColor) {
2101 const auto& [layerStatus, layer] =
2102 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2103 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002104
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002105 auto& writer = getWriter(getPrimaryDisplayId());
2106 writer.setLayerColor(getPrimaryDisplayId(), layer, Color{1.0f, 1.0f, 1.0f, 1.0f});
ramindanidcfe3a82021-11-29 17:00:31 +00002107 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002108 ASSERT_TRUE(mReader.takeErrors().empty());
2109
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002110 writer.setLayerColor(getPrimaryDisplayId(), layer, Color{0.0f, 0.0f, 0.0f, 0.0f});
Ady Abraham3192f3d2021-12-03 16:08:56 -08002111 execute();
2112 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002113}
2114
ramindani431aad42022-02-01 21:44:29 +00002115TEST_P(GraphicsComposerAidlCommandTest, SetLayerCompositionType) {
2116 const auto& [layerStatus, layer] =
2117 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2118 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002119
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002120 auto& writer = getWriter(getPrimaryDisplayId());
2121 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::CLIENT);
ramindanidcfe3a82021-11-29 17:00:31 +00002122 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002123 ASSERT_TRUE(mReader.takeErrors().empty());
2124
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002125 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::DEVICE);
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::SOLID_COLOR);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002130 execute();
2131 ASSERT_TRUE(mReader.takeErrors().empty());
2132
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002133 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::CURSOR);
ramindani431aad42022-02-01 21:44:29 +00002134 execute();
2135}
2136
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002137TEST_P(GraphicsComposerAidlCommandTest, DisplayDecoration) {
2138 for (VtsDisplay& display : mDisplays) {
2139 const auto [layerStatus, layer] =
2140 mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount);
2141 EXPECT_TRUE(layerStatus.isOk());
2142
2143 const auto [error, support] =
2144 mComposerClient->getDisplayDecorationSupport(display.getDisplayId());
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002145
Leon Scroggins III91590872022-02-23 09:51:21 -05002146 const auto format = (error.isOk() && support) ? support->format
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002147 : aidl::android::hardware::graphics::common::PixelFormat::RGBA_8888;
2148 const auto decorBuffer = allocate(static_cast<::android::PixelFormat>(format));
2149 ASSERT_NE(nullptr, decorBuffer);
2150 if (::android::OK != decorBuffer->initCheck()) {
2151 if (support) {
2152 FAIL() << "Device advertised display decoration support with format "
2153 << aidl::android::hardware::graphics::common::toString(format)
2154 << " but failed to allocate it!";
2155 } else {
2156 FAIL() << "Device advertised NO display decoration support, but it should "
2157 << "still be able to allocate "
2158 << aidl::android::hardware::graphics::common::toString(format);
2159 }
2160 }
2161
Midas Chien7d55d422022-06-07 02:32:28 +08002162 configureLayer(display, layer, Composition::DISPLAY_DECORATION, display.getFrameRect(),
2163 display.getCrop());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002164 auto& writer = getWriter(display.getDisplayId());
2165 writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, decorBuffer->handle,
2166 /*acquireFence*/ -1);
2167 writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp);
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002168 execute();
2169 if (support) {
2170 ASSERT_TRUE(mReader.takeErrors().empty());
2171 } else {
2172 const auto errors = mReader.takeErrors();
2173 ASSERT_EQ(1, errors.size());
Leon Scroggins III6455e792022-02-24 12:18:58 -05002174 EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, errors[0].errorCode);
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002175 }
2176 }
2177}
2178
ramindani431aad42022-02-01 21:44:29 +00002179TEST_P(GraphicsComposerAidlCommandTest, SetLayerDataspace) {
2180 const auto& [layerStatus, layer] =
2181 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2182 EXPECT_TRUE(layerStatus.isOk());
2183
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002184 auto& writer = getWriter(getPrimaryDisplayId());
2185 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
ramindani431aad42022-02-01 21:44:29 +00002186 execute();
2187}
2188
2189TEST_P(GraphicsComposerAidlCommandTest, SetLayerDisplayFrame) {
2190 const auto& [layerStatus, layer] =
2191 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2192 EXPECT_TRUE(layerStatus.isOk());
2193
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002194 auto& writer = getWriter(getPrimaryDisplayId());
2195 writer.setLayerDisplayFrame(getPrimaryDisplayId(), layer, Rect{0, 0, 1, 1});
ramindani431aad42022-02-01 21:44:29 +00002196 execute();
2197}
2198
2199TEST_P(GraphicsComposerAidlCommandTest, SetLayerPlaneAlpha) {
2200 const auto& [layerStatus, layer] =
2201 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2202 EXPECT_TRUE(layerStatus.isOk());
2203
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002204 auto& writer = getWriter(getPrimaryDisplayId());
2205 writer.setLayerPlaneAlpha(getPrimaryDisplayId(), layer, /*alpha*/ 0.0f);
ramindani431aad42022-02-01 21:44:29 +00002206 execute();
2207 ASSERT_TRUE(mReader.takeErrors().empty());
2208
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002209 writer.setLayerPlaneAlpha(getPrimaryDisplayId(), layer, /*alpha*/ 1.0f);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002210 execute();
2211 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002212}
2213
ramindani431aad42022-02-01 21:44:29 +00002214TEST_P(GraphicsComposerAidlCommandTest, SetLayerSidebandStream) {
Jason Macnak325e8232022-01-24 14:48:55 -08002215 if (!hasCapability(Capability::SIDEBAND_STREAM)) {
ramindanidcfe3a82021-11-29 17:00:31 +00002216 GTEST_SUCCEED() << "no sideband stream support";
2217 return;
2218 }
2219
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002220 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00002221 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00002222 ASSERT_NE(nullptr, handle);
2223
ramindani431aad42022-02-01 21:44:29 +00002224 const auto& [layerStatus, layer] =
2225 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2226 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002227
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002228 auto& writer = getWriter(getPrimaryDisplayId());
2229 writer.setLayerSidebandStream(getPrimaryDisplayId(), layer, handle);
ramindanidcfe3a82021-11-29 17:00:31 +00002230 execute();
2231}
2232
ramindani431aad42022-02-01 21:44:29 +00002233TEST_P(GraphicsComposerAidlCommandTest, SetLayerSourceCrop) {
2234 const auto& [layerStatus, layer] =
2235 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2236 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002237
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002238 auto& writer = getWriter(getPrimaryDisplayId());
2239 writer.setLayerSourceCrop(getPrimaryDisplayId(), layer, FRect{0.0f, 0.0f, 1.0f, 1.0f});
ramindanidcfe3a82021-11-29 17:00:31 +00002240 execute();
2241}
2242
ramindani431aad42022-02-01 21:44:29 +00002243TEST_P(GraphicsComposerAidlCommandTest, SetLayerTransform) {
2244 const auto& [layerStatus, layer] =
2245 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2246 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002247
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002248 auto& writer = getWriter(getPrimaryDisplayId());
2249 writer.setLayerTransform(getPrimaryDisplayId(), layer, static_cast<Transform>(0));
ramindanidcfe3a82021-11-29 17:00:31 +00002250 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002251 ASSERT_TRUE(mReader.takeErrors().empty());
2252
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002253 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::FLIP_H);
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::FLIP_V);
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_90);
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_180);
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, Transform::ROT_270);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002270 execute();
2271 ASSERT_TRUE(mReader.takeErrors().empty());
2272
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002273 writer.setLayerTransform(getPrimaryDisplayId(), layer,
2274 static_cast<Transform>(static_cast<int>(Transform::FLIP_H) |
2275 static_cast<int>(Transform::ROT_90)));
Ady Abraham3192f3d2021-12-03 16:08:56 -08002276 execute();
2277 ASSERT_TRUE(mReader.takeErrors().empty());
2278
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002279 writer.setLayerTransform(getPrimaryDisplayId(), layer,
2280 static_cast<Transform>(static_cast<int>(Transform::FLIP_V) |
2281 static_cast<int>(Transform::ROT_90)));
Ady Abraham3192f3d2021-12-03 16:08:56 -08002282 execute();
2283 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002284}
2285
ramindani431aad42022-02-01 21:44:29 +00002286TEST_P(GraphicsComposerAidlCommandTest, SetLayerVisibleRegion) {
2287 const auto& [layerStatus, layer] =
2288 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2289 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002290
2291 Rect empty{0, 0, 0, 0};
2292 Rect unit{0, 0, 1, 1};
2293
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002294 auto& writer = getWriter(getPrimaryDisplayId());
2295 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
ramindanidcfe3a82021-11-29 17:00:31 +00002296 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002297 ASSERT_TRUE(mReader.takeErrors().empty());
2298
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002299 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
Ady Abraham3192f3d2021-12-03 16:08:56 -08002300 execute();
2301 ASSERT_TRUE(mReader.takeErrors().empty());
2302
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002303 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>());
Ady Abraham3192f3d2021-12-03 16:08:56 -08002304 execute();
2305 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002306}
2307
ramindani431aad42022-02-01 21:44:29 +00002308TEST_P(GraphicsComposerAidlCommandTest, SetLayerZOrder) {
2309 const auto& [layerStatus, layer] =
2310 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2311 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002312
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002313 auto& writer = getWriter(getPrimaryDisplayId());
2314 writer.setLayerZOrder(getPrimaryDisplayId(), layer, /*z*/ 10);
ramindanidcfe3a82021-11-29 17:00:31 +00002315 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002316 ASSERT_TRUE(mReader.takeErrors().empty());
2317
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002318 writer.setLayerZOrder(getPrimaryDisplayId(), layer, /*z*/ 0);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002319 execute();
2320 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002321}
2322
ramindani431aad42022-02-01 21:44:29 +00002323TEST_P(GraphicsComposerAidlCommandTest, SetLayerPerFrameMetadata) {
2324 const auto& [layerStatus, layer] =
2325 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2326 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002327
ramindanidcfe3a82021-11-29 17:00:31 +00002328 /**
2329 * DISPLAY_P3 is a color space that uses the DCI_P3 primaries,
2330 * the D65 white point and the SRGB transfer functions.
2331 * Rendering Intent: Colorimetric
2332 * Primaries:
2333 * x y
2334 * green 0.265 0.690
2335 * blue 0.150 0.060
2336 * red 0.680 0.320
2337 * white (D65) 0.3127 0.3290
2338 */
2339
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002340 auto& writer = getWriter(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00002341 std::vector<PerFrameMetadata> aidlMetadata;
2342 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X, 0.680f});
2343 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y, 0.320f});
2344 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X, 0.265f});
2345 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y, 0.690f});
2346 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X, 0.150f});
2347 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y, 0.060f});
2348 aidlMetadata.push_back({PerFrameMetadataKey::WHITE_POINT_X, 0.3127f});
2349 aidlMetadata.push_back({PerFrameMetadataKey::WHITE_POINT_Y, 0.3290f});
2350 aidlMetadata.push_back({PerFrameMetadataKey::MAX_LUMINANCE, 100.0f});
2351 aidlMetadata.push_back({PerFrameMetadataKey::MIN_LUMINANCE, 0.1f});
2352 aidlMetadata.push_back({PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL, 78.0});
2353 aidlMetadata.push_back({PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL, 62.0});
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002354 writer.setLayerPerFrameMetadata(getPrimaryDisplayId(), layer, aidlMetadata);
ramindanidcfe3a82021-11-29 17:00:31 +00002355 execute();
2356
Ady Abraham3192f3d2021-12-03 16:08:56 -08002357 const auto errors = mReader.takeErrors();
2358 if (errors.size() == 1 && errors[0].errorCode == EX_UNSUPPORTED_OPERATION) {
ramindanidcfe3a82021-11-29 17:00:31 +00002359 GTEST_SUCCEED() << "SetLayerPerFrameMetadata is not supported";
ramindani431aad42022-02-01 21:44:29 +00002360 EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002361 return;
2362 }
2363
ramindani431aad42022-02-01 21:44:29 +00002364 EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002365}
2366
Alec Mourib1f16722022-02-07 13:03:44 -08002367TEST_P(GraphicsComposerAidlCommandTest, setLayerBrightness) {
ramindani431aad42022-02-01 21:44:29 +00002368 const auto& [layerStatus, layer] =
2369 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
Alec Mouri95e490b2022-01-06 13:46:58 -08002370
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002371 auto& writer = getWriter(getPrimaryDisplayId());
2372 writer.setLayerBrightness(getPrimaryDisplayId(), layer, 0.2f);
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, 1.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, 0.f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002381 execute();
2382 ASSERT_TRUE(mReader.takeErrors().empty());
2383
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002384 writer.setLayerBrightness(getPrimaryDisplayId(), layer, -1.f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002385 execute();
Alec Mourib1f16722022-02-07 13:03:44 -08002386 {
2387 const auto errors = mReader.takeErrors();
2388 ASSERT_EQ(1, errors.size());
2389 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
2390 }
2391
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002392 writer.setLayerBrightness(getPrimaryDisplayId(), layer, std::nanf(""));
Alec Mourib1f16722022-02-07 13:03:44 -08002393 execute();
2394 {
2395 const auto errors = mReader.takeErrors();
2396 ASSERT_EQ(1, errors.size());
2397 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
2398 }
Alec Mouri95e490b2022-01-06 13:46:58 -08002399}
2400
ramindani431aad42022-02-01 21:44:29 +00002401TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints) {
ramindanidcfe3a82021-11-29 17:00:31 +00002402 Test_setActiveConfigWithConstraints({.delayForChange = 0, .refreshMiss = false});
2403}
2404
ramindani431aad42022-02-01 21:44:29 +00002405TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_Delayed) {
ramindanidcfe3a82021-11-29 17:00:31 +00002406 Test_setActiveConfigWithConstraints({.delayForChange = 300'000'000, // 300ms
2407 .refreshMiss = false});
2408}
2409
ramindani431aad42022-02-01 21:44:29 +00002410TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_MissRefresh) {
ramindanidcfe3a82021-11-29 17:00:31 +00002411 Test_setActiveConfigWithConstraints({.delayForChange = 0, .refreshMiss = true});
2412}
2413
ramindani431aad42022-02-01 21:44:29 +00002414TEST_P(GraphicsComposerAidlCommandTest, GetDisplayVsyncPeriod) {
ramindanidcfe3a82021-11-29 17:00:31 +00002415 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +00002416 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
2417 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002418
ramindani431aad42022-02-01 21:44:29 +00002419 for (int32_t config : configs) {
2420 int32_t expectedVsyncPeriodNanos = display.getDisplayConfig(config).vsyncPeriod;
2421
ramindanidcfe3a82021-11-29 17:00:31 +00002422 VsyncPeriodChangeConstraints constraints;
2423
2424 constraints.desiredTimeNanos = systemTime();
2425 constraints.seamlessRequired = false;
ramindani431aad42022-02-01 21:44:29 +00002426
2427 const auto& [timelineStatus, timeline] =
2428 mComposerClient->setActiveConfigWithConstraints(&display, config, constraints);
2429 EXPECT_TRUE(timelineStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002430
2431 if (timeline.refreshRequired) {
2432 sendRefreshFrame(display, &timeline);
2433 }
ramindani431aad42022-02-01 21:44:29 +00002434 waitForVsyncPeriodChange(display.getDisplayId(), timeline, constraints.desiredTimeNanos,
2435 /*odPeriodNanos*/ 0, expectedVsyncPeriodNanos);
ramindanidcfe3a82021-11-29 17:00:31 +00002436
2437 int32_t vsyncPeriodNanos;
2438 int retryCount = 100;
2439 do {
2440 std::this_thread::sleep_for(10ms);
ramindani431aad42022-02-01 21:44:29 +00002441 const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanosValue] =
2442 mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
2443
2444 EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
2445 vsyncPeriodNanos = vsyncPeriodNanosValue;
ramindanidcfe3a82021-11-29 17:00:31 +00002446 --retryCount;
2447 } while (vsyncPeriodNanos != expectedVsyncPeriodNanos && retryCount > 0);
2448
2449 EXPECT_EQ(vsyncPeriodNanos, expectedVsyncPeriodNanos);
2450
2451 // Make sure that the vsync period stays the same if the active config is not
2452 // changed.
2453 auto timeout = 1ms;
2454 for (int i = 0; i < 10; i++) {
2455 std::this_thread::sleep_for(timeout);
2456 timeout *= 2;
2457 vsyncPeriodNanos = 0;
ramindani431aad42022-02-01 21:44:29 +00002458 const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanosValue] =
2459 mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
2460
2461 EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
2462 vsyncPeriodNanos = vsyncPeriodNanosValue;
ramindanidcfe3a82021-11-29 17:00:31 +00002463 EXPECT_EQ(vsyncPeriodNanos, expectedVsyncPeriodNanos);
2464 }
2465 }
2466 }
2467}
2468
ramindani431aad42022-02-01 21:44:29 +00002469TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_SeamlessNotAllowed) {
ramindanidcfe3a82021-11-29 17:00:31 +00002470 VsyncPeriodChangeConstraints constraints;
ramindanidcfe3a82021-11-29 17:00:31 +00002471 constraints.seamlessRequired = true;
2472 constraints.desiredTimeNanos = systemTime();
2473
2474 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +00002475 forEachTwoConfigs(display.getDisplayId(), [&](int32_t config1, int32_t config2) {
2476 int32_t configGroup1 = display.getDisplayConfig(config1).configGroup;
2477 int32_t configGroup2 = display.getDisplayConfig(config2).configGroup;
ramindanidcfe3a82021-11-29 17:00:31 +00002478 if (configGroup1 != configGroup2) {
ramindani431aad42022-02-01 21:44:29 +00002479 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002480 sendRefreshFrame(display, nullptr);
ramindani431aad42022-02-01 21:44:29 +00002481 const auto& [status, _] = mComposerClient->setActiveConfigWithConstraints(
2482 &display, config2, constraints);
2483 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00002484 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(
2485 status, IComposerClient::EX_SEAMLESS_NOT_ALLOWED));
ramindanidcfe3a82021-11-29 17:00:31 +00002486 }
2487 });
2488 }
2489}
2490
ramindani431aad42022-02-01 21:44:29 +00002491TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_NoTimestamp) {
2492 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ std::nullopt));
Ady Abraham72c5b502021-12-10 17:23:39 -08002493}
2494
ramindani431aad42022-02-01 21:44:29 +00002495TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_0) {
2496 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ 0));
Ady Abraham72c5b502021-12-10 17:23:39 -08002497}
2498
ramindani431aad42022-02-01 21:44:29 +00002499TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_5) {
2500 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ 5));
Ady Abraham72c5b502021-12-10 17:23:39 -08002501}
2502
ramindani431aad42022-02-01 21:44:29 +00002503TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Unsupported) {
2504 const bool hasDisplayIdleTimerSupport =
2505 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002506 if (!hasDisplayIdleTimerSupport) {
ramindani431aad42022-02-01 21:44:29 +00002507 const auto& status =
2508 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0);
2509 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00002510 EXPECT_NO_FATAL_FAILURE(
2511 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
Midas Chiena0b56bd2022-01-13 23:27:33 +08002512 }
2513}
2514
ramindani431aad42022-02-01 21:44:29 +00002515TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_BadParameter) {
2516 const bool hasDisplayIdleTimerSupport =
2517 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002518 if (!hasDisplayIdleTimerSupport) {
2519 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2520 return;
2521 }
2522
ramindani431aad42022-02-01 21:44:29 +00002523 const auto& status =
2524 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ -1);
2525 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00002526 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
Midas Chiena0b56bd2022-01-13 23:27:33 +08002527}
2528
ramindani431aad42022-02-01 21:44:29 +00002529TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Disable) {
2530 const bool hasDisplayIdleTimerSupport =
2531 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002532 if (!hasDisplayIdleTimerSupport) {
2533 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2534 return;
2535 }
2536
ramindani431aad42022-02-01 21:44:29 +00002537 EXPECT_TRUE(mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002538 std::this_thread::sleep_for(1s);
ramindani431aad42022-02-01 21:44:29 +00002539 EXPECT_EQ(0, mComposerClient->getVsyncIdleCount());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002540}
2541
ramindani431aad42022-02-01 21:44:29 +00002542TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Timeout_2) {
2543 const bool hasDisplayIdleTimerSupport =
2544 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002545 if (!hasDisplayIdleTimerSupport) {
2546 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2547 return;
2548 }
2549
ramindani431aad42022-02-01 21:44:29 +00002550 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
2551 EXPECT_TRUE(mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002552
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002553 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002554 ASSERT_NE(nullptr, buffer->handle);
2555
2556 const auto layer = createOnScreenLayer();
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002557 auto& writer = getWriter(getPrimaryDisplayId());
2558 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer->handle,
2559 /*acquireFence*/ -1);
ramindani431aad42022-02-01 21:44:29 +00002560 int32_t vsyncIdleCount = mComposerClient->getVsyncIdleCount();
Midas Chiena0b56bd2022-01-13 23:27:33 +08002561 auto earlyVsyncIdleTime = systemTime() + std::chrono::nanoseconds(2s).count();
ramindani431aad42022-02-01 21:44:29 +00002562 EXPECT_TRUE(
2563 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 2000).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002564
2565 const sp<::android::Fence> presentFence =
ramindani431aad42022-02-01 21:44:29 +00002566 presentAndGetFence(ComposerClientWriter::kNoTimestamp);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002567 presentFence->waitForever(LOG_TAG);
2568
2569 std::this_thread::sleep_for(3s);
ramindani431aad42022-02-01 21:44:29 +00002570 if (vsyncIdleCount < mComposerClient->getVsyncIdleCount()) {
2571 EXPECT_GE(mComposerClient->getVsyncIdleTime(), earlyVsyncIdleTime);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002572 }
2573
ramindani431aad42022-02-01 21:44:29 +00002574 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002575}
2576
ramindani12423f52023-06-14 20:04:51 -07002577class GraphicsComposerAidlCommandV2Test : public GraphicsComposerAidlCommandTest {
2578 protected:
2579 void SetUp() override {
2580 GraphicsComposerAidlTest::SetUp();
2581 if (getInterfaceVersion() <= 1) {
2582 GTEST_SKIP() << "Device interface version is expected to be >= 2";
2583 }
ramindani17c71102023-03-20 10:51:14 -07002584 }
ramindani12423f52023-06-14 20:04:51 -07002585};
2586/**
2587 * Test Capability::SKIP_VALIDATE
2588 *
2589 * Capability::SKIP_VALIDATE has been deprecated and should not be enabled.
2590 */
2591TEST_P(GraphicsComposerAidlCommandV2Test, SkipValidateDeprecatedTest) {
2592 ASSERT_FALSE(hasCapability(Capability::SKIP_VALIDATE))
2593 << "Found Capability::SKIP_VALIDATE capability.";
2594}
2595
2596TEST_P(GraphicsComposerAidlCommandV2Test, SetLayerBufferSlotsToClear) {
2597 // Older HAL versions use a backwards compatible way of clearing buffer slots
2598 // HAL at version 1 or lower does not have LayerCommand::bufferSlotsToClear
2599 const auto& [layerStatus, layer] =
2600 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2601 EXPECT_TRUE(layerStatus.isOk());
2602 auto& writer = getWriter(getPrimaryDisplayId());
2603
2604 // setup 3 buffers in the buffer cache, with the last buffer being active
2605 // then emulate the Android platform code that clears all 3 buffer slots
2606
2607 const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2608 ASSERT_NE(nullptr, buffer1);
2609 const auto handle1 = buffer1->handle;
2610 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle1, /*acquireFence*/ -1);
2611 execute();
2612 ASSERT_TRUE(mReader.takeErrors().empty());
2613
2614 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2615 ASSERT_NE(nullptr, buffer2);
2616 const auto handle2 = buffer2->handle;
2617 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 1, handle2, /*acquireFence*/ -1);
2618 execute();
2619 ASSERT_TRUE(mReader.takeErrors().empty());
2620
2621 const auto buffer3 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2622 ASSERT_NE(nullptr, buffer3);
2623 const auto handle3 = buffer3->handle;
2624 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 2, handle3, /*acquireFence*/ -1);
2625 execute();
2626 ASSERT_TRUE(mReader.takeErrors().empty());
2627
2628 // Ensure we can clear all 3 buffer slots, even the active buffer - it is assumed the
2629 // current active buffer's slot will be cleared, but still remain the active buffer and no
2630 // errors will occur.
2631 writer.setLayerBufferSlotsToClear(getPrimaryDisplayId(), layer, {0, 1, 2});
2632 execute();
2633 ASSERT_TRUE(mReader.takeErrors().empty());
2634}
2635
2636TEST_P(GraphicsComposerAidlCommandV2Test, SetRefreshRateChangedCallbackDebug_Unsupported) {
ramindani9dd8c482023-02-21 18:07:56 -08002637 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2638 auto status = mComposerClient->setRefreshRateChangedCallbackDebugEnabled(
2639 getPrimaryDisplayId(), /*enabled*/ true);
2640 EXPECT_FALSE(status.isOk());
2641 EXPECT_NO_FATAL_FAILURE(
2642 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
2643
2644 status = mComposerClient->setRefreshRateChangedCallbackDebugEnabled(getPrimaryDisplayId(),
2645 /*enabled*/ false);
2646 EXPECT_FALSE(status.isOk());
2647 EXPECT_NO_FATAL_FAILURE(
2648 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
2649 }
2650}
2651
ramindani12423f52023-06-14 20:04:51 -07002652TEST_P(GraphicsComposerAidlCommandV2Test, SetRefreshRateChangedCallbackDebug_Enabled) {
ramindani9dd8c482023-02-21 18:07:56 -08002653 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2654 GTEST_SUCCEED() << "Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG is not supported";
2655 return;
2656 }
2657
2658 const auto displayId = getPrimaryDisplayId();
2659 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2660 // Enable the callback
2661 ASSERT_TRUE(mComposerClient
2662 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2663 /*enabled*/ true)
2664 .isOk());
2665 std::this_thread::sleep_for(100ms);
2666
ramindani91518892023-03-03 16:55:09 +00002667 const auto displayFilter = [displayId](auto refreshRateChangedDebugData) {
2668 return displayId == refreshRateChangedDebugData.display;
2669 };
ramindani9dd8c482023-02-21 18:07:56 -08002670
2671 // Check that we immediately got a callback
ramindani91518892023-03-03 16:55:09 +00002672 EXPECT_TRUE(checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter));
ramindani9dd8c482023-02-21 18:07:56 -08002673
2674 ASSERT_TRUE(mComposerClient
2675 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2676 /*enabled*/ false)
2677 .isOk());
2678}
2679
ramindani12423f52023-06-14 20:04:51 -07002680TEST_P(GraphicsComposerAidlCommandV2Test,
ramindani9dd8c482023-02-21 18:07:56 -08002681 SetRefreshRateChangedCallbackDebugEnabled_noCallbackWhenIdle) {
2682 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2683 GTEST_SUCCEED() << "Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG is not supported";
2684 return;
2685 }
2686
2687 auto display = getEditablePrimaryDisplay();
2688 const auto displayId = display.getDisplayId();
2689
2690 if (!hasDisplayCapability(displayId, DisplayCapability::DISPLAY_IDLE_TIMER)) {
2691 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2692 return;
2693 }
2694
2695 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2696 EXPECT_TRUE(mComposerClient->setPeakRefreshRateConfig(&display).isOk());
2697
2698 ASSERT_TRUE(mComposerClient->setIdleTimerEnabled(displayId, /*timeoutMs*/ 500).isOk());
2699 // Enable the callback
2700 ASSERT_TRUE(mComposerClient
2701 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2702 /*enabled*/ true)
2703 .isOk());
2704
ramindani91518892023-03-03 16:55:09 +00002705 const auto displayFilter = [displayId](auto refreshRateChangedDebugData) {
2706 return displayId == refreshRateChangedDebugData.display;
2707 };
ramindani9dd8c482023-02-21 18:07:56 -08002708
2709 int retryCount = 3;
2710 do {
2711 // Wait for 1s so that we enter the idle state
2712 std::this_thread::sleep_for(1s);
ramindani91518892023-03-03 16:55:09 +00002713 if (!checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter)) {
ramindani9dd8c482023-02-21 18:07:56 -08002714 // DID NOT receive a callback, we are in the idle state.
2715 break;
2716 }
2717 } while (--retryCount > 0);
2718
2719 if (retryCount == 0) {
2720 GTEST_SUCCEED() << "Unable to enter the idle mode";
2721 return;
2722 }
2723
2724 // Send the REFRESH_RATE_INDICATOR update
2725 ASSERT_NO_FATAL_FAILURE(
2726 sendBufferUpdate(createOnScreenLayer(Composition::REFRESH_RATE_INDICATOR)));
2727 std::this_thread::sleep_for(1s);
ramindani91518892023-03-03 16:55:09 +00002728 EXPECT_FALSE(checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter))
ramindani9dd8c482023-02-21 18:07:56 -08002729 << "A callback should not be received for REFRESH_RATE_INDICATOR";
2730
2731 EXPECT_TRUE(mComposerClient
2732 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2733 /*enabled*/ false)
2734 .isOk());
2735}
2736
ramindani12423f52023-06-14 20:04:51 -07002737TEST_P(GraphicsComposerAidlCommandV2Test,
ramindani9dd8c482023-02-21 18:07:56 -08002738 SetRefreshRateChangedCallbackDebugEnabled_SetActiveConfigWithConstraints) {
2739 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2740 GTEST_SUCCEED() << "Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG is not supported";
2741 return;
2742 }
2743
2744 VsyncPeriodChangeConstraints constraints;
2745 constraints.seamlessRequired = false;
2746 constraints.desiredTimeNanos = systemTime();
2747
2748 for (VtsDisplay& display : mDisplays) {
2749 const auto displayId = display.getDisplayId();
2750 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2751
2752 // Enable the callback
2753 ASSERT_TRUE(mComposerClient
2754 ->setRefreshRateChangedCallbackDebugEnabled(displayId, /*enabled*/ true)
2755 .isOk());
2756
2757 forEachTwoConfigs(displayId, [&](int32_t config1, int32_t config2) {
2758 const int32_t vsyncPeriod1 = display.getDisplayConfig(config1).vsyncPeriod;
2759 const int32_t vsyncPeriod2 = display.getDisplayConfig(config2).vsyncPeriod;
2760
2761 if (vsyncPeriod1 == vsyncPeriod2) {
2762 return; // continue
2763 }
2764
2765 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
2766 sendRefreshFrame(display, nullptr);
2767
2768 const auto& [status, timeline] =
2769 mComposerClient->setActiveConfigWithConstraints(&display, config2, constraints);
2770 EXPECT_TRUE(status.isOk());
2771
2772 if (timeline.refreshRequired) {
2773 sendRefreshFrame(display, &timeline);
2774 }
2775
ramindani91518892023-03-03 16:55:09 +00002776 const auto callbackFilter = [displayId,
2777 vsyncPeriod2](auto refreshRateChangedDebugData) {
2778 constexpr int kVsyncThreshold = 1000;
2779 return displayId == refreshRateChangedDebugData.display &&
2780 std::abs(vsyncPeriod2 - refreshRateChangedDebugData.vsyncPeriodNanos) <=
2781 kVsyncThreshold;
2782 };
ramindani9dd8c482023-02-21 18:07:56 -08002783
2784 int retryCount = 3;
2785 do {
2786 std::this_thread::sleep_for(100ms);
ramindani91518892023-03-03 16:55:09 +00002787 if (checkIfCallbackRefreshRateChangedDebugEnabledReceived(callbackFilter)) {
ramindani9dd8c482023-02-21 18:07:56 -08002788 GTEST_SUCCEED() << "Received a callback successfully";
2789 break;
2790 }
2791 } while (--retryCount > 0);
2792
2793 if (retryCount == 0) {
2794 GTEST_FAIL() << "failed to get a callback for the display " << displayId
2795 << " with config " << config2;
2796 }
2797 });
2798
2799 EXPECT_TRUE(
2800 mComposerClient
2801 ->setRefreshRateChangedCallbackDebugEnabled(displayId, /*enabled*/ false)
2802 .isOk());
2803 }
2804}
2805
Joen Chene0a962c2023-08-28 09:49:11 +00002806TEST_P(GraphicsComposerAidlCommandTest, MultiThreadedPresent) {
2807 std::vector<VtsDisplay*> displays;
2808 for (auto& display : mDisplays) {
2809 if (hasDisplayCapability(display.getDisplayId(),
2810 DisplayCapability::MULTI_THREADED_PRESENT)) {
2811 displays.push_back(&display);
2812 }
2813 }
2814
2815 const size_t numDisplays = displays.size();
2816 if (numDisplays <= 1u) {
2817 GTEST_SKIP();
2818 }
2819
2820 // When multi-threaded, use a reader per display. As with mWriters, this mutex
2821 // guards access to the map.
2822 std::mutex readersMutex;
2823 std::unordered_map<int64_t, ComposerClientReader> readers;
2824 std::vector<std::thread> threads;
2825 threads.reserve(numDisplays);
2826
2827 // Each display will have a layer to present. This maps from the display to
2828 // the layer, so we can properly destroy each layer at the end.
2829 std::unordered_map<int64_t, int64_t> layers;
2830
2831 for (auto* const display : displays) {
2832 const int64_t displayId = display->getDisplayId();
2833
2834 // Ensure that all writers and readers have been added to their respective
2835 // maps initially, so that the following loop never modifies the maps. The
2836 // maps are accessed from different threads, and if the maps were modified,
2837 // this would invalidate their iterators, and therefore references to the
2838 // writers and readers.
2839 auto& writer = getWriter(displayId);
2840 {
2841 std::lock_guard guard{readersMutex};
2842 readers.try_emplace(displayId, displayId);
2843 }
2844
2845 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2846
2847 const auto& [status, layer] = mComposerClient->createLayer(displayId, kBufferSlotCount);
2848 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2849 ASSERT_NE(nullptr, buffer);
2850 ASSERT_EQ(::android::OK, buffer->initCheck());
2851 ASSERT_NE(nullptr, buffer->handle);
2852
2853 configureLayer(*display, layer, Composition::DEVICE, display->getFrameRect(),
2854 display->getCrop());
2855 writer.setLayerBuffer(displayId, layer, /*slot*/ 0, buffer->handle,
2856 /*acquireFence*/ -1);
2857 writer.setLayerDataspace(displayId, layer, common::Dataspace::UNKNOWN);
2858 layers.try_emplace(displayId, layer);
2859 }
2860
2861 for (auto* const display : displays) {
2862 const int64_t displayId = display->getDisplayId();
2863 auto& writer = getWriter(displayId);
2864 std::unique_lock lock{readersMutex};
2865 auto& reader = readers.at(displayId);
2866 lock.unlock();
2867
2868 writer.validateDisplay(displayId, ComposerClientWriter::kNoTimestamp);
2869 execute(writer, reader);
2870
2871 threads.emplace_back([this, displayId, &readers, &readersMutex]() {
2872 auto& writer = getWriter(displayId);
2873 std::unique_lock lock{readersMutex};
2874 ComposerClientReader& reader = readers.at(displayId);
2875 lock.unlock();
2876
2877 writer.presentDisplay(displayId);
2878 execute(writer, reader);
2879 ASSERT_TRUE(reader.takeErrors().empty());
2880
2881 auto presentFence = reader.takePresentFence(displayId);
2882 // take ownership
2883 const int fenceOwner = presentFence.get();
2884 *presentFence.getR() = -1;
2885 EXPECT_NE(-1, fenceOwner);
2886 const auto presentFence2 = sp<::android::Fence>::make(fenceOwner);
2887 presentFence2->waitForever(LOG_TAG);
2888 });
2889 }
2890
2891 for (auto& thread : threads) {
2892 thread.join();
2893 }
2894
2895 for (auto& [displayId, layer] : layers) {
2896 EXPECT_TRUE(mComposerClient->destroyLayer(displayId, layer).isOk());
2897 }
2898
2899 std::lock_guard guard{readersMutex};
2900 for (auto& [displayId, reader] : readers) {
2901 ASSERT_TRUE(reader.takeErrors().empty());
2902 ASSERT_TRUE(reader.takeChangedCompositionTypes(displayId).empty());
2903 }
2904}
2905
ramindanidcfe3a82021-11-29 17:00:31 +00002906GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlCommandTest);
2907INSTANTIATE_TEST_SUITE_P(
2908 PerInstance, GraphicsComposerAidlCommandTest,
2909 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
2910 ::android::PrintInstanceNameToString);
ramindanid32ae8e2021-10-01 18:48:39 +00002911GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlTest);
2912INSTANTIATE_TEST_SUITE_P(
2913 PerInstance, GraphicsComposerAidlTest,
2914 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
2915 ::android::PrintInstanceNameToString);
ramindani12423f52023-06-14 20:04:51 -07002916GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlV2Test);
2917INSTANTIATE_TEST_SUITE_P(
2918 PerInstance, GraphicsComposerAidlV2Test,
2919 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
2920 ::android::PrintInstanceNameToString);
ramindani02fe4772023-06-30 18:04:41 -07002921GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlV3Test);
2922INSTANTIATE_TEST_SUITE_P(
2923 PerInstance, GraphicsComposerAidlV3Test,
2924 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
2925 ::android::PrintInstanceNameToString);
ramindani12423f52023-06-14 20:04:51 -07002926GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlCommandV2Test);
2927INSTANTIATE_TEST_SUITE_P(
2928 PerInstance, GraphicsComposerAidlCommandV2Test,
2929 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
2930 ::android::PrintInstanceNameToString);
2931
ramindanid32ae8e2021-10-01 18:48:39 +00002932} // namespace aidl::android::hardware::graphics::composer3::vts
2933
2934int main(int argc, char** argv) {
2935 ::testing::InitGoogleTest(&argc, argv);
2936
2937 using namespace std::chrono_literals;
2938 if (!android::base::WaitForProperty("init.svc.surfaceflinger", "stopped", 10s)) {
2939 ALOGE("Failed to stop init.svc.surfaceflinger");
2940 return -1;
2941 }
ramindanibeea10e2021-12-07 21:02:49 +00002942
2943 android::ProcessState::self()->setThreadPoolMaxThreadCount(4);
2944
2945 // The binder threadpool we start will inherit sched policy and priority
2946 // of (this) creating thread. We want the binder thread pool to have
2947 // SCHED_FIFO policy and priority 1 (lowest RT priority)
2948 // Once the pool is created we reset this thread's priority back to
2949 // original.
2950 // This thread policy is based on what we do in the SurfaceFlinger while starting
2951 // the thread pool and we need to replicate that for the VTS tests.
2952 int newPriority = 0;
2953 int origPolicy = sched_getscheduler(0);
2954 struct sched_param origSchedParam;
2955
2956 int errorInPriorityModification = sched_getparam(0, &origSchedParam);
2957 if (errorInPriorityModification == 0) {
2958 int policy = SCHED_FIFO;
2959 newPriority = sched_get_priority_min(policy);
2960
2961 struct sched_param param;
2962 param.sched_priority = newPriority;
2963
2964 errorInPriorityModification = sched_setscheduler(0, policy, &param);
2965 }
2966
2967 // start the thread pool
2968 android::ProcessState::self()->startThreadPool();
2969
2970 // Reset current thread's policy and priority
2971 if (errorInPriorityModification == 0) {
2972 errorInPriorityModification = sched_setscheduler(0, origPolicy, &origSchedParam);
2973 } else {
2974 ALOGE("Failed to set VtsHalGraphicsComposer3_TargetTest binder threadpool priority to "
2975 "SCHED_FIFO");
2976 }
2977
ramindanid32ae8e2021-10-01 18:48:39 +00002978 return RUN_ALL_TESTS();
Leon Scroggins III45095052023-03-23 18:23:15 -04002979}