blob: a53eb384e73800f4c62b23b39996b5160a4a0e01 [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
ramindanicdcfcaf2023-11-09 10:00:10 -08001482 writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp,
1483 VtsComposerClient::kNoFrameIntervalNs);
ramindanidcfe3a82021-11-29 17:00:31 +00001484 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001485 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001486
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001487 writer.presentDisplay(display.getDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001488 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001489 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001490 }
1491
1492 {
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001493 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindanidcfe3a82021-11-29 17:00:31 +00001494 ASSERT_NE(nullptr, buffer->handle);
1495
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001496 writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, buffer->handle,
1497 /*acquireFence*/ -1);
1498 writer.setLayerSurfaceDamage(display.getDisplayId(), layer,
1499 std::vector<Rect>(1, {0, 0, 10, 10}));
ramindanicdcfcaf2023-11-09 10:00:10 -08001500 writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp,
1501 VtsComposerClient::kNoFrameIntervalNs);
ramindanidcfe3a82021-11-29 17:00:31 +00001502 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001503 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001504
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001505 writer.presentDisplay(display.getDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001506 execute();
1507 }
1508
ramindani431aad42022-02-01 21:44:29 +00001509 EXPECT_TRUE(mComposerClient->destroyLayer(display.getDisplayId(), layer).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001510 }
1511
Ady Abraham72c5b502021-12-10 17:23:39 -08001512 sp<::android::Fence> presentAndGetFence(
1513 std::optional<ClockMonotonicTimestamp> expectedPresentTime) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001514 auto& writer = getWriter(getPrimaryDisplayId());
ramindanicdcfcaf2023-11-09 10:00:10 -08001515 writer.validateDisplay(getPrimaryDisplayId(), expectedPresentTime,
1516 VtsComposerClient::kNoFrameIntervalNs);
Ady Abraham72c5b502021-12-10 17:23:39 -08001517 execute();
1518 EXPECT_TRUE(mReader.takeErrors().empty());
1519
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001520 writer.presentDisplay(getPrimaryDisplayId());
Ady Abraham72c5b502021-12-10 17:23:39 -08001521 execute();
1522 EXPECT_TRUE(mReader.takeErrors().empty());
1523
ramindani431aad42022-02-01 21:44:29 +00001524 auto presentFence = mReader.takePresentFence(getPrimaryDisplayId());
Ady Abraham46219f52021-12-20 09:44:31 -08001525 // take ownership
1526 const int fenceOwner = presentFence.get();
1527 *presentFence.getR() = -1;
1528 EXPECT_NE(-1, fenceOwner);
1529 return sp<::android::Fence>::make(fenceOwner);
Ady Abraham72c5b502021-12-10 17:23:39 -08001530 }
1531
1532 int32_t getVsyncPeriod() {
ramindani431aad42022-02-01 21:44:29 +00001533 const auto& [status, activeConfig] =
1534 mComposerClient->getActiveConfig(getPrimaryDisplayId());
1535 EXPECT_TRUE(status.isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001536
ramindani431aad42022-02-01 21:44:29 +00001537 const auto& [vsyncPeriodStatus, vsyncPeriod] = mComposerClient->getDisplayAttribute(
1538 getPrimaryDisplayId(), activeConfig, DisplayAttribute::VSYNC_PERIOD);
1539 EXPECT_TRUE(vsyncPeriodStatus.isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001540 return vsyncPeriod;
1541 }
1542
ramindani9dd8c482023-02-21 18:07:56 -08001543 int64_t createOnScreenLayer(Composition composition = Composition::DEVICE) {
ramindani431aad42022-02-01 21:44:29 +00001544 const auto& [status, layer] =
1545 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1546 EXPECT_TRUE(status.isOk());
1547 Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
1548 getPrimaryDisplay().getDisplayHeight()};
1549 FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
1550 (float)getPrimaryDisplay().getDisplayHeight()};
ramindani9dd8c482023-02-21 18:07:56 -08001551 configureLayer(getPrimaryDisplay(), layer, composition, displayFrame, cropRect);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001552 auto& writer = getWriter(getPrimaryDisplayId());
1553 writer.setLayerDataspace(getPrimaryDisplayId(), layer, common::Dataspace::UNKNOWN);
Ady Abraham72c5b502021-12-10 17:23:39 -08001554 return layer;
1555 }
1556
ramindani9dd8c482023-02-21 18:07:56 -08001557 void sendBufferUpdate(int64_t layer) {
1558 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1559 ASSERT_NE(nullptr, buffer->handle);
1560
1561 auto& writer = getWriter(getPrimaryDisplayId());
1562 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer->handle,
1563 /*acquireFence*/ -1);
1564
1565 const sp<::android::Fence> presentFence =
1566 presentAndGetFence(ComposerClientWriter::kNoTimestamp);
1567 presentFence->waitForever(LOG_TAG);
1568 }
1569
Midas Chiena0b56bd2022-01-13 23:27:33 +08001570 bool hasDisplayCapability(int64_t display, DisplayCapability cap) {
ramindani431aad42022-02-01 21:44:29 +00001571 const auto& [status, capabilities] = mComposerClient->getDisplayCapabilities(display);
1572 EXPECT_TRUE(status.isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08001573
1574 return std::find(capabilities.begin(), capabilities.end(), cap) != capabilities.end();
1575 }
1576
ramindanidcfe3a82021-11-29 17:00:31 +00001577 void Test_setActiveConfigWithConstraints(const TestParameters& params) {
1578 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +00001579 forEachTwoConfigs(display.getDisplayId(), [&](int32_t config1, int32_t config2) {
1580 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001581 sendRefreshFrame(display, nullptr);
1582
ramindani431aad42022-02-01 21:44:29 +00001583 const auto displayConfigGroup1 = display.getDisplayConfig(config1);
1584 int32_t vsyncPeriod1 = displayConfigGroup1.vsyncPeriod;
1585 int32_t configGroup1 = displayConfigGroup1.configGroup;
1586
1587 const auto displayConfigGroup2 = display.getDisplayConfig(config2);
1588 int32_t vsyncPeriod2 = displayConfigGroup2.vsyncPeriod;
1589 int32_t configGroup2 = displayConfigGroup2.configGroup;
ramindanidcfe3a82021-11-29 17:00:31 +00001590
1591 if (vsyncPeriod1 == vsyncPeriod2) {
1592 return; // continue
1593 }
1594
1595 // We don't allow delayed change when changing config groups
1596 if (params.delayForChange > 0 && configGroup1 != configGroup2) {
1597 return; // continue
1598 }
1599
ramindanidcfe3a82021-11-29 17:00:31 +00001600 VsyncPeriodChangeConstraints constraints = {
1601 .desiredTimeNanos = systemTime() + params.delayForChange,
1602 .seamlessRequired = false};
ramindani431aad42022-02-01 21:44:29 +00001603 const auto& [status, timeline] = mComposerClient->setActiveConfigWithConstraints(
1604 &display, config2, constraints);
1605 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001606
1607 EXPECT_TRUE(timeline.newVsyncAppliedTimeNanos >= constraints.desiredTimeNanos);
1608 // Refresh rate should change within a reasonable time
1609 constexpr std::chrono::nanoseconds kReasonableTimeForChange = 1s; // 1 second
1610 EXPECT_TRUE(timeline.newVsyncAppliedTimeNanos - constraints.desiredTimeNanos <=
1611 kReasonableTimeForChange.count());
1612
1613 if (timeline.refreshRequired) {
1614 if (params.refreshMiss) {
1615 // Miss the refresh frame on purpose to make sure the implementation sends a
1616 // callback
1617 std::this_thread::sleep_until(toTimePoint(timeline.refreshTimeNanos) +
1618 100ms);
1619 }
1620 sendRefreshFrame(display, &timeline);
1621 }
ramindani431aad42022-02-01 21:44:29 +00001622 waitForVsyncPeriodChange(display.getDisplayId(), timeline,
1623 constraints.desiredTimeNanos, vsyncPeriod1, vsyncPeriod2);
ramindanidcfe3a82021-11-29 17:00:31 +00001624
1625 // At this point the refresh rate should have changed already, however in rare
1626 // cases the implementation might have missed the deadline. In this case a new
1627 // timeline should have been provided.
ramindani431aad42022-02-01 21:44:29 +00001628 auto newTimeline = mComposerClient->takeLastVsyncPeriodChangeTimeline();
ramindanidcfe3a82021-11-29 17:00:31 +00001629 if (timeline.refreshRequired && params.refreshMiss) {
1630 EXPECT_TRUE(newTimeline.has_value());
1631 }
1632
1633 if (newTimeline.has_value()) {
1634 if (newTimeline->refreshRequired) {
1635 sendRefreshFrame(display, &newTimeline.value());
1636 }
ramindani431aad42022-02-01 21:44:29 +00001637 waitForVsyncPeriodChange(display.getDisplayId(), newTimeline.value(),
ramindanidcfe3a82021-11-29 17:00:31 +00001638 constraints.desiredTimeNanos, vsyncPeriod1,
1639 vsyncPeriod2);
1640 }
1641
ramindani431aad42022-02-01 21:44:29 +00001642 const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanos] =
1643 mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
1644 EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001645 EXPECT_EQ(vsyncPeriodNanos, vsyncPeriod2);
1646 });
1647 }
1648 }
1649
Ady Abraham72c5b502021-12-10 17:23:39 -08001650 void Test_expectedPresentTime(std::optional<int> framesDelay) {
Jason Macnak325e8232022-01-24 14:48:55 -08001651 if (hasCapability(Capability::PRESENT_FENCE_IS_NOT_RELIABLE)) {
1652 GTEST_SUCCEED() << "Device has unreliable present fences capability, skipping";
1653 return;
1654 }
1655
ramindani431aad42022-02-01 21:44:29 +00001656 ASSERT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001657
1658 const auto vsyncPeriod = getVsyncPeriod();
1659
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001660 const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1661 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
Ady Abraham72c5b502021-12-10 17:23:39 -08001662 ASSERT_NE(nullptr, buffer1);
1663 ASSERT_NE(nullptr, buffer2);
1664
1665 const auto layer = createOnScreenLayer();
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001666 auto& writer = getWriter(getPrimaryDisplayId());
1667 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer1->handle,
1668 /*acquireFence*/ -1);
Ady Abraham72c5b502021-12-10 17:23:39 -08001669 const sp<::android::Fence> presentFence1 =
1670 presentAndGetFence(ComposerClientWriter::kNoTimestamp);
1671 presentFence1->waitForever(LOG_TAG);
1672
1673 auto expectedPresentTime = presentFence1->getSignalTime() + vsyncPeriod;
1674 if (framesDelay.has_value()) {
1675 expectedPresentTime += *framesDelay * vsyncPeriod;
1676 }
1677
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001678 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer2->handle,
1679 /*acquireFence*/ -1);
Ady Abraham72c5b502021-12-10 17:23:39 -08001680 const auto setExpectedPresentTime = [&]() -> std::optional<ClockMonotonicTimestamp> {
1681 if (!framesDelay.has_value()) {
1682 return ComposerClientWriter::kNoTimestamp;
1683 } else if (*framesDelay == 0) {
1684 return ClockMonotonicTimestamp{0};
1685 }
1686 return ClockMonotonicTimestamp{expectedPresentTime};
1687 }();
1688
1689 const sp<::android::Fence> presentFence2 = presentAndGetFence(setExpectedPresentTime);
1690 presentFence2->waitForever(LOG_TAG);
1691
1692 const auto actualPresentTime = presentFence2->getSignalTime();
Ady Abrahamdf084f32022-01-10 14:10:23 -08001693 EXPECT_GE(actualPresentTime, expectedPresentTime - vsyncPeriod / 2);
Ady Abraham72c5b502021-12-10 17:23:39 -08001694
ramindani431aad42022-02-01 21:44:29 +00001695 ASSERT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001696 }
1697
ramindani431aad42022-02-01 21:44:29 +00001698 void configureLayer(const VtsDisplay& display, int64_t layer, Composition composition,
1699 const Rect& displayFrame, const FRect& cropRect) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001700 auto& writer = getWriter(display.getDisplayId());
1701 writer.setLayerCompositionType(display.getDisplayId(), layer, composition);
1702 writer.setLayerDisplayFrame(display.getDisplayId(), layer, displayFrame);
1703 writer.setLayerPlaneAlpha(display.getDisplayId(), layer, /*alpha*/ 1);
1704 writer.setLayerSourceCrop(display.getDisplayId(), layer, cropRect);
1705 writer.setLayerTransform(display.getDisplayId(), layer, static_cast<Transform>(0));
1706 writer.setLayerVisibleRegion(display.getDisplayId(), layer,
1707 std::vector<Rect>(1, displayFrame));
1708 writer.setLayerZOrder(display.getDisplayId(), layer, /*z*/ 10);
1709 writer.setLayerBlendMode(display.getDisplayId(), layer, BlendMode::NONE);
1710 writer.setLayerSurfaceDamage(display.getDisplayId(), layer,
1711 std::vector<Rect>(1, displayFrame));
ramindani431aad42022-02-01 21:44:29 +00001712 }
ramindanidcfe3a82021-11-29 17:00:31 +00001713 // clang-format off
1714 const std::array<float, 16> kIdentity = {{
1715 1.0f, 0.0f, 0.0f, 0.0f,
1716 0.0f, 1.0f, 0.0f, 0.0f,
1717 0.0f, 0.0f, 1.0f, 0.0f,
1718 0.0f, 0.0f, 0.0f, 1.0f,
1719 }};
1720 // clang-format on
1721
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001722 ComposerClientWriter& getWriter(int64_t display) {
Joen Chene0a962c2023-08-28 09:49:11 +00001723 std::lock_guard guard{mWritersMutex};
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001724 auto [it, _] = mWriters.try_emplace(display, display);
1725 return it->second;
1726 }
1727
Ady Abraham91c9d1a2021-12-15 18:14:45 -08001728 ComposerClientReader mReader;
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001729
1730 private:
Joen Chene0a962c2023-08-28 09:49:11 +00001731 void executeInternal(ComposerClientWriter& writer,
1732 std::vector<CommandResultPayload>& payloads) {
1733 auto commands = writer.takePendingCommands();
1734 if (commands.empty()) {
1735 return;
1736 }
1737
1738 auto [status, results] = mComposerClient->executeCommands(commands);
1739 ASSERT_TRUE(status.isOk()) << "executeCommands failed " << status.getDescription();
1740
1741 payloads.reserve(payloads.size() + results.size());
1742 payloads.insert(payloads.end(), std::make_move_iterator(results.begin()),
1743 std::make_move_iterator(results.end()));
1744 }
1745
1746 // Guards access to the map itself. Callers must ensure not to attempt to
1747 // - modify the same writer from multiple threads
1748 // - insert a new writer into the map during concurrent access, which would invalidate
1749 // references from other threads
1750 std::mutex mWritersMutex;
1751 std::unordered_map<int64_t, ComposerClientWriter> mWriters GUARDED_BY(mWritersMutex);
ramindanidcfe3a82021-11-29 17:00:31 +00001752};
1753
ramindani431aad42022-02-01 21:44:29 +00001754TEST_P(GraphicsComposerAidlCommandTest, SetColorTransform) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001755 auto& writer = getWriter(getPrimaryDisplayId());
1756 writer.setColorTransform(getPrimaryDisplayId(), kIdentity.data());
ramindanidcfe3a82021-11-29 17:00:31 +00001757 execute();
1758}
1759
1760TEST_P(GraphicsComposerAidlCommandTest, SetLayerColorTransform) {
ramindani431aad42022-02-01 21:44:29 +00001761 const auto& [status, layer] =
1762 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1763 EXPECT_TRUE(status.isOk());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001764 auto& writer = getWriter(getPrimaryDisplayId());
1765 writer.setLayerColorTransform(getPrimaryDisplayId(), layer, kIdentity.data());
ramindanidcfe3a82021-11-29 17:00:31 +00001766 execute();
1767
Ady Abraham3192f3d2021-12-03 16:08:56 -08001768 const auto errors = mReader.takeErrors();
Jason Macnak062bc9a2022-01-20 15:00:09 -08001769 if (errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_UNSUPPORTED) {
ramindanidcfe3a82021-11-29 17:00:31 +00001770 GTEST_SUCCEED() << "setLayerColorTransform is not supported";
1771 return;
1772 }
1773}
1774
Alec Mouri60564e12021-12-09 18:48:20 -08001775TEST_P(GraphicsComposerAidlCommandTest, SetDisplayBrightness) {
ramindani431aad42022-02-01 21:44:29 +00001776 const auto& [status, capabilities] =
1777 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
1778 ASSERT_TRUE(status.isOk());
Alec Mouri60564e12021-12-09 18:48:20 -08001779 bool brightnessSupport = std::find(capabilities.begin(), capabilities.end(),
1780 DisplayCapability::BRIGHTNESS) != capabilities.end();
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001781 auto& writer = getWriter(getPrimaryDisplayId());
Alec Mouri60564e12021-12-09 18:48:20 -08001782 if (!brightnessSupport) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001783 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.5f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001784 execute();
1785 const auto errors = mReader.takeErrors();
1786 EXPECT_EQ(1, errors.size());
Jason Macnak062bc9a2022-01-20 15:00:09 -08001787 EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, errors[0].errorCode);
Alec Mouri60564e12021-12-09 18:48:20 -08001788 GTEST_SUCCEED() << "SetDisplayBrightness is not supported";
1789 return;
1790 }
1791
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001792 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001793 execute();
1794 EXPECT_TRUE(mReader.takeErrors().empty());
1795
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001796 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.5f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001797 execute();
1798 EXPECT_TRUE(mReader.takeErrors().empty());
1799
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001800 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 1.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001801 execute();
1802 EXPECT_TRUE(mReader.takeErrors().empty());
1803
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001804 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ -1.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001805 execute();
1806 EXPECT_TRUE(mReader.takeErrors().empty());
1807
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001808 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 2.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001809 execute();
1810 {
1811 const auto errors = mReader.takeErrors();
ramindanib3bdf052022-01-12 18:27:05 +00001812 ASSERT_EQ(1, errors.size());
Alec Mouri60564e12021-12-09 18:48:20 -08001813 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
1814 }
1815
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001816 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ -2.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001817 execute();
1818 {
1819 const auto errors = mReader.takeErrors();
ramindanib3bdf052022-01-12 18:27:05 +00001820 ASSERT_EQ(1, errors.size());
Alec Mouri60564e12021-12-09 18:48:20 -08001821 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
1822 }
1823}
1824
ramindani431aad42022-02-01 21:44:29 +00001825TEST_P(GraphicsComposerAidlCommandTest, SetClientTarget) {
1826 EXPECT_TRUE(mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kBufferSlotCount)
1827 .isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001828
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001829 auto& writer = getWriter(getPrimaryDisplayId());
1830 writer.setClientTarget(getPrimaryDisplayId(), /*slot*/ 0, nullptr, /*acquireFence*/ -1,
Alec Mouri8062f1f2023-09-06 02:14:47 +00001831 Dataspace::UNKNOWN, std::vector<Rect>(), 1.0f);
ramindanidcfe3a82021-11-29 17:00:31 +00001832
1833 execute();
1834}
1835
ramindani431aad42022-02-01 21:44:29 +00001836TEST_P(GraphicsComposerAidlCommandTest, SetOutputBuffer) {
1837 const auto& [status, virtualDisplayCount] = mComposerClient->getMaxVirtualDisplayCount();
1838 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001839 if (virtualDisplayCount == 0) {
1840 GTEST_SUCCEED() << "no virtual display support";
1841 return;
1842 }
1843
ramindani431aad42022-02-01 21:44:29 +00001844 const auto& [displayStatus, display] = mComposerClient->createVirtualDisplay(
1845 /*width*/ 64, /*height*/ 64, common::PixelFormat::IMPLEMENTATION_DEFINED,
1846 kBufferSlotCount);
1847 EXPECT_TRUE(displayStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001848
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001849 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001850 const auto handle = buffer->handle;
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001851 auto& writer = getWriter(display.display);
1852 writer.setOutputBuffer(display.display, /*slot*/ 0, handle, /*releaseFence*/ -1);
ramindanidcfe3a82021-11-29 17:00:31 +00001853 execute();
1854}
1855
ramindani431aad42022-02-01 21:44:29 +00001856TEST_P(GraphicsComposerAidlCommandTest, ValidDisplay) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001857 auto& writer = getWriter(getPrimaryDisplayId());
ramindanicdcfcaf2023-11-09 10:00:10 -08001858 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
1859 VtsComposerClient::kNoFrameIntervalNs);
ramindanidcfe3a82021-11-29 17:00:31 +00001860 execute();
1861}
1862
ramindani431aad42022-02-01 21:44:29 +00001863TEST_P(GraphicsComposerAidlCommandTest, AcceptDisplayChanges) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001864 auto& writer = getWriter(getPrimaryDisplayId());
ramindanicdcfcaf2023-11-09 10:00:10 -08001865 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
1866 VtsComposerClient::kNoFrameIntervalNs);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001867 writer.acceptDisplayChanges(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001868 execute();
1869}
1870
ramindani431aad42022-02-01 21:44:29 +00001871TEST_P(GraphicsComposerAidlCommandTest, PresentDisplay) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001872 auto& writer = getWriter(getPrimaryDisplayId());
ramindanicdcfcaf2023-11-09 10:00:10 -08001873 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
1874 VtsComposerClient::kNoFrameIntervalNs);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001875 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001876 execute();
1877}
1878
1879/**
1880 * Test IComposerClient::Command::PRESENT_DISPLAY
1881 *
1882 * Test that IComposerClient::Command::PRESENT_DISPLAY works without
1883 * additional call to validateDisplay when only the layer buffer handle and
1884 * surface damage have been set
1885 */
ramindani431aad42022-02-01 21:44:29 +00001886TEST_P(GraphicsComposerAidlCommandTest, PresentDisplayNoLayerStateChanges) {
ramindani431aad42022-02-01 21:44:29 +00001887 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001888
ramindani431aad42022-02-01 21:44:29 +00001889 const auto& [renderIntentsStatus, renderIntents] =
1890 mComposerClient->getRenderIntents(getPrimaryDisplayId(), ColorMode::NATIVE);
1891 EXPECT_TRUE(renderIntentsStatus.isOk());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001892 auto& writer = getWriter(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001893 for (auto intent : renderIntents) {
ramindani431aad42022-02-01 21:44:29 +00001894 EXPECT_TRUE(mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE, intent)
1895 .isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001896
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001897 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001898 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001899 ASSERT_NE(nullptr, handle);
1900
ramindani431aad42022-02-01 21:44:29 +00001901 const auto& [layerStatus, layer] =
1902 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1903 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001904
ramindani431aad42022-02-01 21:44:29 +00001905 Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
1906 getPrimaryDisplay().getDisplayHeight()};
1907 FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
1908 (float)getPrimaryDisplay().getDisplayHeight()};
1909 configureLayer(getPrimaryDisplay(), layer, Composition::CURSOR, displayFrame, cropRect);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001910 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle,
1911 /*acquireFence*/ -1);
1912 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
ramindanicdcfcaf2023-11-09 10:00:10 -08001913 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
1914 VtsComposerClient::kNoFrameIntervalNs);
ramindanidcfe3a82021-11-29 17:00:31 +00001915 execute();
ramindani431aad42022-02-01 21:44:29 +00001916 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
ramindanidcfe3a82021-11-29 17:00:31 +00001917 GTEST_SUCCEED() << "Composition change requested, skipping test";
1918 return;
1919 }
1920
Ady Abraham3192f3d2021-12-03 16:08:56 -08001921 ASSERT_TRUE(mReader.takeErrors().empty());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001922 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001923 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001924 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001925
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001926 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001927 const auto handle2 = buffer2->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001928 ASSERT_NE(nullptr, handle2);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001929 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle2,
1930 /*acquireFence*/ -1);
1931 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer,
1932 std::vector<Rect>(1, {0, 0, 10, 10}));
1933 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001934 execute();
1935 }
1936}
1937
ramindani431aad42022-02-01 21:44:29 +00001938TEST_P(GraphicsComposerAidlCommandTest, SetLayerCursorPosition) {
1939 const auto& [layerStatus, layer] =
1940 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1941 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001942
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001943 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001944 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001945 ASSERT_NE(nullptr, handle);
ramindanidcfe3a82021-11-29 17:00:31 +00001946
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001947 auto& writer = getWriter(getPrimaryDisplayId());
1948 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle, /*acquireFence*/ -1);
ramindani431aad42022-02-01 21:44:29 +00001949
1950 Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
1951 getPrimaryDisplay().getDisplayHeight()};
1952 FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
1953 (float)getPrimaryDisplay().getDisplayHeight()};
1954 configureLayer(getPrimaryDisplay(), layer, Composition::CURSOR, displayFrame, cropRect);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001955 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
ramindanicdcfcaf2023-11-09 10:00:10 -08001956 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
1957 VtsComposerClient::kNoFrameIntervalNs);
ramindanidcfe3a82021-11-29 17:00:31 +00001958
1959 execute();
Ady Abraham46219f52021-12-20 09:44:31 -08001960
ramindani431aad42022-02-01 21:44:29 +00001961 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
ramindanidcfe3a82021-11-29 17:00:31 +00001962 GTEST_SUCCEED() << "Composition change requested, skipping test";
1963 return;
1964 }
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001965 writer.presentDisplay(getPrimaryDisplayId());
Ady Abraham3192f3d2021-12-03 16:08:56 -08001966 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001967
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001968 writer.setLayerCursorPosition(getPrimaryDisplayId(), layer, /*x*/ 1, /*y*/ 1);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001969 execute();
1970
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001971 writer.setLayerCursorPosition(getPrimaryDisplayId(), layer, /*x*/ 0, /*y*/ 0);
ramindanicdcfcaf2023-11-09 10:00:10 -08001972 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
1973 VtsComposerClient::kNoFrameIntervalNs);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001974 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001975 execute();
1976}
1977
ramindani431aad42022-02-01 21:44:29 +00001978TEST_P(GraphicsComposerAidlCommandTest, SetLayerBuffer) {
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001979 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001980 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001981 ASSERT_NE(nullptr, handle);
1982
ramindani431aad42022-02-01 21:44:29 +00001983 const auto& [layerStatus, layer] =
1984 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1985 EXPECT_TRUE(layerStatus.isOk());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001986 auto& writer = getWriter(getPrimaryDisplayId());
1987 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle, /*acquireFence*/ -1);
ramindanidcfe3a82021-11-29 17:00:31 +00001988 execute();
1989}
1990
Brian Lindahl25e0d092022-12-09 00:32:11 -07001991TEST_P(GraphicsComposerAidlCommandTest, SetLayerBufferMultipleTimes) {
1992 const auto& [layerStatus, layer] =
1993 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1994 EXPECT_TRUE(layerStatus.isOk());
1995 auto& writer = getWriter(getPrimaryDisplayId());
1996
1997 // Setup 3 buffers in the buffer cache, with the last buffer being active. Then, emulate the
1998 // Android platform code that clears all 3 buffer slots by setting all but the active buffer
1999 // slot to a placeholder buffer, and then restoring the active buffer.
2000
2001 // This is used on HALs that don't support setLayerBufferSlotsToClear (version <= 3.1).
2002
2003 const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2004 ASSERT_NE(nullptr, buffer1);
2005 const auto handle1 = buffer1->handle;
2006 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle1, /*acquireFence*/ -1);
2007 execute();
2008 ASSERT_TRUE(mReader.takeErrors().empty());
2009
2010 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2011 ASSERT_NE(nullptr, buffer2);
2012 const auto handle2 = buffer2->handle;
2013 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 1, handle2, /*acquireFence*/ -1);
2014 execute();
2015 ASSERT_TRUE(mReader.takeErrors().empty());
2016
2017 const auto buffer3 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2018 ASSERT_NE(nullptr, buffer3);
2019 const auto handle3 = buffer3->handle;
2020 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 2, handle3, /*acquireFence*/ -1);
2021 execute();
2022 ASSERT_TRUE(mReader.takeErrors().empty());
2023
2024 // Older versions of the HAL clear all but the active buffer slot with a placeholder buffer,
2025 // and then restoring the current active buffer at the end
2026 auto clearSlotBuffer = allocate(1u, 1u, ::android::PIXEL_FORMAT_RGB_888);
2027 ASSERT_NE(nullptr, clearSlotBuffer);
2028 auto clearSlotBufferHandle = clearSlotBuffer->handle;
2029
2030 // clear buffer slots 0 and 1 with new layer commands... and then...
2031 writer.setLayerBufferWithNewCommand(getPrimaryDisplayId(), layer, /* slot */ 0,
2032 clearSlotBufferHandle, /*acquireFence*/ -1);
2033 writer.setLayerBufferWithNewCommand(getPrimaryDisplayId(), layer, /* slot */ 1,
2034 clearSlotBufferHandle, /*acquireFence*/ -1);
2035 // ...reset the layer buffer to the current active buffer slot with a final new command
2036 writer.setLayerBufferWithNewCommand(getPrimaryDisplayId(), layer, /*slot*/ 2, nullptr,
2037 /*acquireFence*/ -1);
2038 execute();
2039 ASSERT_TRUE(mReader.takeErrors().empty());
2040}
2041
ramindani431aad42022-02-01 21:44:29 +00002042TEST_P(GraphicsComposerAidlCommandTest, SetLayerSurfaceDamage) {
2043 const auto& [layerStatus, layer] =
2044 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2045 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002046
2047 Rect empty{0, 0, 0, 0};
2048 Rect unit{0, 0, 1, 1};
2049
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002050 auto& writer = getWriter(getPrimaryDisplayId());
2051 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
ramindanidcfe3a82021-11-29 17:00:31 +00002052 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002053 ASSERT_TRUE(mReader.takeErrors().empty());
2054
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002055 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
Ady Abraham3192f3d2021-12-03 16:08:56 -08002056 execute();
2057 ASSERT_TRUE(mReader.takeErrors().empty());
2058
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002059 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>());
Ady Abraham3192f3d2021-12-03 16:08:56 -08002060 execute();
2061 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002062}
2063
ramindani431aad42022-02-01 21:44:29 +00002064TEST_P(GraphicsComposerAidlCommandTest, SetLayerBlockingRegion) {
2065 const auto& [layerStatus, layer] =
2066 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2067 EXPECT_TRUE(layerStatus.isOk());
Leon Scroggins III03318152022-01-13 12:24:19 -05002068
2069 Rect empty{0, 0, 0, 0};
2070 Rect unit{0, 0, 1, 1};
2071
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002072 auto& writer = getWriter(getPrimaryDisplayId());
2073 writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
Leon Scroggins III03318152022-01-13 12:24:19 -05002074 execute();
2075 ASSERT_TRUE(mReader.takeErrors().empty());
2076
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002077 writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
Leon Scroggins III03318152022-01-13 12:24:19 -05002078 execute();
2079 ASSERT_TRUE(mReader.takeErrors().empty());
2080
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002081 writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>());
Leon Scroggins III03318152022-01-13 12:24:19 -05002082 execute();
2083 ASSERT_TRUE(mReader.takeErrors().empty());
2084}
2085
ramindani431aad42022-02-01 21:44:29 +00002086TEST_P(GraphicsComposerAidlCommandTest, SetLayerBlendMode) {
2087 const auto& [layerStatus, layer] =
2088 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2089 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002090
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002091 auto& writer = getWriter(getPrimaryDisplayId());
2092 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::NONE);
ramindanidcfe3a82021-11-29 17:00:31 +00002093 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002094 ASSERT_TRUE(mReader.takeErrors().empty());
2095
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002096 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::PREMULTIPLIED);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002097 execute();
2098 ASSERT_TRUE(mReader.takeErrors().empty());
2099
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002100 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::COVERAGE);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002101 execute();
2102 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002103}
2104
ramindani431aad42022-02-01 21:44:29 +00002105TEST_P(GraphicsComposerAidlCommandTest, SetLayerColor) {
2106 const auto& [layerStatus, layer] =
2107 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2108 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002109
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002110 auto& writer = getWriter(getPrimaryDisplayId());
2111 writer.setLayerColor(getPrimaryDisplayId(), layer, Color{1.0f, 1.0f, 1.0f, 1.0f});
ramindanidcfe3a82021-11-29 17:00:31 +00002112 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002113 ASSERT_TRUE(mReader.takeErrors().empty());
2114
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002115 writer.setLayerColor(getPrimaryDisplayId(), layer, Color{0.0f, 0.0f, 0.0f, 0.0f});
Ady Abraham3192f3d2021-12-03 16:08:56 -08002116 execute();
2117 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002118}
2119
ramindani431aad42022-02-01 21:44:29 +00002120TEST_P(GraphicsComposerAidlCommandTest, SetLayerCompositionType) {
2121 const auto& [layerStatus, layer] =
2122 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2123 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002124
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002125 auto& writer = getWriter(getPrimaryDisplayId());
2126 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::CLIENT);
ramindanidcfe3a82021-11-29 17:00:31 +00002127 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002128 ASSERT_TRUE(mReader.takeErrors().empty());
2129
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002130 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::DEVICE);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002131 execute();
2132 ASSERT_TRUE(mReader.takeErrors().empty());
2133
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002134 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::SOLID_COLOR);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002135 execute();
2136 ASSERT_TRUE(mReader.takeErrors().empty());
2137
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002138 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::CURSOR);
ramindani431aad42022-02-01 21:44:29 +00002139 execute();
2140}
2141
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002142TEST_P(GraphicsComposerAidlCommandTest, DisplayDecoration) {
2143 for (VtsDisplay& display : mDisplays) {
2144 const auto [layerStatus, layer] =
2145 mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount);
2146 EXPECT_TRUE(layerStatus.isOk());
2147
2148 const auto [error, support] =
2149 mComposerClient->getDisplayDecorationSupport(display.getDisplayId());
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002150
Leon Scroggins III91590872022-02-23 09:51:21 -05002151 const auto format = (error.isOk() && support) ? support->format
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002152 : aidl::android::hardware::graphics::common::PixelFormat::RGBA_8888;
2153 const auto decorBuffer = allocate(static_cast<::android::PixelFormat>(format));
2154 ASSERT_NE(nullptr, decorBuffer);
2155 if (::android::OK != decorBuffer->initCheck()) {
2156 if (support) {
2157 FAIL() << "Device advertised display decoration support with format "
2158 << aidl::android::hardware::graphics::common::toString(format)
2159 << " but failed to allocate it!";
2160 } else {
2161 FAIL() << "Device advertised NO display decoration support, but it should "
2162 << "still be able to allocate "
2163 << aidl::android::hardware::graphics::common::toString(format);
2164 }
2165 }
2166
Midas Chien7d55d422022-06-07 02:32:28 +08002167 configureLayer(display, layer, Composition::DISPLAY_DECORATION, display.getFrameRect(),
2168 display.getCrop());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002169 auto& writer = getWriter(display.getDisplayId());
2170 writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, decorBuffer->handle,
2171 /*acquireFence*/ -1);
ramindanicdcfcaf2023-11-09 10:00:10 -08002172 writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp,
2173 VtsComposerClient::kNoFrameIntervalNs);
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002174 execute();
2175 if (support) {
2176 ASSERT_TRUE(mReader.takeErrors().empty());
2177 } else {
2178 const auto errors = mReader.takeErrors();
2179 ASSERT_EQ(1, errors.size());
Leon Scroggins III6455e792022-02-24 12:18:58 -05002180 EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, errors[0].errorCode);
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002181 }
2182 }
2183}
2184
ramindani431aad42022-02-01 21:44:29 +00002185TEST_P(GraphicsComposerAidlCommandTest, SetLayerDataspace) {
2186 const auto& [layerStatus, layer] =
2187 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2188 EXPECT_TRUE(layerStatus.isOk());
2189
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002190 auto& writer = getWriter(getPrimaryDisplayId());
2191 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
ramindani431aad42022-02-01 21:44:29 +00002192 execute();
2193}
2194
2195TEST_P(GraphicsComposerAidlCommandTest, SetLayerDisplayFrame) {
2196 const auto& [layerStatus, layer] =
2197 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2198 EXPECT_TRUE(layerStatus.isOk());
2199
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002200 auto& writer = getWriter(getPrimaryDisplayId());
2201 writer.setLayerDisplayFrame(getPrimaryDisplayId(), layer, Rect{0, 0, 1, 1});
ramindani431aad42022-02-01 21:44:29 +00002202 execute();
2203}
2204
2205TEST_P(GraphicsComposerAidlCommandTest, SetLayerPlaneAlpha) {
2206 const auto& [layerStatus, layer] =
2207 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2208 EXPECT_TRUE(layerStatus.isOk());
2209
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002210 auto& writer = getWriter(getPrimaryDisplayId());
2211 writer.setLayerPlaneAlpha(getPrimaryDisplayId(), layer, /*alpha*/ 0.0f);
ramindani431aad42022-02-01 21:44:29 +00002212 execute();
2213 ASSERT_TRUE(mReader.takeErrors().empty());
2214
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002215 writer.setLayerPlaneAlpha(getPrimaryDisplayId(), layer, /*alpha*/ 1.0f);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002216 execute();
2217 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002218}
2219
ramindani431aad42022-02-01 21:44:29 +00002220TEST_P(GraphicsComposerAidlCommandTest, SetLayerSidebandStream) {
Jason Macnak325e8232022-01-24 14:48:55 -08002221 if (!hasCapability(Capability::SIDEBAND_STREAM)) {
ramindanidcfe3a82021-11-29 17:00:31 +00002222 GTEST_SUCCEED() << "no sideband stream support";
2223 return;
2224 }
2225
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002226 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00002227 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00002228 ASSERT_NE(nullptr, handle);
2229
ramindani431aad42022-02-01 21:44:29 +00002230 const auto& [layerStatus, layer] =
2231 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2232 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002233
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002234 auto& writer = getWriter(getPrimaryDisplayId());
2235 writer.setLayerSidebandStream(getPrimaryDisplayId(), layer, handle);
ramindanidcfe3a82021-11-29 17:00:31 +00002236 execute();
2237}
2238
ramindani431aad42022-02-01 21:44:29 +00002239TEST_P(GraphicsComposerAidlCommandTest, SetLayerSourceCrop) {
2240 const auto& [layerStatus, layer] =
2241 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2242 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002243
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002244 auto& writer = getWriter(getPrimaryDisplayId());
2245 writer.setLayerSourceCrop(getPrimaryDisplayId(), layer, FRect{0.0f, 0.0f, 1.0f, 1.0f});
ramindanidcfe3a82021-11-29 17:00:31 +00002246 execute();
2247}
2248
ramindani431aad42022-02-01 21:44:29 +00002249TEST_P(GraphicsComposerAidlCommandTest, SetLayerTransform) {
2250 const auto& [layerStatus, layer] =
2251 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2252 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002253
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002254 auto& writer = getWriter(getPrimaryDisplayId());
2255 writer.setLayerTransform(getPrimaryDisplayId(), layer, static_cast<Transform>(0));
ramindanidcfe3a82021-11-29 17:00:31 +00002256 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002257 ASSERT_TRUE(mReader.takeErrors().empty());
2258
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002259 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::FLIP_H);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002260 execute();
2261 ASSERT_TRUE(mReader.takeErrors().empty());
2262
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002263 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::FLIP_V);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002264 execute();
2265 ASSERT_TRUE(mReader.takeErrors().empty());
2266
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002267 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_90);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002268 execute();
2269 ASSERT_TRUE(mReader.takeErrors().empty());
2270
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002271 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_180);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002272 execute();
2273 ASSERT_TRUE(mReader.takeErrors().empty());
2274
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002275 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_270);
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_H) |
2281 static_cast<int>(Transform::ROT_90)));
Ady Abraham3192f3d2021-12-03 16:08:56 -08002282 execute();
2283 ASSERT_TRUE(mReader.takeErrors().empty());
2284
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002285 writer.setLayerTransform(getPrimaryDisplayId(), layer,
2286 static_cast<Transform>(static_cast<int>(Transform::FLIP_V) |
2287 static_cast<int>(Transform::ROT_90)));
Ady Abraham3192f3d2021-12-03 16:08:56 -08002288 execute();
2289 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002290}
2291
ramindani431aad42022-02-01 21:44:29 +00002292TEST_P(GraphicsComposerAidlCommandTest, SetLayerVisibleRegion) {
2293 const auto& [layerStatus, layer] =
2294 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2295 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002296
2297 Rect empty{0, 0, 0, 0};
2298 Rect unit{0, 0, 1, 1};
2299
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002300 auto& writer = getWriter(getPrimaryDisplayId());
2301 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
ramindanidcfe3a82021-11-29 17:00:31 +00002302 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002303 ASSERT_TRUE(mReader.takeErrors().empty());
2304
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002305 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
Ady Abraham3192f3d2021-12-03 16:08:56 -08002306 execute();
2307 ASSERT_TRUE(mReader.takeErrors().empty());
2308
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002309 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>());
Ady Abraham3192f3d2021-12-03 16:08:56 -08002310 execute();
2311 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002312}
2313
ramindani431aad42022-02-01 21:44:29 +00002314TEST_P(GraphicsComposerAidlCommandTest, SetLayerZOrder) {
2315 const auto& [layerStatus, layer] =
2316 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2317 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002318
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002319 auto& writer = getWriter(getPrimaryDisplayId());
2320 writer.setLayerZOrder(getPrimaryDisplayId(), layer, /*z*/ 10);
ramindanidcfe3a82021-11-29 17:00:31 +00002321 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002322 ASSERT_TRUE(mReader.takeErrors().empty());
2323
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002324 writer.setLayerZOrder(getPrimaryDisplayId(), layer, /*z*/ 0);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002325 execute();
2326 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002327}
2328
ramindani431aad42022-02-01 21:44:29 +00002329TEST_P(GraphicsComposerAidlCommandTest, SetLayerPerFrameMetadata) {
2330 const auto& [layerStatus, layer] =
2331 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2332 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002333
ramindanidcfe3a82021-11-29 17:00:31 +00002334 /**
2335 * DISPLAY_P3 is a color space that uses the DCI_P3 primaries,
2336 * the D65 white point and the SRGB transfer functions.
2337 * Rendering Intent: Colorimetric
2338 * Primaries:
2339 * x y
2340 * green 0.265 0.690
2341 * blue 0.150 0.060
2342 * red 0.680 0.320
2343 * white (D65) 0.3127 0.3290
2344 */
2345
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002346 auto& writer = getWriter(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00002347 std::vector<PerFrameMetadata> aidlMetadata;
2348 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X, 0.680f});
2349 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y, 0.320f});
2350 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X, 0.265f});
2351 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y, 0.690f});
2352 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X, 0.150f});
2353 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y, 0.060f});
2354 aidlMetadata.push_back({PerFrameMetadataKey::WHITE_POINT_X, 0.3127f});
2355 aidlMetadata.push_back({PerFrameMetadataKey::WHITE_POINT_Y, 0.3290f});
2356 aidlMetadata.push_back({PerFrameMetadataKey::MAX_LUMINANCE, 100.0f});
2357 aidlMetadata.push_back({PerFrameMetadataKey::MIN_LUMINANCE, 0.1f});
2358 aidlMetadata.push_back({PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL, 78.0});
2359 aidlMetadata.push_back({PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL, 62.0});
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002360 writer.setLayerPerFrameMetadata(getPrimaryDisplayId(), layer, aidlMetadata);
ramindanidcfe3a82021-11-29 17:00:31 +00002361 execute();
2362
Ady Abraham3192f3d2021-12-03 16:08:56 -08002363 const auto errors = mReader.takeErrors();
2364 if (errors.size() == 1 && errors[0].errorCode == EX_UNSUPPORTED_OPERATION) {
ramindanidcfe3a82021-11-29 17:00:31 +00002365 GTEST_SUCCEED() << "SetLayerPerFrameMetadata is not supported";
ramindani431aad42022-02-01 21:44:29 +00002366 EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002367 return;
2368 }
2369
ramindani431aad42022-02-01 21:44:29 +00002370 EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002371}
2372
Alec Mourib1f16722022-02-07 13:03:44 -08002373TEST_P(GraphicsComposerAidlCommandTest, setLayerBrightness) {
ramindani431aad42022-02-01 21:44:29 +00002374 const auto& [layerStatus, layer] =
2375 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
Alec Mouri95e490b2022-01-06 13:46:58 -08002376
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002377 auto& writer = getWriter(getPrimaryDisplayId());
2378 writer.setLayerBrightness(getPrimaryDisplayId(), layer, 0.2f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002379 execute();
2380 ASSERT_TRUE(mReader.takeErrors().empty());
2381
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002382 writer.setLayerBrightness(getPrimaryDisplayId(), layer, 1.f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002383 execute();
2384 ASSERT_TRUE(mReader.takeErrors().empty());
2385
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002386 writer.setLayerBrightness(getPrimaryDisplayId(), layer, 0.f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002387 execute();
2388 ASSERT_TRUE(mReader.takeErrors().empty());
2389
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002390 writer.setLayerBrightness(getPrimaryDisplayId(), layer, -1.f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002391 execute();
Alec Mourib1f16722022-02-07 13:03:44 -08002392 {
2393 const auto errors = mReader.takeErrors();
2394 ASSERT_EQ(1, errors.size());
2395 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
2396 }
2397
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002398 writer.setLayerBrightness(getPrimaryDisplayId(), layer, std::nanf(""));
Alec Mourib1f16722022-02-07 13:03:44 -08002399 execute();
2400 {
2401 const auto errors = mReader.takeErrors();
2402 ASSERT_EQ(1, errors.size());
2403 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
2404 }
Alec Mouri95e490b2022-01-06 13:46:58 -08002405}
2406
ramindani431aad42022-02-01 21:44:29 +00002407TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints) {
ramindanidcfe3a82021-11-29 17:00:31 +00002408 Test_setActiveConfigWithConstraints({.delayForChange = 0, .refreshMiss = false});
2409}
2410
ramindani431aad42022-02-01 21:44:29 +00002411TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_Delayed) {
ramindanidcfe3a82021-11-29 17:00:31 +00002412 Test_setActiveConfigWithConstraints({.delayForChange = 300'000'000, // 300ms
2413 .refreshMiss = false});
2414}
2415
ramindani431aad42022-02-01 21:44:29 +00002416TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_MissRefresh) {
ramindanidcfe3a82021-11-29 17:00:31 +00002417 Test_setActiveConfigWithConstraints({.delayForChange = 0, .refreshMiss = true});
2418}
2419
ramindani431aad42022-02-01 21:44:29 +00002420TEST_P(GraphicsComposerAidlCommandTest, GetDisplayVsyncPeriod) {
ramindanidcfe3a82021-11-29 17:00:31 +00002421 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +00002422 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
2423 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002424
ramindani431aad42022-02-01 21:44:29 +00002425 for (int32_t config : configs) {
2426 int32_t expectedVsyncPeriodNanos = display.getDisplayConfig(config).vsyncPeriod;
2427
ramindanidcfe3a82021-11-29 17:00:31 +00002428 VsyncPeriodChangeConstraints constraints;
2429
2430 constraints.desiredTimeNanos = systemTime();
2431 constraints.seamlessRequired = false;
ramindani431aad42022-02-01 21:44:29 +00002432
2433 const auto& [timelineStatus, timeline] =
2434 mComposerClient->setActiveConfigWithConstraints(&display, config, constraints);
2435 EXPECT_TRUE(timelineStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002436
2437 if (timeline.refreshRequired) {
2438 sendRefreshFrame(display, &timeline);
2439 }
ramindani431aad42022-02-01 21:44:29 +00002440 waitForVsyncPeriodChange(display.getDisplayId(), timeline, constraints.desiredTimeNanos,
2441 /*odPeriodNanos*/ 0, expectedVsyncPeriodNanos);
ramindanidcfe3a82021-11-29 17:00:31 +00002442
2443 int32_t vsyncPeriodNanos;
2444 int retryCount = 100;
2445 do {
2446 std::this_thread::sleep_for(10ms);
ramindani431aad42022-02-01 21:44:29 +00002447 const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanosValue] =
2448 mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
2449
2450 EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
2451 vsyncPeriodNanos = vsyncPeriodNanosValue;
ramindanidcfe3a82021-11-29 17:00:31 +00002452 --retryCount;
2453 } while (vsyncPeriodNanos != expectedVsyncPeriodNanos && retryCount > 0);
2454
2455 EXPECT_EQ(vsyncPeriodNanos, expectedVsyncPeriodNanos);
2456
2457 // Make sure that the vsync period stays the same if the active config is not
2458 // changed.
2459 auto timeout = 1ms;
2460 for (int i = 0; i < 10; i++) {
2461 std::this_thread::sleep_for(timeout);
2462 timeout *= 2;
2463 vsyncPeriodNanos = 0;
ramindani431aad42022-02-01 21:44:29 +00002464 const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanosValue] =
2465 mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
2466
2467 EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
2468 vsyncPeriodNanos = vsyncPeriodNanosValue;
ramindanidcfe3a82021-11-29 17:00:31 +00002469 EXPECT_EQ(vsyncPeriodNanos, expectedVsyncPeriodNanos);
2470 }
2471 }
2472 }
2473}
2474
ramindani431aad42022-02-01 21:44:29 +00002475TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_SeamlessNotAllowed) {
ramindanidcfe3a82021-11-29 17:00:31 +00002476 VsyncPeriodChangeConstraints constraints;
ramindanidcfe3a82021-11-29 17:00:31 +00002477 constraints.seamlessRequired = true;
2478 constraints.desiredTimeNanos = systemTime();
2479
2480 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +00002481 forEachTwoConfigs(display.getDisplayId(), [&](int32_t config1, int32_t config2) {
2482 int32_t configGroup1 = display.getDisplayConfig(config1).configGroup;
2483 int32_t configGroup2 = display.getDisplayConfig(config2).configGroup;
ramindanidcfe3a82021-11-29 17:00:31 +00002484 if (configGroup1 != configGroup2) {
ramindani431aad42022-02-01 21:44:29 +00002485 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002486 sendRefreshFrame(display, nullptr);
ramindani431aad42022-02-01 21:44:29 +00002487 const auto& [status, _] = mComposerClient->setActiveConfigWithConstraints(
2488 &display, config2, constraints);
2489 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00002490 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(
2491 status, IComposerClient::EX_SEAMLESS_NOT_ALLOWED));
ramindanidcfe3a82021-11-29 17:00:31 +00002492 }
2493 });
2494 }
2495}
2496
ramindani431aad42022-02-01 21:44:29 +00002497TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_NoTimestamp) {
2498 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ std::nullopt));
Ady Abraham72c5b502021-12-10 17:23:39 -08002499}
2500
ramindani431aad42022-02-01 21:44:29 +00002501TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_0) {
2502 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ 0));
Ady Abraham72c5b502021-12-10 17:23:39 -08002503}
2504
ramindani431aad42022-02-01 21:44:29 +00002505TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_5) {
2506 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ 5));
Ady Abraham72c5b502021-12-10 17:23:39 -08002507}
2508
ramindani431aad42022-02-01 21:44:29 +00002509TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Unsupported) {
2510 const bool hasDisplayIdleTimerSupport =
2511 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002512 if (!hasDisplayIdleTimerSupport) {
ramindani431aad42022-02-01 21:44:29 +00002513 const auto& status =
2514 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0);
2515 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00002516 EXPECT_NO_FATAL_FAILURE(
2517 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
Midas Chiena0b56bd2022-01-13 23:27:33 +08002518 }
2519}
2520
ramindani431aad42022-02-01 21:44:29 +00002521TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_BadParameter) {
2522 const bool hasDisplayIdleTimerSupport =
2523 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002524 if (!hasDisplayIdleTimerSupport) {
2525 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2526 return;
2527 }
2528
ramindani431aad42022-02-01 21:44:29 +00002529 const auto& status =
2530 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ -1);
2531 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00002532 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
Midas Chiena0b56bd2022-01-13 23:27:33 +08002533}
2534
ramindani431aad42022-02-01 21:44:29 +00002535TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Disable) {
2536 const bool hasDisplayIdleTimerSupport =
2537 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002538 if (!hasDisplayIdleTimerSupport) {
2539 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2540 return;
2541 }
2542
ramindani431aad42022-02-01 21:44:29 +00002543 EXPECT_TRUE(mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002544 std::this_thread::sleep_for(1s);
ramindani431aad42022-02-01 21:44:29 +00002545 EXPECT_EQ(0, mComposerClient->getVsyncIdleCount());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002546}
2547
ramindani431aad42022-02-01 21:44:29 +00002548TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Timeout_2) {
2549 const bool hasDisplayIdleTimerSupport =
2550 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002551 if (!hasDisplayIdleTimerSupport) {
2552 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2553 return;
2554 }
2555
ramindani431aad42022-02-01 21:44:29 +00002556 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
2557 EXPECT_TRUE(mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002558
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002559 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002560 ASSERT_NE(nullptr, buffer->handle);
2561
2562 const auto layer = createOnScreenLayer();
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002563 auto& writer = getWriter(getPrimaryDisplayId());
2564 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer->handle,
2565 /*acquireFence*/ -1);
ramindani431aad42022-02-01 21:44:29 +00002566 int32_t vsyncIdleCount = mComposerClient->getVsyncIdleCount();
Midas Chiena0b56bd2022-01-13 23:27:33 +08002567 auto earlyVsyncIdleTime = systemTime() + std::chrono::nanoseconds(2s).count();
ramindani431aad42022-02-01 21:44:29 +00002568 EXPECT_TRUE(
2569 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 2000).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002570
2571 const sp<::android::Fence> presentFence =
ramindani431aad42022-02-01 21:44:29 +00002572 presentAndGetFence(ComposerClientWriter::kNoTimestamp);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002573 presentFence->waitForever(LOG_TAG);
2574
2575 std::this_thread::sleep_for(3s);
ramindani431aad42022-02-01 21:44:29 +00002576 if (vsyncIdleCount < mComposerClient->getVsyncIdleCount()) {
2577 EXPECT_GE(mComposerClient->getVsyncIdleTime(), earlyVsyncIdleTime);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002578 }
2579
ramindani431aad42022-02-01 21:44:29 +00002580 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002581}
2582
ramindani12423f52023-06-14 20:04:51 -07002583class GraphicsComposerAidlCommandV2Test : public GraphicsComposerAidlCommandTest {
2584 protected:
2585 void SetUp() override {
2586 GraphicsComposerAidlTest::SetUp();
2587 if (getInterfaceVersion() <= 1) {
2588 GTEST_SKIP() << "Device interface version is expected to be >= 2";
2589 }
ramindani17c71102023-03-20 10:51:14 -07002590 }
ramindani12423f52023-06-14 20:04:51 -07002591};
2592/**
2593 * Test Capability::SKIP_VALIDATE
2594 *
2595 * Capability::SKIP_VALIDATE has been deprecated and should not be enabled.
2596 */
2597TEST_P(GraphicsComposerAidlCommandV2Test, SkipValidateDeprecatedTest) {
Leon Scroggins III79d7ae82023-10-11 16:03:52 -04002598#pragma clang diagnostic push
2599#pragma clang diagnostic ignored "-Wdeprecated-declarations"
ramindani12423f52023-06-14 20:04:51 -07002600 ASSERT_FALSE(hasCapability(Capability::SKIP_VALIDATE))
2601 << "Found Capability::SKIP_VALIDATE capability.";
Leon Scroggins III79d7ae82023-10-11 16:03:52 -04002602#pragma clang diagnostic pop
ramindani12423f52023-06-14 20:04:51 -07002603}
2604
2605TEST_P(GraphicsComposerAidlCommandV2Test, SetLayerBufferSlotsToClear) {
2606 // Older HAL versions use a backwards compatible way of clearing buffer slots
2607 // HAL at version 1 or lower does not have LayerCommand::bufferSlotsToClear
2608 const auto& [layerStatus, layer] =
2609 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2610 EXPECT_TRUE(layerStatus.isOk());
2611 auto& writer = getWriter(getPrimaryDisplayId());
2612
2613 // setup 3 buffers in the buffer cache, with the last buffer being active
2614 // then emulate the Android platform code that clears all 3 buffer slots
2615
2616 const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2617 ASSERT_NE(nullptr, buffer1);
2618 const auto handle1 = buffer1->handle;
2619 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle1, /*acquireFence*/ -1);
2620 execute();
2621 ASSERT_TRUE(mReader.takeErrors().empty());
2622
2623 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2624 ASSERT_NE(nullptr, buffer2);
2625 const auto handle2 = buffer2->handle;
2626 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 1, handle2, /*acquireFence*/ -1);
2627 execute();
2628 ASSERT_TRUE(mReader.takeErrors().empty());
2629
2630 const auto buffer3 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2631 ASSERT_NE(nullptr, buffer3);
2632 const auto handle3 = buffer3->handle;
2633 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 2, handle3, /*acquireFence*/ -1);
2634 execute();
2635 ASSERT_TRUE(mReader.takeErrors().empty());
2636
2637 // Ensure we can clear all 3 buffer slots, even the active buffer - it is assumed the
2638 // current active buffer's slot will be cleared, but still remain the active buffer and no
2639 // errors will occur.
2640 writer.setLayerBufferSlotsToClear(getPrimaryDisplayId(), layer, {0, 1, 2});
2641 execute();
2642 ASSERT_TRUE(mReader.takeErrors().empty());
2643}
2644
2645TEST_P(GraphicsComposerAidlCommandV2Test, SetRefreshRateChangedCallbackDebug_Unsupported) {
ramindani9dd8c482023-02-21 18:07:56 -08002646 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2647 auto status = mComposerClient->setRefreshRateChangedCallbackDebugEnabled(
2648 getPrimaryDisplayId(), /*enabled*/ true);
2649 EXPECT_FALSE(status.isOk());
2650 EXPECT_NO_FATAL_FAILURE(
2651 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
2652
2653 status = mComposerClient->setRefreshRateChangedCallbackDebugEnabled(getPrimaryDisplayId(),
2654 /*enabled*/ false);
2655 EXPECT_FALSE(status.isOk());
2656 EXPECT_NO_FATAL_FAILURE(
2657 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
2658 }
2659}
2660
ramindani12423f52023-06-14 20:04:51 -07002661TEST_P(GraphicsComposerAidlCommandV2Test, SetRefreshRateChangedCallbackDebug_Enabled) {
ramindani9dd8c482023-02-21 18:07:56 -08002662 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2663 GTEST_SUCCEED() << "Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG is not supported";
2664 return;
2665 }
2666
2667 const auto displayId = getPrimaryDisplayId();
2668 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2669 // Enable the callback
2670 ASSERT_TRUE(mComposerClient
2671 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2672 /*enabled*/ true)
2673 .isOk());
2674 std::this_thread::sleep_for(100ms);
2675
ramindani91518892023-03-03 16:55:09 +00002676 const auto displayFilter = [displayId](auto refreshRateChangedDebugData) {
2677 return displayId == refreshRateChangedDebugData.display;
2678 };
ramindani9dd8c482023-02-21 18:07:56 -08002679
2680 // Check that we immediately got a callback
ramindani91518892023-03-03 16:55:09 +00002681 EXPECT_TRUE(checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter));
ramindani9dd8c482023-02-21 18:07:56 -08002682
2683 ASSERT_TRUE(mComposerClient
2684 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2685 /*enabled*/ false)
2686 .isOk());
2687}
2688
ramindani12423f52023-06-14 20:04:51 -07002689TEST_P(GraphicsComposerAidlCommandV2Test,
ramindani9dd8c482023-02-21 18:07:56 -08002690 SetRefreshRateChangedCallbackDebugEnabled_noCallbackWhenIdle) {
2691 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2692 GTEST_SUCCEED() << "Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG is not supported";
2693 return;
2694 }
2695
2696 auto display = getEditablePrimaryDisplay();
2697 const auto displayId = display.getDisplayId();
2698
2699 if (!hasDisplayCapability(displayId, DisplayCapability::DISPLAY_IDLE_TIMER)) {
2700 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2701 return;
2702 }
2703
2704 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2705 EXPECT_TRUE(mComposerClient->setPeakRefreshRateConfig(&display).isOk());
2706
2707 ASSERT_TRUE(mComposerClient->setIdleTimerEnabled(displayId, /*timeoutMs*/ 500).isOk());
2708 // Enable the callback
2709 ASSERT_TRUE(mComposerClient
2710 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2711 /*enabled*/ true)
2712 .isOk());
2713
ramindani91518892023-03-03 16:55:09 +00002714 const auto displayFilter = [displayId](auto refreshRateChangedDebugData) {
2715 return displayId == refreshRateChangedDebugData.display;
2716 };
ramindani9dd8c482023-02-21 18:07:56 -08002717
2718 int retryCount = 3;
2719 do {
2720 // Wait for 1s so that we enter the idle state
2721 std::this_thread::sleep_for(1s);
ramindani91518892023-03-03 16:55:09 +00002722 if (!checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter)) {
ramindani9dd8c482023-02-21 18:07:56 -08002723 // DID NOT receive a callback, we are in the idle state.
2724 break;
2725 }
2726 } while (--retryCount > 0);
2727
2728 if (retryCount == 0) {
2729 GTEST_SUCCEED() << "Unable to enter the idle mode";
2730 return;
2731 }
2732
2733 // Send the REFRESH_RATE_INDICATOR update
2734 ASSERT_NO_FATAL_FAILURE(
2735 sendBufferUpdate(createOnScreenLayer(Composition::REFRESH_RATE_INDICATOR)));
2736 std::this_thread::sleep_for(1s);
ramindani91518892023-03-03 16:55:09 +00002737 EXPECT_FALSE(checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter))
ramindani9dd8c482023-02-21 18:07:56 -08002738 << "A callback should not be received for REFRESH_RATE_INDICATOR";
2739
2740 EXPECT_TRUE(mComposerClient
2741 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2742 /*enabled*/ false)
2743 .isOk());
2744}
2745
ramindani12423f52023-06-14 20:04:51 -07002746TEST_P(GraphicsComposerAidlCommandV2Test,
ramindani9dd8c482023-02-21 18:07:56 -08002747 SetRefreshRateChangedCallbackDebugEnabled_SetActiveConfigWithConstraints) {
2748 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2749 GTEST_SUCCEED() << "Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG is not supported";
2750 return;
2751 }
2752
2753 VsyncPeriodChangeConstraints constraints;
2754 constraints.seamlessRequired = false;
2755 constraints.desiredTimeNanos = systemTime();
2756
2757 for (VtsDisplay& display : mDisplays) {
2758 const auto displayId = display.getDisplayId();
2759 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2760
2761 // Enable the callback
2762 ASSERT_TRUE(mComposerClient
2763 ->setRefreshRateChangedCallbackDebugEnabled(displayId, /*enabled*/ true)
2764 .isOk());
2765
2766 forEachTwoConfigs(displayId, [&](int32_t config1, int32_t config2) {
2767 const int32_t vsyncPeriod1 = display.getDisplayConfig(config1).vsyncPeriod;
2768 const int32_t vsyncPeriod2 = display.getDisplayConfig(config2).vsyncPeriod;
2769
2770 if (vsyncPeriod1 == vsyncPeriod2) {
2771 return; // continue
2772 }
2773
2774 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
2775 sendRefreshFrame(display, nullptr);
2776
2777 const auto& [status, timeline] =
2778 mComposerClient->setActiveConfigWithConstraints(&display, config2, constraints);
2779 EXPECT_TRUE(status.isOk());
2780
2781 if (timeline.refreshRequired) {
2782 sendRefreshFrame(display, &timeline);
2783 }
2784
ramindani91518892023-03-03 16:55:09 +00002785 const auto callbackFilter = [displayId,
2786 vsyncPeriod2](auto refreshRateChangedDebugData) {
2787 constexpr int kVsyncThreshold = 1000;
2788 return displayId == refreshRateChangedDebugData.display &&
2789 std::abs(vsyncPeriod2 - refreshRateChangedDebugData.vsyncPeriodNanos) <=
2790 kVsyncThreshold;
2791 };
ramindani9dd8c482023-02-21 18:07:56 -08002792
2793 int retryCount = 3;
2794 do {
2795 std::this_thread::sleep_for(100ms);
ramindani91518892023-03-03 16:55:09 +00002796 if (checkIfCallbackRefreshRateChangedDebugEnabledReceived(callbackFilter)) {
ramindani9dd8c482023-02-21 18:07:56 -08002797 GTEST_SUCCEED() << "Received a callback successfully";
2798 break;
2799 }
2800 } while (--retryCount > 0);
2801
2802 if (retryCount == 0) {
2803 GTEST_FAIL() << "failed to get a callback for the display " << displayId
2804 << " with config " << config2;
2805 }
2806 });
2807
2808 EXPECT_TRUE(
2809 mComposerClient
2810 ->setRefreshRateChangedCallbackDebugEnabled(displayId, /*enabled*/ false)
2811 .isOk());
2812 }
2813}
2814
Joen Chene0a962c2023-08-28 09:49:11 +00002815TEST_P(GraphicsComposerAidlCommandTest, MultiThreadedPresent) {
2816 std::vector<VtsDisplay*> displays;
2817 for (auto& display : mDisplays) {
2818 if (hasDisplayCapability(display.getDisplayId(),
2819 DisplayCapability::MULTI_THREADED_PRESENT)) {
2820 displays.push_back(&display);
2821 }
2822 }
2823
2824 const size_t numDisplays = displays.size();
2825 if (numDisplays <= 1u) {
2826 GTEST_SKIP();
2827 }
2828
2829 // When multi-threaded, use a reader per display. As with mWriters, this mutex
2830 // guards access to the map.
2831 std::mutex readersMutex;
2832 std::unordered_map<int64_t, ComposerClientReader> readers;
2833 std::vector<std::thread> threads;
2834 threads.reserve(numDisplays);
2835
2836 // Each display will have a layer to present. This maps from the display to
2837 // the layer, so we can properly destroy each layer at the end.
2838 std::unordered_map<int64_t, int64_t> layers;
2839
2840 for (auto* const display : displays) {
2841 const int64_t displayId = display->getDisplayId();
2842
2843 // Ensure that all writers and readers have been added to their respective
2844 // maps initially, so that the following loop never modifies the maps. The
2845 // maps are accessed from different threads, and if the maps were modified,
2846 // this would invalidate their iterators, and therefore references to the
2847 // writers and readers.
2848 auto& writer = getWriter(displayId);
2849 {
2850 std::lock_guard guard{readersMutex};
2851 readers.try_emplace(displayId, displayId);
2852 }
2853
2854 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2855
2856 const auto& [status, layer] = mComposerClient->createLayer(displayId, kBufferSlotCount);
2857 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2858 ASSERT_NE(nullptr, buffer);
2859 ASSERT_EQ(::android::OK, buffer->initCheck());
2860 ASSERT_NE(nullptr, buffer->handle);
2861
2862 configureLayer(*display, layer, Composition::DEVICE, display->getFrameRect(),
2863 display->getCrop());
2864 writer.setLayerBuffer(displayId, layer, /*slot*/ 0, buffer->handle,
2865 /*acquireFence*/ -1);
2866 writer.setLayerDataspace(displayId, layer, common::Dataspace::UNKNOWN);
2867 layers.try_emplace(displayId, layer);
2868 }
2869
2870 for (auto* const display : displays) {
2871 const int64_t displayId = display->getDisplayId();
2872 auto& writer = getWriter(displayId);
2873 std::unique_lock lock{readersMutex};
2874 auto& reader = readers.at(displayId);
2875 lock.unlock();
2876
ramindanicdcfcaf2023-11-09 10:00:10 -08002877 writer.validateDisplay(displayId, ComposerClientWriter::kNoTimestamp,
2878 VtsComposerClient::kNoFrameIntervalNs);
Joen Chene0a962c2023-08-28 09:49:11 +00002879 execute(writer, reader);
2880
2881 threads.emplace_back([this, displayId, &readers, &readersMutex]() {
2882 auto& writer = getWriter(displayId);
2883 std::unique_lock lock{readersMutex};
2884 ComposerClientReader& reader = readers.at(displayId);
2885 lock.unlock();
2886
2887 writer.presentDisplay(displayId);
2888 execute(writer, reader);
2889 ASSERT_TRUE(reader.takeErrors().empty());
2890
2891 auto presentFence = reader.takePresentFence(displayId);
2892 // take ownership
2893 const int fenceOwner = presentFence.get();
2894 *presentFence.getR() = -1;
2895 EXPECT_NE(-1, fenceOwner);
2896 const auto presentFence2 = sp<::android::Fence>::make(fenceOwner);
2897 presentFence2->waitForever(LOG_TAG);
2898 });
2899 }
2900
2901 for (auto& thread : threads) {
2902 thread.join();
2903 }
2904
2905 for (auto& [displayId, layer] : layers) {
2906 EXPECT_TRUE(mComposerClient->destroyLayer(displayId, layer).isOk());
2907 }
2908
2909 std::lock_guard guard{readersMutex};
2910 for (auto& [displayId, reader] : readers) {
2911 ASSERT_TRUE(reader.takeErrors().empty());
2912 ASSERT_TRUE(reader.takeChangedCompositionTypes(displayId).empty());
2913 }
2914}
2915
Manali Bhutiyani38565cc2023-11-11 06:16:24 +00002916class GraphicsComposerAidlBatchedCommandTest : public GraphicsComposerAidlCommandTest {
2917 protected:
2918 void SetUp() override {
2919 GraphicsComposerAidlCommandTest::SetUp();
2920 if (getInterfaceVersion() <= 2) {
2921 GTEST_SKIP() << "Device interface version is expected to be >= 3";
2922 }
2923 }
2924 void TearDown() override {
2925 const auto errors = mReader.takeErrors();
2926 ASSERT_TRUE(mReader.takeErrors().empty());
2927 ASSERT_NO_FATAL_FAILURE(GraphicsComposerAidlTest::TearDown());
2928 }
2929};
2930
2931TEST_P(GraphicsComposerAidlBatchedCommandTest, CreateBatchedCommand) {
2932 auto& writer = getWriter(getPrimaryDisplayId());
2933 int64_t layer = 5;
2934 writer.setLayerLifecycleBatchCommandType(getPrimaryDisplayId(), layer,
2935 LayerLifecycleBatchCommandType::CREATE);
2936 writer.setNewBufferSlotCount(getPrimaryDisplayId(), layer, 1);
2937 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
2938 VtsComposerClient::kNoFrameIntervalNs);
2939 execute();
2940 ASSERT_TRUE(mReader.takeErrors().empty());
2941}
2942
2943TEST_P(GraphicsComposerAidlBatchedCommandTest, DestroyBatchedCommand) {
2944 auto& writer = getWriter(getPrimaryDisplayId());
2945 int64_t layer = 5;
2946 writer.setLayerLifecycleBatchCommandType(getPrimaryDisplayId(), layer,
2947 LayerLifecycleBatchCommandType::CREATE);
2948 writer.setNewBufferSlotCount(getPrimaryDisplayId(), layer, 1);
2949 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
2950 VtsComposerClient::kNoFrameIntervalNs);
2951 execute();
2952 ASSERT_TRUE(mReader.takeErrors().empty());
2953 writer.setLayerLifecycleBatchCommandType(getPrimaryDisplayId(), layer,
2954 LayerLifecycleBatchCommandType::DESTROY);
2955 layer++;
2956 writer.setLayerLifecycleBatchCommandType(getPrimaryDisplayId(), layer,
2957 LayerLifecycleBatchCommandType::CREATE);
2958 writer.setNewBufferSlotCount(getPrimaryDisplayId(), layer, 1);
2959
2960 execute();
2961 ASSERT_TRUE(mReader.takeErrors().empty());
2962}
2963
2964TEST_P(GraphicsComposerAidlBatchedCommandTest, NoCreateDestroyBatchedCommandIncorrectLayer) {
2965 auto& writer = getWriter(getPrimaryDisplayId());
2966 int64_t layer = 5;
2967 writer.setLayerLifecycleBatchCommandType(getPrimaryDisplayId(), layer,
2968 LayerLifecycleBatchCommandType::DESTROY);
2969 execute();
2970 const auto errors = mReader.takeErrors();
2971 ASSERT_TRUE(errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_BAD_LAYER);
2972}
2973
2974GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlBatchedCommandTest);
2975INSTANTIATE_TEST_SUITE_P(
2976 PerInstance, GraphicsComposerAidlBatchedCommandTest,
2977 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
2978 ::android::PrintInstanceNameToString);
ramindanidcfe3a82021-11-29 17:00:31 +00002979GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlCommandTest);
2980INSTANTIATE_TEST_SUITE_P(
2981 PerInstance, GraphicsComposerAidlCommandTest,
2982 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
2983 ::android::PrintInstanceNameToString);
ramindanid32ae8e2021-10-01 18:48:39 +00002984GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlTest);
2985INSTANTIATE_TEST_SUITE_P(
2986 PerInstance, GraphicsComposerAidlTest,
2987 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
2988 ::android::PrintInstanceNameToString);
ramindani12423f52023-06-14 20:04:51 -07002989GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlV2Test);
2990INSTANTIATE_TEST_SUITE_P(
2991 PerInstance, GraphicsComposerAidlV2Test,
2992 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
2993 ::android::PrintInstanceNameToString);
ramindani02fe4772023-06-30 18:04:41 -07002994GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlV3Test);
2995INSTANTIATE_TEST_SUITE_P(
2996 PerInstance, GraphicsComposerAidlV3Test,
2997 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
2998 ::android::PrintInstanceNameToString);
ramindani12423f52023-06-14 20:04:51 -07002999GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlCommandV2Test);
3000INSTANTIATE_TEST_SUITE_P(
3001 PerInstance, GraphicsComposerAidlCommandV2Test,
3002 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
3003 ::android::PrintInstanceNameToString);
3004
ramindanid32ae8e2021-10-01 18:48:39 +00003005} // namespace aidl::android::hardware::graphics::composer3::vts
3006
3007int main(int argc, char** argv) {
3008 ::testing::InitGoogleTest(&argc, argv);
3009
3010 using namespace std::chrono_literals;
3011 if (!android::base::WaitForProperty("init.svc.surfaceflinger", "stopped", 10s)) {
3012 ALOGE("Failed to stop init.svc.surfaceflinger");
3013 return -1;
3014 }
ramindanibeea10e2021-12-07 21:02:49 +00003015
3016 android::ProcessState::self()->setThreadPoolMaxThreadCount(4);
3017
3018 // The binder threadpool we start will inherit sched policy and priority
3019 // of (this) creating thread. We want the binder thread pool to have
3020 // SCHED_FIFO policy and priority 1 (lowest RT priority)
3021 // Once the pool is created we reset this thread's priority back to
3022 // original.
3023 // This thread policy is based on what we do in the SurfaceFlinger while starting
3024 // the thread pool and we need to replicate that for the VTS tests.
3025 int newPriority = 0;
3026 int origPolicy = sched_getscheduler(0);
3027 struct sched_param origSchedParam;
3028
3029 int errorInPriorityModification = sched_getparam(0, &origSchedParam);
3030 if (errorInPriorityModification == 0) {
3031 int policy = SCHED_FIFO;
3032 newPriority = sched_get_priority_min(policy);
3033
3034 struct sched_param param;
3035 param.sched_priority = newPriority;
3036
3037 errorInPriorityModification = sched_setscheduler(0, policy, &param);
3038 }
3039
3040 // start the thread pool
3041 android::ProcessState::self()->startThreadPool();
3042
3043 // Reset current thread's policy and priority
3044 if (errorInPriorityModification == 0) {
3045 errorInPriorityModification = sched_setscheduler(0, origPolicy, &origSchedParam);
3046 } else {
3047 ALOGE("Failed to set VtsHalGraphicsComposer3_TargetTest binder threadpool priority to "
3048 "SCHED_FIFO");
3049 }
3050
ramindanid32ae8e2021-10-01 18:48:39 +00003051 return RUN_ALL_TESTS();
Leon Scroggins III45095052023-03-23 18:23:15 -04003052}