blob: 5116774b40dc395e586d2fd326461fafb0bfe2e6 [file] [log] [blame]
ramindani431aad42022-02-01 21:44:29 +00001/**
2 * Copyright (c) 2022, The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
Sally Qi2600d342022-08-16 12:46:17 -070016
ramindanid32ae8e2021-10-01 18:48:39 +000017#include <aidl/Gtest.h>
18#include <aidl/Vintf.h>
Ady Abraham3192f3d2021-12-03 16:08:56 -080019#include <aidl/android/hardware/graphics/common/BlendMode.h>
ramindani3335f7a2021-10-25 17:22:35 +000020#include <aidl/android/hardware/graphics/common/BufferUsage.h>
21#include <aidl/android/hardware/graphics/common/FRect.h>
Leon Scroggins IIIde057582022-01-13 12:26:00 -050022#include <aidl/android/hardware/graphics/common/PixelFormat.h>
ramindani3335f7a2021-10-25 17:22:35 +000023#include <aidl/android/hardware/graphics/common/Rect.h>
ramindani3335f7a2021-10-25 17:22:35 +000024#include <aidl/android/hardware/graphics/composer3/Composition.h>
ramindanid32ae8e2021-10-01 18:48:39 +000025#include <aidl/android/hardware/graphics/composer3/IComposer.h>
26#include <android-base/properties.h>
ramindania9780262021-10-01 18:48:39 +000027#include <android/binder_process.h>
Ady Abraham91c9d1a2021-12-15 18:14:45 -080028#include <android/hardware/graphics/composer3/ComposerClientReader.h>
29#include <android/hardware/graphics/composer3/ComposerClientWriter.h>
ramindanid32ae8e2021-10-01 18:48:39 +000030#include <binder/ProcessState.h>
31#include <gtest/gtest.h>
Ady Abraham72c5b502021-12-10 17:23:39 -080032#include <ui/Fence.h>
ramindani3335f7a2021-10-25 17:22:35 +000033#include <ui/GraphicBuffer.h>
34#include <ui/PixelFormat.h>
ramindani0291f112021-11-04 03:45:46 +000035#include <algorithm>
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -040036#include <iterator>
ramindani592b6512021-10-08 21:15:19 +000037#include <numeric>
ramindanid32ae8e2021-10-01 18:48:39 +000038#include <string>
ramindani1cb794e2021-10-13 20:45:23 +000039#include <thread>
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -040040#include <unordered_map>
ramindani458e53e2022-02-23 17:30:16 +000041#include "GraphicsComposerCallback.h"
42#include "VtsComposerClient.h"
ramindani3335f7a2021-10-25 17:22:35 +000043
ramindanid32ae8e2021-10-01 18:48:39 +000044#undef LOG_TAG
45#define LOG_TAG "VtsHalGraphicsComposer3_TargetTest"
46
47namespace aidl::android::hardware::graphics::composer3::vts {
48namespace {
49
ramindani1cb794e2021-10-13 20:45:23 +000050using namespace std::chrono_literals;
51
ramindanidcfe3a82021-11-29 17:00:31 +000052using ::android::GraphicBuffer;
53using ::android::sp;
54
ramindanid32ae8e2021-10-01 18:48:39 +000055class GraphicsComposerAidlTest : public ::testing::TestWithParam<std::string> {
ramindania9780262021-10-01 18:48:39 +000056 protected:
57 void SetUp() override {
ramindani431aad42022-02-01 21:44:29 +000058 mComposerClient = std::make_unique<VtsComposerClient>(GetParam());
59 ASSERT_TRUE(mComposerClient->createClient().isOk());
Jason Macnake531a092022-01-20 08:49:09 -080060
ramindani431aad42022-02-01 21:44:29 +000061 const auto& [status, displays] = mComposerClient->getDisplays();
Jason Macnake531a092022-01-20 08:49:09 -080062 ASSERT_TRUE(status.isOk());
ramindani431aad42022-02-01 21:44:29 +000063 mDisplays = displays;
ramindanidcfe3a82021-11-29 17:00:31 +000064
ramindani3335f7a2021-10-25 17:22:35 +000065 // explicitly disable vsync
66 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +000067 EXPECT_TRUE(mComposerClient->setVsync(display.getDisplayId(), false).isOk());
ramindani3335f7a2021-10-25 17:22:35 +000068 }
ramindani431aad42022-02-01 21:44:29 +000069 mComposerClient->setVsyncAllowed(false);
ramindania9780262021-10-01 18:48:39 +000070 }
71
ramindani3335f7a2021-10-25 17:22:35 +000072 void TearDown() override {
ramindani431aad42022-02-01 21:44:29 +000073 ASSERT_TRUE(mComposerClient->tearDown());
74 mComposerClient.reset();
ramindani3335f7a2021-10-25 17:22:35 +000075 }
ramindanic2b8d082021-11-06 02:03:50 +000076
ramindanid5751092022-04-22 22:30:20 +000077 void assertServiceSpecificError(const ScopedAStatus& status, int32_t serviceSpecificError) {
78 ASSERT_EQ(status.getExceptionCode(), EX_SERVICE_SPECIFIC);
79 ASSERT_EQ(status.getServiceSpecificError(), serviceSpecificError);
80 }
81
ramindani431aad42022-02-01 21:44:29 +000082 void Test_setContentTypeForDisplay(int64_t display,
83 const std::vector<ContentType>& supportedContentTypes,
84 ContentType contentType, const char* contentTypeStr) {
85 const bool contentTypeSupport =
86 std::find(supportedContentTypes.begin(), supportedContentTypes.end(),
87 contentType) != supportedContentTypes.end();
ramindanidcfe3a82021-11-29 17:00:31 +000088
89 if (!contentTypeSupport) {
ramindani431aad42022-02-01 21:44:29 +000090 const auto& status = mComposerClient->setContentType(display, contentType);
91 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +000092 EXPECT_NO_FATAL_FAILURE(
93 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
ramindanidcfe3a82021-11-29 17:00:31 +000094 GTEST_SUCCEED() << contentTypeStr << " content type is not supported on display "
95 << std::to_string(display) << ", skipping test";
96 return;
97 }
98
99 EXPECT_TRUE(mComposerClient->setContentType(display, contentType).isOk());
100 EXPECT_TRUE(mComposerClient->setContentType(display, ContentType::NONE).isOk());
101 }
102
ramindani431aad42022-02-01 21:44:29 +0000103 void Test_setContentType(ContentType contentType, const char* contentTypeStr) {
ramindanidcfe3a82021-11-29 17:00:31 +0000104 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000105 const auto& [status, supportedContentTypes] =
106 mComposerClient->getSupportedContentTypes(display.getDisplayId());
107 EXPECT_TRUE(status.isOk());
108 Test_setContentTypeForDisplay(display.getDisplayId(), supportedContentTypes,
109 contentType, contentTypeStr);
ramindanidcfe3a82021-11-29 17:00:31 +0000110 }
111 }
112
Jason Macnak325e8232022-01-24 14:48:55 -0800113 bool hasCapability(Capability capability) {
ramindani431aad42022-02-01 21:44:29 +0000114 const auto& [status, capabilities] = mComposerClient->getCapabilities();
115 EXPECT_TRUE(status.isOk());
Jason Macnak325e8232022-01-24 14:48:55 -0800116 return std::any_of(
117 capabilities.begin(), capabilities.end(),
118 [&](const Capability& activeCapability) { return activeCapability == capability; });
119 }
120
ramindani431aad42022-02-01 21:44:29 +0000121 const VtsDisplay& getPrimaryDisplay() const { return mDisplays[0]; }
ramindania9780262021-10-01 18:48:39 +0000122
ramindani431aad42022-02-01 21:44:29 +0000123 int64_t getPrimaryDisplayId() const { return getPrimaryDisplay().getDisplayId(); }
ramindania9780262021-10-01 18:48:39 +0000124
ramindani431aad42022-02-01 21:44:29 +0000125 int64_t getInvalidDisplayId() const { return mComposerClient->getInvalidDisplayId(); }
ramindani1cb794e2021-10-13 20:45:23 +0000126
ramindani431aad42022-02-01 21:44:29 +0000127 VtsDisplay& getEditablePrimaryDisplay() { return mDisplays[0]; }
ramindani0291f112021-11-04 03:45:46 +0000128
ramindani3335f7a2021-10-25 17:22:35 +0000129 struct TestParameters {
130 nsecs_t delayForChange;
131 bool refreshMiss;
132 };
133
ramindani431aad42022-02-01 21:44:29 +0000134 std::unique_ptr<VtsComposerClient> mComposerClient;
ramindani1cb794e2021-10-13 20:45:23 +0000135 std::vector<VtsDisplay> mDisplays;
ramindani3335f7a2021-10-25 17:22:35 +0000136 // use the slot count usually set by SF
137 static constexpr uint32_t kBufferSlotCount = 64;
ramindanid32ae8e2021-10-01 18:48:39 +0000138};
139
ramindani431aad42022-02-01 21:44:29 +0000140TEST_P(GraphicsComposerAidlTest, GetDisplayCapabilities_BadDisplay) {
141 const auto& [status, _] = mComposerClient->getDisplayCapabilities(getInvalidDisplayId());
ramindani5f696942021-10-14 16:24:18 +0000142
ramindani431aad42022-02-01 21:44:29 +0000143 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000144 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindania9780262021-10-01 18:48:39 +0000145}
146
ramindani431aad42022-02-01 21:44:29 +0000147TEST_P(GraphicsComposerAidlTest, GetDisplayCapabilities) {
ramindania9780262021-10-01 18:48:39 +0000148 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000149 const auto& [status, capabilities] =
150 mComposerClient->getDisplayCapabilities(display.getDisplayId());
ramindania9780262021-10-01 18:48:39 +0000151
ramindani431aad42022-02-01 21:44:29 +0000152 EXPECT_TRUE(status.isOk());
ramindania9780262021-10-01 18:48:39 +0000153 }
ramindanid32ae8e2021-10-01 18:48:39 +0000154}
155
ramindani2740bac2021-11-24 22:58:32 +0000156TEST_P(GraphicsComposerAidlTest, DumpDebugInfo) {
ramindani431aad42022-02-01 21:44:29 +0000157 ASSERT_TRUE(mComposerClient->dumpDebugInfo().isOk());
ramindani2740bac2021-11-24 22:58:32 +0000158}
159
160TEST_P(GraphicsComposerAidlTest, CreateClientSingleton) {
161 std::shared_ptr<IComposerClient> composerClient;
ramindani431aad42022-02-01 21:44:29 +0000162 const auto& status = mComposerClient->createClient();
ramindani2740bac2021-11-24 22:58:32 +0000163
ramindani431aad42022-02-01 21:44:29 +0000164 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000165 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_NO_RESOURCES));
ramindani2740bac2021-11-24 22:58:32 +0000166}
167
ramindani592b6512021-10-08 21:15:19 +0000168TEST_P(GraphicsComposerAidlTest, GetDisplayIdentificationData) {
ramindani431aad42022-02-01 21:44:29 +0000169 const auto& [status0, displayIdentification0] =
170 mComposerClient->getDisplayIdentificationData(getPrimaryDisplayId());
ramindanid5751092022-04-22 22:30:20 +0000171 if (!status0.isOk() && status0.getExceptionCode() == EX_SERVICE_SPECIFIC &&
172 status0.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindani431aad42022-02-01 21:44:29 +0000173 GTEST_SUCCEED() << "Display identification data not supported, skipping test";
ramindani592b6512021-10-08 21:15:19 +0000174 return;
175 }
ramindani431aad42022-02-01 21:44:29 +0000176 ASSERT_TRUE(status0.isOk()) << "failed to get display identification data";
ramindani592b6512021-10-08 21:15:19 +0000177 ASSERT_FALSE(displayIdentification0.data.empty());
178
179 constexpr size_t kEdidBlockSize = 128;
180 ASSERT_TRUE(displayIdentification0.data.size() % kEdidBlockSize == 0)
181 << "EDID blob length is not a multiple of " << kEdidBlockSize;
182
183 const uint8_t kEdidHeader[] = {0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00};
184 ASSERT_TRUE(std::equal(std::begin(kEdidHeader), std::end(kEdidHeader),
185 displayIdentification0.data.begin()))
186 << "EDID blob doesn't start with the fixed EDID header";
187 ASSERT_EQ(0, std::accumulate(displayIdentification0.data.begin(),
188 displayIdentification0.data.begin() + kEdidBlockSize,
189 static_cast<uint8_t>(0)))
190 << "EDID base block doesn't checksum";
191
ramindani431aad42022-02-01 21:44:29 +0000192 const auto& [status1, displayIdentification1] =
193 mComposerClient->getDisplayIdentificationData(getPrimaryDisplayId());
194 ASSERT_TRUE(status1.isOk());
ramindani592b6512021-10-08 21:15:19 +0000195
196 ASSERT_EQ(displayIdentification0.port, displayIdentification1.port) << "ports are not stable";
197 ASSERT_TRUE(displayIdentification0.data.size() == displayIdentification1.data.size() &&
198 std::equal(displayIdentification0.data.begin(), displayIdentification0.data.end(),
199 displayIdentification1.data.begin()))
200 << "data is not stable";
201}
202
203TEST_P(GraphicsComposerAidlTest, GetHdrCapabilities) {
ramindani431aad42022-02-01 21:44:29 +0000204 const auto& [status, hdrCapabilities] =
205 mComposerClient->getHdrCapabilities(getPrimaryDisplayId());
ramindani592b6512021-10-08 21:15:19 +0000206
ramindani431aad42022-02-01 21:44:29 +0000207 ASSERT_TRUE(status.isOk());
208 EXPECT_TRUE(hdrCapabilities.maxLuminance >= hdrCapabilities.minLuminance);
ramindani592b6512021-10-08 21:15:19 +0000209}
210
211TEST_P(GraphicsComposerAidlTest, GetPerFrameMetadataKeys) {
ramindani431aad42022-02-01 21:44:29 +0000212 const auto& [status, keys] = mComposerClient->getPerFrameMetadataKeys(getPrimaryDisplayId());
ramindanid5751092022-04-22 22:30:20 +0000213 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
214 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindanic2b8d082021-11-06 02:03:50 +0000215 GTEST_SUCCEED() << "getPerFrameMetadataKeys is not supported";
216 return;
ramindani592b6512021-10-08 21:15:19 +0000217 }
ramindani431aad42022-02-01 21:44:29 +0000218
219 ASSERT_TRUE(status.isOk());
220 EXPECT_TRUE(keys.size() >= 0);
ramindani592b6512021-10-08 21:15:19 +0000221}
222
223TEST_P(GraphicsComposerAidlTest, GetReadbackBufferAttributes) {
ramindani431aad42022-02-01 21:44:29 +0000224 const auto& [status, _] = mComposerClient->getReadbackBufferAttributes(getPrimaryDisplayId());
ramindanid5751092022-04-22 22:30:20 +0000225 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
226 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindani431aad42022-02-01 21:44:29 +0000227 GTEST_SUCCEED() << "getReadbackBufferAttributes is not supported";
228 return;
ramindani592b6512021-10-08 21:15:19 +0000229 }
ramindani431aad42022-02-01 21:44:29 +0000230
231 ASSERT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000232}
233
234TEST_P(GraphicsComposerAidlTest, GetRenderIntents) {
ramindani431aad42022-02-01 21:44:29 +0000235 const auto& [status, modes] = mComposerClient->getColorModes(getPrimaryDisplayId());
236 EXPECT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000237
ramindani431aad42022-02-01 21:44:29 +0000238 for (auto mode : modes) {
239 const auto& [intentStatus, intents] =
240 mComposerClient->getRenderIntents(getPrimaryDisplayId(), mode);
241 EXPECT_TRUE(intentStatus.isOk());
ramindani592b6512021-10-08 21:15:19 +0000242 bool isHdr;
243 switch (mode) {
244 case ColorMode::BT2100_PQ:
245 case ColorMode::BT2100_HLG:
246 isHdr = true;
247 break;
248 default:
249 isHdr = false;
250 break;
251 }
252 RenderIntent requiredIntent =
253 isHdr ? RenderIntent::TONE_MAP_COLORIMETRIC : RenderIntent::COLORIMETRIC;
254
ramindani431aad42022-02-01 21:44:29 +0000255 const auto iter = std::find(intents.cbegin(), intents.cend(), requiredIntent);
ramindani592b6512021-10-08 21:15:19 +0000256 EXPECT_NE(intents.cend(), iter);
257 }
258}
259
ramindani431aad42022-02-01 21:44:29 +0000260TEST_P(GraphicsComposerAidlTest, GetRenderIntents_BadDisplay) {
261 const auto& [status, modes] = mComposerClient->getColorModes(getPrimaryDisplayId());
262 ASSERT_TRUE(status.isOk());
263
ramindani592b6512021-10-08 21:15:19 +0000264 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +0000265 const auto& [intentStatus, _] =
266 mComposerClient->getRenderIntents(getInvalidDisplayId(), mode);
267
268 EXPECT_FALSE(intentStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000269 EXPECT_NO_FATAL_FAILURE(
270 assertServiceSpecificError(intentStatus, IComposerClient::EX_BAD_DISPLAY));
ramindani592b6512021-10-08 21:15:19 +0000271 }
272}
273
ramindani431aad42022-02-01 21:44:29 +0000274TEST_P(GraphicsComposerAidlTest, GetRenderIntents_BadParameter) {
275 const auto& [status, _] =
276 mComposerClient->getRenderIntents(getPrimaryDisplayId(), static_cast<ColorMode>(-1));
277
278 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000279 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
ramindani592b6512021-10-08 21:15:19 +0000280}
281
282TEST_P(GraphicsComposerAidlTest, GetColorModes) {
ramindani431aad42022-02-01 21:44:29 +0000283 const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
284 ASSERT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000285
ramindani431aad42022-02-01 21:44:29 +0000286 const auto native = std::find(colorModes.cbegin(), colorModes.cend(), ColorMode::NATIVE);
287 EXPECT_NE(colorModes.cend(), native);
ramindani592b6512021-10-08 21:15:19 +0000288}
289
ramindani431aad42022-02-01 21:44:29 +0000290TEST_P(GraphicsComposerAidlTest, GetColorMode_BadDisplay) {
291 const auto& [status, _] = mComposerClient->getColorModes(getInvalidDisplayId());
ramindani592b6512021-10-08 21:15:19 +0000292
ramindani431aad42022-02-01 21:44:29 +0000293 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000294 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani592b6512021-10-08 21:15:19 +0000295}
296
297TEST_P(GraphicsComposerAidlTest, SetColorMode) {
ramindani431aad42022-02-01 21:44:29 +0000298 const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
299 EXPECT_TRUE(status.isOk());
300
ramindani592b6512021-10-08 21:15:19 +0000301 for (auto mode : colorModes) {
ramindani431aad42022-02-01 21:44:29 +0000302 const auto& [intentStatus, intents] =
303 mComposerClient->getRenderIntents(getPrimaryDisplayId(), mode);
304 EXPECT_TRUE(intentStatus.isOk()) << "failed to get render intents";
305
ramindani592b6512021-10-08 21:15:19 +0000306 for (auto intent : intents) {
ramindani431aad42022-02-01 21:44:29 +0000307 const auto modeStatus =
308 mComposerClient->setColorMode(getPrimaryDisplayId(), mode, intent);
309 EXPECT_TRUE(modeStatus.isOk() ||
ramindanid5751092022-04-22 22:30:20 +0000310 (modeStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
311 IComposerClient::EX_UNSUPPORTED == modeStatus.getServiceSpecificError()))
ramindani592b6512021-10-08 21:15:19 +0000312 << "failed to set color mode";
313 }
314 }
315
ramindani431aad42022-02-01 21:44:29 +0000316 const auto modeStatus = mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE,
317 RenderIntent::COLORIMETRIC);
318 EXPECT_TRUE(modeStatus.isOk() ||
ramindanid5751092022-04-22 22:30:20 +0000319 (modeStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
320 IComposerClient::EX_UNSUPPORTED == modeStatus.getServiceSpecificError()))
ramindani592b6512021-10-08 21:15:19 +0000321 << "failed to set color mode";
322}
323
ramindani431aad42022-02-01 21:44:29 +0000324TEST_P(GraphicsComposerAidlTest, SetColorMode_BadDisplay) {
325 const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
326 ASSERT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000327
ramindani431aad42022-02-01 21:44:29 +0000328 for (auto mode : colorModes) {
329 const auto& [intentStatus, intents] =
330 mComposerClient->getRenderIntents(getPrimaryDisplayId(), mode);
331 ASSERT_TRUE(intentStatus.isOk()) << "failed to get render intents";
332
333 for (auto intent : intents) {
334 auto const modeStatus =
335 mComposerClient->setColorMode(getInvalidDisplayId(), mode, intent);
336
337 EXPECT_FALSE(modeStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000338 EXPECT_NO_FATAL_FAILURE(
339 assertServiceSpecificError(modeStatus, IComposerClient::EX_BAD_DISPLAY));
ramindani770d7082021-11-30 00:36:42 +0000340 }
341 }
ramindani592b6512021-10-08 21:15:19 +0000342}
343
ramindani431aad42022-02-01 21:44:29 +0000344TEST_P(GraphicsComposerAidlTest, SetColorMode_BadParameter) {
345 auto status = mComposerClient->setColorMode(getPrimaryDisplayId(), static_cast<ColorMode>(-1),
346 RenderIntent::COLORIMETRIC);
ramindani592b6512021-10-08 21:15:19 +0000347
ramindani431aad42022-02-01 21:44:29 +0000348 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000349 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
ramindani592b6512021-10-08 21:15:19 +0000350
ramindani431aad42022-02-01 21:44:29 +0000351 status = mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE,
352 static_cast<RenderIntent>(-1));
ramindani592b6512021-10-08 21:15:19 +0000353
ramindani431aad42022-02-01 21:44:29 +0000354 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000355 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
ramindani592b6512021-10-08 21:15:19 +0000356}
357
358TEST_P(GraphicsComposerAidlTest, GetDisplayedContentSamplingAttributes) {
ramindani431aad42022-02-01 21:44:29 +0000359 int constexpr kInvalid = -1;
360 const auto& [status, format] =
361 mComposerClient->getDisplayedContentSamplingAttributes(getPrimaryDisplayId());
ramindani592b6512021-10-08 21:15:19 +0000362
ramindanid5751092022-04-22 22:30:20 +0000363 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
364 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindani592b6512021-10-08 21:15:19 +0000365 SUCCEED() << "Device does not support optional extension. Test skipped";
366 return;
367 }
368
ramindani431aad42022-02-01 21:44:29 +0000369 ASSERT_TRUE(status.isOk());
370 EXPECT_NE(kInvalid, static_cast<int>(format.format));
371 EXPECT_NE(kInvalid, static_cast<int>(format.dataspace));
372 EXPECT_NE(kInvalid, static_cast<int>(format.componentMask));
ramindani592b6512021-10-08 21:15:19 +0000373};
374
375TEST_P(GraphicsComposerAidlTest, SetDisplayedContentSamplingEnabled) {
ramindani431aad42022-02-01 21:44:29 +0000376 int constexpr kMaxFrames = 10;
ramindani592b6512021-10-08 21:15:19 +0000377 FormatColorComponent enableAllComponents = FormatColorComponent::FORMAT_COMPONENT_0;
ramindani431aad42022-02-01 21:44:29 +0000378 auto status = mComposerClient->setDisplayedContentSamplingEnabled(
379 getPrimaryDisplayId(), /*isEnabled*/ true, enableAllComponents, kMaxFrames);
ramindanid5751092022-04-22 22:30:20 +0000380 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
381 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindani592b6512021-10-08 21:15:19 +0000382 SUCCEED() << "Device does not support optional extension. Test skipped";
383 return;
384 }
ramindani431aad42022-02-01 21:44:29 +0000385 EXPECT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000386
ramindani431aad42022-02-01 21:44:29 +0000387 status = mComposerClient->setDisplayedContentSamplingEnabled(
388 getPrimaryDisplayId(), /*isEnabled*/ false, enableAllComponents, kMaxFrames);
389 EXPECT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000390}
391
392TEST_P(GraphicsComposerAidlTest, GetDisplayedContentSample) {
ramindani431aad42022-02-01 21:44:29 +0000393 const auto& [status, displayContentSamplingAttributes] =
394 mComposerClient->getDisplayedContentSamplingAttributes(getPrimaryDisplayId());
ramindanid5751092022-04-22 22:30:20 +0000395 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
396 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindanideb059e2021-11-18 01:57:25 +0000397 SUCCEED() << "Sampling attributes aren't supported on this device, test skipped";
398 return;
399 }
ramindani592b6512021-10-08 21:15:19 +0000400
ramindani431aad42022-02-01 21:44:29 +0000401 int64_t constexpr kMaxFrames = 10;
402 int64_t constexpr kTimestamp = 0;
403 const auto& [sampleStatus, displayContentSample] = mComposerClient->getDisplayedContentSample(
404 getPrimaryDisplayId(), kMaxFrames, kTimestamp);
ramindanid5751092022-04-22 22:30:20 +0000405 if (!sampleStatus.isOk() && sampleStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
ramindani431aad42022-02-01 21:44:29 +0000406 sampleStatus.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindani592b6512021-10-08 21:15:19 +0000407 SUCCEED() << "Device does not support optional extension. Test skipped";
408 return;
409 }
410
ramindani431aad42022-02-01 21:44:29 +0000411 EXPECT_TRUE(sampleStatus.isOk());
412 const std::vector<std::vector<int64_t>> histogram = {
ramindani592b6512021-10-08 21:15:19 +0000413 displayContentSample.sampleComponent0, displayContentSample.sampleComponent1,
414 displayContentSample.sampleComponent2, displayContentSample.sampleComponent3};
415
ramindani3335f7a2021-10-25 17:22:35 +0000416 for (size_t i = 0; i < histogram.size(); i++) {
417 const bool shouldHaveHistogram =
418 static_cast<int>(displayContentSamplingAttributes.componentMask) & (1 << i);
419 EXPECT_EQ(shouldHaveHistogram, !histogram[i].empty());
ramindani592b6512021-10-08 21:15:19 +0000420 }
421}
422
ramindani431aad42022-02-01 21:44:29 +0000423TEST_P(GraphicsComposerAidlTest, GetDisplayConnectionType) {
424 const auto& [status, type] = mComposerClient->getDisplayConnectionType(getInvalidDisplayId());
425
426 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000427 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani431aad42022-02-01 21:44:29 +0000428
ramindani0291f112021-11-04 03:45:46 +0000429 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000430 const auto& [connectionTypeStatus, _] =
431 mComposerClient->getDisplayConnectionType(display.getDisplayId());
432 EXPECT_TRUE(connectionTypeStatus.isOk());
ramindani0291f112021-11-04 03:45:46 +0000433 }
434}
435
ramindani431aad42022-02-01 21:44:29 +0000436TEST_P(GraphicsComposerAidlTest, GetDisplayAttribute) {
ramindani0291f112021-11-04 03:45:46 +0000437 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000438 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
439 EXPECT_TRUE(status.isOk());
440
ramindani0291f112021-11-04 03:45:46 +0000441 for (const auto& config : configs) {
442 const std::array<DisplayAttribute, 4> requiredAttributes = {{
443 DisplayAttribute::WIDTH,
444 DisplayAttribute::HEIGHT,
445 DisplayAttribute::VSYNC_PERIOD,
446 DisplayAttribute::CONFIG_GROUP,
447 }};
ramindani0291f112021-11-04 03:45:46 +0000448 for (const auto& attribute : requiredAttributes) {
ramindani431aad42022-02-01 21:44:29 +0000449 const auto& [attribStatus, value] = mComposerClient->getDisplayAttribute(
450 display.getDisplayId(), config, attribute);
451 EXPECT_TRUE(attribStatus.isOk());
ramindani0291f112021-11-04 03:45:46 +0000452 EXPECT_NE(-1, value);
453 }
454
455 const std::array<DisplayAttribute, 2> optionalAttributes = {{
456 DisplayAttribute::DPI_X,
457 DisplayAttribute::DPI_Y,
458 }};
459 for (const auto& attribute : optionalAttributes) {
ramindani431aad42022-02-01 21:44:29 +0000460 const auto& [attribStatus, value] = mComposerClient->getDisplayAttribute(
461 display.getDisplayId(), config, attribute);
ramindanid5751092022-04-22 22:30:20 +0000462 EXPECT_TRUE(attribStatus.isOk() ||
463 (attribStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
464 IComposerClient::EX_UNSUPPORTED ==
465 attribStatus.getServiceSpecificError()));
ramindani0291f112021-11-04 03:45:46 +0000466 }
467 }
468 }
469}
470
ramindani431aad42022-02-01 21:44:29 +0000471TEST_P(GraphicsComposerAidlTest, CheckConfigsAreValid) {
ramindani0291f112021-11-04 03:45:46 +0000472 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000473 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
474 EXPECT_TRUE(status.isOk());
ramindani0291f112021-11-04 03:45:46 +0000475
476 EXPECT_FALSE(std::any_of(configs.begin(), configs.end(), [](auto config) {
477 return config == IComposerClient::INVALID_CONFIGURATION;
478 }));
479 }
480}
481
ramindani431aad42022-02-01 21:44:29 +0000482TEST_P(GraphicsComposerAidlTest, GetDisplayVsyncPeriod_BadDisplay) {
483 const auto& [status, vsyncPeriodNanos] =
484 mComposerClient->getDisplayVsyncPeriod(getInvalidDisplayId());
485
486 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000487 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani0291f112021-11-04 03:45:46 +0000488}
489
ramindani431aad42022-02-01 21:44:29 +0000490TEST_P(GraphicsComposerAidlTest, SetActiveConfigWithConstraints_BadDisplay) {
ramindani0291f112021-11-04 03:45:46 +0000491 VsyncPeriodChangeConstraints constraints;
ramindani0291f112021-11-04 03:45:46 +0000492 constraints.seamlessRequired = false;
493 constraints.desiredTimeNanos = systemTime();
ramindani431aad42022-02-01 21:44:29 +0000494 auto invalidDisplay = VtsDisplay(getInvalidDisplayId());
ramindani0291f112021-11-04 03:45:46 +0000495
ramindani431aad42022-02-01 21:44:29 +0000496 const auto& [status, timeline] = mComposerClient->setActiveConfigWithConstraints(
497 &invalidDisplay, /*config*/ 0, constraints);
498
499 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000500 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani0291f112021-11-04 03:45:46 +0000501}
502
ramindani431aad42022-02-01 21:44:29 +0000503TEST_P(GraphicsComposerAidlTest, SetActiveConfigWithConstraints_BadConfig) {
ramindani0291f112021-11-04 03:45:46 +0000504 VsyncPeriodChangeConstraints constraints;
ramindani0291f112021-11-04 03:45:46 +0000505 constraints.seamlessRequired = false;
506 constraints.desiredTimeNanos = systemTime();
507
508 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000509 int32_t constexpr kInvalidConfigId = IComposerClient::INVALID_CONFIGURATION;
510 const auto& [status, _] = mComposerClient->setActiveConfigWithConstraints(
511 &display, kInvalidConfigId, constraints);
512
513 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000514 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_CONFIG));
ramindani0291f112021-11-04 03:45:46 +0000515 }
516}
517
ramindani431aad42022-02-01 21:44:29 +0000518TEST_P(GraphicsComposerAidlTest, SetBootDisplayConfig_BadDisplay) {
ramindani476314c2022-03-16 00:17:08 +0000519 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
520 GTEST_SUCCEED() << "Boot Display Config not supported";
521 return;
522 }
ramindani431aad42022-02-01 21:44:29 +0000523 const auto& status = mComposerClient->setBootDisplayConfig(getInvalidDisplayId(), /*config*/ 0);
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100524
ramindani431aad42022-02-01 21:44:29 +0000525 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000526 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100527}
528
ramindani431aad42022-02-01 21:44:29 +0000529TEST_P(GraphicsComposerAidlTest, SetBootDisplayConfig_BadConfig) {
ramindani476314c2022-03-16 00:17:08 +0000530 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
531 GTEST_SUCCEED() << "Boot Display Config not supported";
532 return;
533 }
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100534 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000535 int32_t constexpr kInvalidConfigId = IComposerClient::INVALID_CONFIGURATION;
536 const auto& status =
537 mComposerClient->setBootDisplayConfig(display.getDisplayId(), kInvalidConfigId);
538
539 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000540 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_CONFIG));
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100541 }
542}
543
ramindani431aad42022-02-01 21:44:29 +0000544TEST_P(GraphicsComposerAidlTest, SetBootDisplayConfig) {
ramindani476314c2022-03-16 00:17:08 +0000545 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
546 GTEST_SUCCEED() << "Boot Display Config not supported";
547 return;
548 }
ramindani431aad42022-02-01 21:44:29 +0000549 const auto& [status, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
550 EXPECT_TRUE(status.isOk());
551 for (const auto& config : configs) {
552 EXPECT_TRUE(mComposerClient->setBootDisplayConfig(getPrimaryDisplayId(), config).isOk());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100553 }
554}
555
ramindani431aad42022-02-01 21:44:29 +0000556TEST_P(GraphicsComposerAidlTest, ClearBootDisplayConfig_BadDisplay) {
ramindani476314c2022-03-16 00:17:08 +0000557 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
558 GTEST_SUCCEED() << "Boot Display Config not supported";
559 return;
560 }
ramindani431aad42022-02-01 21:44:29 +0000561 const auto& status = mComposerClient->clearBootDisplayConfig(getInvalidDisplayId());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100562
ramindani431aad42022-02-01 21:44:29 +0000563 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000564 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100565}
566
ramindani431aad42022-02-01 21:44:29 +0000567TEST_P(GraphicsComposerAidlTest, ClearBootDisplayConfig) {
ramindani476314c2022-03-16 00:17:08 +0000568 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
569 GTEST_SUCCEED() << "Boot Display Config not supported";
570 return;
571 }
ramindani431aad42022-02-01 21:44:29 +0000572 EXPECT_TRUE(mComposerClient->clearBootDisplayConfig(getPrimaryDisplayId()).isOk());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100573}
574
ramindani431aad42022-02-01 21:44:29 +0000575TEST_P(GraphicsComposerAidlTest, GetPreferredBootDisplayConfig_BadDisplay) {
ramindani476314c2022-03-16 00:17:08 +0000576 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
577 GTEST_SUCCEED() << "Boot Display Config not supported";
578 return;
579 }
ramindani431aad42022-02-01 21:44:29 +0000580 const auto& [status, _] = mComposerClient->getPreferredBootDisplayConfig(getInvalidDisplayId());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100581
ramindani431aad42022-02-01 21:44:29 +0000582 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000583 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100584}
585
ramindani431aad42022-02-01 21:44:29 +0000586TEST_P(GraphicsComposerAidlTest, GetPreferredBootDisplayConfig) {
ramindani476314c2022-03-16 00:17:08 +0000587 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
588 GTEST_SUCCEED() << "Boot Display Config not supported";
589 return;
590 }
ramindani431aad42022-02-01 21:44:29 +0000591 const auto& [status, preferredDisplayConfig] =
592 mComposerClient->getPreferredBootDisplayConfig(getPrimaryDisplayId());
593 EXPECT_TRUE(status.isOk());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100594
ramindani431aad42022-02-01 21:44:29 +0000595 const auto& [configStatus, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
596
597 EXPECT_TRUE(configStatus.isOk());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100598 EXPECT_NE(configs.end(), std::find(configs.begin(), configs.end(), preferredDisplayConfig));
599}
600
ramindani476314c2022-03-16 00:17:08 +0000601TEST_P(GraphicsComposerAidlTest, BootDisplayConfig_Unsupported) {
602 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
603 const auto& [configStatus, config] =
604 mComposerClient->getActiveConfig(getPrimaryDisplayId());
605 EXPECT_TRUE(configStatus.isOk());
606
607 auto status = mComposerClient->setBootDisplayConfig(getPrimaryDisplayId(), config);
608 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000609 EXPECT_NO_FATAL_FAILURE(
610 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
ramindani476314c2022-03-16 00:17:08 +0000611
612 status = mComposerClient->getPreferredBootDisplayConfig(getPrimaryDisplayId()).first;
613 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000614 EXPECT_NO_FATAL_FAILURE(
615 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
ramindani476314c2022-03-16 00:17:08 +0000616
617 status = mComposerClient->clearBootDisplayConfig(getPrimaryDisplayId());
618 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000619 EXPECT_NO_FATAL_FAILURE(
620 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
ramindani476314c2022-03-16 00:17:08 +0000621 }
622}
623
Kriti Dang3793ebd2022-12-05 13:03:49 +0100624TEST_P(GraphicsComposerAidlTest, GetHdrConversionCapabilities) {
625 if (!hasCapability(Capability::HDR_OUTPUT_CONVERSION_CONFIG)) {
626 GTEST_SUCCEED() << "HDR output conversion not supported";
627 return;
628 }
629 const auto& [status, conversionCapabilities] = mComposerClient->getHdrConversionCapabilities();
630 EXPECT_TRUE(status.isOk());
631}
632
633TEST_P(GraphicsComposerAidlTest, SetHdrConversionStrategy_Passthrough) {
634 if (!hasCapability(Capability::HDR_OUTPUT_CONVERSION_CONFIG)) {
635 GTEST_SUCCEED() << "HDR output conversion not supported";
636 return;
637 }
638 common::HdrConversionStrategy hdrConversionStrategy;
639 hdrConversionStrategy.set<common::HdrConversionStrategy::Tag::passthrough>(true);
Kriti Dang37622762023-02-09 18:15:37 +0100640 const auto& [status, preferredHdrOutputType] =
641 mComposerClient->setHdrConversionStrategy(hdrConversionStrategy);
Kriti Dang3793ebd2022-12-05 13:03:49 +0100642 EXPECT_TRUE(status.isOk());
Kriti Dang37622762023-02-09 18:15:37 +0100643 EXPECT_EQ(common::Hdr::INVALID, preferredHdrOutputType);
Kriti Dang3793ebd2022-12-05 13:03:49 +0100644}
645
646TEST_P(GraphicsComposerAidlTest, SetHdrConversionStrategy_Force) {
647 if (!hasCapability(Capability::HDR_OUTPUT_CONVERSION_CONFIG)) {
648 GTEST_SUCCEED() << "HDR output conversion not supported";
649 return;
650 }
651 const auto& [status, conversionCapabilities] = mComposerClient->getHdrConversionCapabilities();
652 for (auto conversionCapability : conversionCapabilities) {
Kriti Dang5fcddd72023-03-07 14:55:51 +0100653 if (conversionCapability.outputType != common::Hdr::INVALID) {
Kriti Dang3793ebd2022-12-05 13:03:49 +0100654 common::HdrConversionStrategy hdrConversionStrategy;
655 hdrConversionStrategy.set<common::HdrConversionStrategy::Tag::forceHdrConversion>(
Kriti Dang5fcddd72023-03-07 14:55:51 +0100656 conversionCapability.outputType);
Kriti Dang37622762023-02-09 18:15:37 +0100657 const auto& [statusSet, preferredHdrOutputType] =
Kriti Dang3793ebd2022-12-05 13:03:49 +0100658 mComposerClient->setHdrConversionStrategy(hdrConversionStrategy);
Kriti Dang37622762023-02-09 18:15:37 +0100659 EXPECT_TRUE(statusSet.isOk());
660 EXPECT_EQ(common::Hdr::INVALID, preferredHdrOutputType);
Kriti Dang3793ebd2022-12-05 13:03:49 +0100661 }
662 }
663}
664
665TEST_P(GraphicsComposerAidlTest, SetHdrConversionStrategy_Auto) {
666 if (!hasCapability(Capability::HDR_OUTPUT_CONVERSION_CONFIG)) {
667 GTEST_SUCCEED() << "HDR output conversion not supported";
668 return;
669 }
670 const auto& [status, conversionCapabilities] = mComposerClient->getHdrConversionCapabilities();
671 std::vector<aidl::android::hardware::graphics::common::Hdr> autoHdrTypes;
672 for (auto conversionCapability : conversionCapabilities) {
Kriti Dang5fcddd72023-03-07 14:55:51 +0100673 if (conversionCapability.outputType != common::Hdr::INVALID) {
674 autoHdrTypes.push_back(conversionCapability.outputType);
Kriti Dang3793ebd2022-12-05 13:03:49 +0100675 }
676 }
677 common::HdrConversionStrategy hdrConversionStrategy;
678 hdrConversionStrategy.set<common::HdrConversionStrategy::Tag::autoAllowedHdrTypes>(
679 autoHdrTypes);
Kriti Dang37622762023-02-09 18:15:37 +0100680 const auto& [statusSet, preferredHdrOutputType] =
681 mComposerClient->setHdrConversionStrategy(hdrConversionStrategy);
682 EXPECT_TRUE(statusSet.isOk());
683 EXPECT_NE(common::Hdr::INVALID, preferredHdrOutputType);
Kriti Dang3793ebd2022-12-05 13:03:49 +0100684}
685
ramindani431aad42022-02-01 21:44:29 +0000686TEST_P(GraphicsComposerAidlTest, SetAutoLowLatencyMode_BadDisplay) {
687 auto status = mComposerClient->setAutoLowLatencyMode(getInvalidDisplayId(), /*isEnabled*/ true);
688 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000689 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani431aad42022-02-01 21:44:29 +0000690
691 status = mComposerClient->setAutoLowLatencyMode(getInvalidDisplayId(), /*isEnabled*/ false);
692 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000693 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani0291f112021-11-04 03:45:46 +0000694}
695
ramindani431aad42022-02-01 21:44:29 +0000696TEST_P(GraphicsComposerAidlTest, SetAutoLowLatencyMode) {
ramindani0291f112021-11-04 03:45:46 +0000697 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000698 const auto& [status, capabilities] =
699 mComposerClient->getDisplayCapabilities(display.getDisplayId());
700 ASSERT_TRUE(status.isOk());
ramindani0291f112021-11-04 03:45:46 +0000701
702 const bool allmSupport =
703 std::find(capabilities.begin(), capabilities.end(),
704 DisplayCapability::AUTO_LOW_LATENCY_MODE) != capabilities.end();
705
706 if (!allmSupport) {
ramindani431aad42022-02-01 21:44:29 +0000707 const auto& statusIsOn = mComposerClient->setAutoLowLatencyMode(display.getDisplayId(),
708 /*isEnabled*/ true);
709 EXPECT_FALSE(statusIsOn.isOk());
ramindanid5751092022-04-22 22:30:20 +0000710 EXPECT_NO_FATAL_FAILURE(
711 assertServiceSpecificError(statusIsOn, IComposerClient::EX_UNSUPPORTED));
ramindani431aad42022-02-01 21:44:29 +0000712 const auto& statusIsOff = mComposerClient->setAutoLowLatencyMode(display.getDisplayId(),
713 /*isEnabled*/ false);
714 EXPECT_FALSE(statusIsOff.isOk());
ramindanid5751092022-04-22 22:30:20 +0000715 EXPECT_NO_FATAL_FAILURE(
716 assertServiceSpecificError(statusIsOff, IComposerClient::EX_UNSUPPORTED));
ramindani0291f112021-11-04 03:45:46 +0000717 GTEST_SUCCEED() << "Auto Low Latency Mode is not supported on display "
ramindani431aad42022-02-01 21:44:29 +0000718 << std::to_string(display.getDisplayId()) << ", skipping test";
ramindani0291f112021-11-04 03:45:46 +0000719 return;
720 }
721
ramindani431aad42022-02-01 21:44:29 +0000722 EXPECT_TRUE(mComposerClient->setAutoLowLatencyMode(display.getDisplayId(), true).isOk());
723 EXPECT_TRUE(mComposerClient->setAutoLowLatencyMode(display.getDisplayId(), false).isOk());
ramindani0291f112021-11-04 03:45:46 +0000724 }
725}
726
ramindani431aad42022-02-01 21:44:29 +0000727TEST_P(GraphicsComposerAidlTest, GetSupportedContentTypes_BadDisplay) {
728 const auto& [status, _] = mComposerClient->getSupportedContentTypes(getInvalidDisplayId());
729
730 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000731 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani0291f112021-11-04 03:45:46 +0000732}
733
ramindani431aad42022-02-01 21:44:29 +0000734TEST_P(GraphicsComposerAidlTest, GetSupportedContentTypes) {
ramindani0291f112021-11-04 03:45:46 +0000735 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000736 const auto& [status, supportedContentTypes] =
737 mComposerClient->getSupportedContentTypes(display.getDisplayId());
738 ASSERT_TRUE(status.isOk());
ramindani0291f112021-11-04 03:45:46 +0000739
740 const bool noneSupported =
741 std::find(supportedContentTypes.begin(), supportedContentTypes.end(),
742 ContentType::NONE) != supportedContentTypes.end();
ramindani431aad42022-02-01 21:44:29 +0000743
ramindani0291f112021-11-04 03:45:46 +0000744 EXPECT_FALSE(noneSupported);
745 }
746}
747
ramindani431aad42022-02-01 21:44:29 +0000748TEST_P(GraphicsComposerAidlTest, SetContentTypeNoneAlwaysAccepted) {
ramindani0291f112021-11-04 03:45:46 +0000749 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000750 EXPECT_TRUE(
751 mComposerClient->setContentType(display.getDisplayId(), ContentType::NONE).isOk());
ramindani0291f112021-11-04 03:45:46 +0000752 }
753}
754
ramindani431aad42022-02-01 21:44:29 +0000755TEST_P(GraphicsComposerAidlTest, SetContentType_BadDisplay) {
ramindani0291f112021-11-04 03:45:46 +0000756 constexpr ContentType types[] = {ContentType::NONE, ContentType::GRAPHICS, ContentType::PHOTO,
757 ContentType::CINEMA, ContentType::GAME};
758 for (const auto& type : types) {
ramindani431aad42022-02-01 21:44:29 +0000759 const auto& status = mComposerClient->setContentType(getInvalidDisplayId(), type);
ramindani0291f112021-11-04 03:45:46 +0000760
ramindani431aad42022-02-01 21:44:29 +0000761 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000762 EXPECT_NO_FATAL_FAILURE(
763 assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani0291f112021-11-04 03:45:46 +0000764 }
765}
766
ramindani431aad42022-02-01 21:44:29 +0000767TEST_P(GraphicsComposerAidlTest, SetGraphicsContentType) {
ramindani0291f112021-11-04 03:45:46 +0000768 Test_setContentType(ContentType::GRAPHICS, "GRAPHICS");
769}
770
ramindani431aad42022-02-01 21:44:29 +0000771TEST_P(GraphicsComposerAidlTest, SetPhotoContentType) {
ramindani0291f112021-11-04 03:45:46 +0000772 Test_setContentType(ContentType::PHOTO, "PHOTO");
773}
774
ramindani431aad42022-02-01 21:44:29 +0000775TEST_P(GraphicsComposerAidlTest, SetCinemaContentType) {
ramindani0291f112021-11-04 03:45:46 +0000776 Test_setContentType(ContentType::CINEMA, "CINEMA");
777}
778
ramindani431aad42022-02-01 21:44:29 +0000779TEST_P(GraphicsComposerAidlTest, SetGameContentType) {
ramindani0291f112021-11-04 03:45:46 +0000780 Test_setContentType(ContentType::GAME, "GAME");
781}
782
ramindanic2b8d082021-11-06 02:03:50 +0000783TEST_P(GraphicsComposerAidlTest, CreateVirtualDisplay) {
ramindani431aad42022-02-01 21:44:29 +0000784 const auto& [status, maxVirtualDisplayCount] = mComposerClient->getMaxVirtualDisplayCount();
785 EXPECT_TRUE(status.isOk());
786
ramindanic2b8d082021-11-06 02:03:50 +0000787 if (maxVirtualDisplayCount == 0) {
788 GTEST_SUCCEED() << "no virtual display support";
789 return;
790 }
791
ramindani431aad42022-02-01 21:44:29 +0000792 const auto& [virtualDisplayStatus, virtualDisplay] = mComposerClient->createVirtualDisplay(
793 /*width*/ 64, /*height*/ 64, common::PixelFormat::IMPLEMENTATION_DEFINED,
794 kBufferSlotCount);
ramindanic2b8d082021-11-06 02:03:50 +0000795
ramindani431aad42022-02-01 21:44:29 +0000796 ASSERT_TRUE(virtualDisplayStatus.isOk());
ramindanic2b8d082021-11-06 02:03:50 +0000797 EXPECT_TRUE(mComposerClient->destroyVirtualDisplay(virtualDisplay.display).isOk());
798}
799
ramindani431aad42022-02-01 21:44:29 +0000800TEST_P(GraphicsComposerAidlTest, DestroyVirtualDisplay_BadDisplay) {
801 const auto& [status, maxDisplayCount] = mComposerClient->getMaxVirtualDisplayCount();
802 EXPECT_TRUE(status.isOk());
803
ramindani2740bac2021-11-24 22:58:32 +0000804 if (maxDisplayCount == 0) {
805 GTEST_SUCCEED() << "no virtual display support";
806 return;
807 }
ramindani2740bac2021-11-24 22:58:32 +0000808
ramindani431aad42022-02-01 21:44:29 +0000809 const auto& destroyStatus = mComposerClient->destroyVirtualDisplay(getInvalidDisplayId());
810
811 EXPECT_FALSE(destroyStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000812 EXPECT_NO_FATAL_FAILURE(
813 assertServiceSpecificError(destroyStatus, IComposerClient::EX_BAD_DISPLAY));
ramindani2740bac2021-11-24 22:58:32 +0000814}
815
816TEST_P(GraphicsComposerAidlTest, CreateLayer) {
ramindani431aad42022-02-01 21:44:29 +0000817 const auto& [status, layer] =
818 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
ramindani2740bac2021-11-24 22:58:32 +0000819
ramindani431aad42022-02-01 21:44:29 +0000820 EXPECT_TRUE(status.isOk());
821 EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
ramindani2740bac2021-11-24 22:58:32 +0000822}
823
ramindani431aad42022-02-01 21:44:29 +0000824TEST_P(GraphicsComposerAidlTest, CreateLayer_BadDisplay) {
825 const auto& [status, _] = mComposerClient->createLayer(getInvalidDisplayId(), kBufferSlotCount);
ramindani2740bac2021-11-24 22:58:32 +0000826
ramindani431aad42022-02-01 21:44:29 +0000827 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000828 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani2740bac2021-11-24 22:58:32 +0000829}
830
ramindani431aad42022-02-01 21:44:29 +0000831TEST_P(GraphicsComposerAidlTest, DestroyLayer_BadDisplay) {
832 const auto& [status, layer] =
833 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
834 EXPECT_TRUE(status.isOk());
ramindani2740bac2021-11-24 22:58:32 +0000835
ramindani431aad42022-02-01 21:44:29 +0000836 const auto& destroyStatus = mComposerClient->destroyLayer(getInvalidDisplayId(), layer);
ramindani2740bac2021-11-24 22:58:32 +0000837
ramindani431aad42022-02-01 21:44:29 +0000838 EXPECT_FALSE(destroyStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000839 EXPECT_NO_FATAL_FAILURE(
840 assertServiceSpecificError(destroyStatus, IComposerClient::EX_BAD_DISPLAY));
ramindani431aad42022-02-01 21:44:29 +0000841 ASSERT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
ramindani2740bac2021-11-24 22:58:32 +0000842}
843
ramindani431aad42022-02-01 21:44:29 +0000844TEST_P(GraphicsComposerAidlTest, DestroyLayer_BadLayerError) {
ramindani2740bac2021-11-24 22:58:32 +0000845 // We haven't created any layers yet, so any id should be invalid
ramindani431aad42022-02-01 21:44:29 +0000846 const auto& status = mComposerClient->destroyLayer(getPrimaryDisplayId(), /*layer*/ 1);
ramindani2740bac2021-11-24 22:58:32 +0000847
ramindani431aad42022-02-01 21:44:29 +0000848 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000849 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_LAYER));
ramindani2740bac2021-11-24 22:58:32 +0000850}
851
ramindani431aad42022-02-01 21:44:29 +0000852TEST_P(GraphicsComposerAidlTest, GetActiveConfig_BadDisplay) {
853 const auto& [status, _] = mComposerClient->getActiveConfig(getInvalidDisplayId());
ramindani2740bac2021-11-24 22:58:32 +0000854
ramindani431aad42022-02-01 21:44:29 +0000855 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000856 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani2740bac2021-11-24 22:58:32 +0000857}
858
859TEST_P(GraphicsComposerAidlTest, GetDisplayConfig) {
ramindani431aad42022-02-01 21:44:29 +0000860 const auto& [status, _] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
861 EXPECT_TRUE(status.isOk());
ramindani2740bac2021-11-24 22:58:32 +0000862}
863
ramindani431aad42022-02-01 21:44:29 +0000864TEST_P(GraphicsComposerAidlTest, GetDisplayConfig_BadDisplay) {
865 const auto& [status, _] = mComposerClient->getDisplayConfigs(getInvalidDisplayId());
ramindani2740bac2021-11-24 22:58:32 +0000866
ramindani431aad42022-02-01 21:44:29 +0000867 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000868 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani2740bac2021-11-24 22:58:32 +0000869}
870
871TEST_P(GraphicsComposerAidlTest, GetDisplayName) {
ramindani431aad42022-02-01 21:44:29 +0000872 const auto& [status, _] = mComposerClient->getDisplayName(getPrimaryDisplayId());
873 EXPECT_TRUE(status.isOk());
ramindani2740bac2021-11-24 22:58:32 +0000874}
875
Sally Qi8ec063f2022-11-12 11:18:56 -0800876TEST_P(GraphicsComposerAidlTest, GetOverlaySupport) {
Dorin Drimus08212492023-02-23 17:06:58 +0000877 const auto& [versionStatus, version] = mComposerClient->getInterfaceVersion();
878 ASSERT_TRUE(versionStatus.isOk());
879 if (version == 1) {
880 GTEST_SUCCEED() << "Device does not support the new API for overlay support";
881 return;
882 }
883
Sally Qic2c392f2023-01-13 14:50:20 -0800884 const auto& [status, properties] = mComposerClient->getOverlaySupport();
Sally Qi2600d342022-08-16 12:46:17 -0700885 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
886 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
887 GTEST_SUCCEED() << "getOverlaySupport is not supported";
888 return;
889 }
890
891 ASSERT_TRUE(status.isOk());
Sally Qic2c392f2023-01-13 14:50:20 -0800892 for (const auto& i : properties.combinations) {
893 for (const auto standard : i.standards) {
894 const auto val = static_cast<int32_t>(standard) &
895 static_cast<int32_t>(common::Dataspace::STANDARD_MASK);
896 ASSERT_TRUE(val == static_cast<int32_t>(standard));
897 }
898 for (const auto transfer : i.transfers) {
899 const auto val = static_cast<int32_t>(transfer) &
900 static_cast<int32_t>(common::Dataspace::TRANSFER_MASK);
901 ASSERT_TRUE(val == static_cast<int32_t>(transfer));
902 }
903 for (const auto range : i.ranges) {
904 const auto val = static_cast<int32_t>(range) &
905 static_cast<int32_t>(common::Dataspace::RANGE_MASK);
906 ASSERT_TRUE(val == static_cast<int32_t>(range));
907 }
908 }
Sally Qi2600d342022-08-16 12:46:17 -0700909}
910
ramindani431aad42022-02-01 21:44:29 +0000911TEST_P(GraphicsComposerAidlTest, GetDisplayPhysicalOrientation_BadDisplay) {
912 const auto& [status, _] = mComposerClient->getDisplayPhysicalOrientation(getInvalidDisplayId());
Ady Abrahamae12e382022-01-13 18:06:21 -0800913
ramindani431aad42022-02-01 21:44:29 +0000914 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000915 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
Ady Abrahamae12e382022-01-13 18:06:21 -0800916}
917
918TEST_P(GraphicsComposerAidlTest, GetDisplayPhysicalOrientation) {
919 const auto allowedDisplayOrientations = std::array<Transform, 4>{
920 Transform::NONE,
921 Transform::ROT_90,
922 Transform::ROT_180,
923 Transform::ROT_270,
924 };
925
ramindani431aad42022-02-01 21:44:29 +0000926 const auto& [status, displayOrientation] =
927 mComposerClient->getDisplayPhysicalOrientation(getPrimaryDisplayId());
Ady Abrahamae12e382022-01-13 18:06:21 -0800928
ramindani431aad42022-02-01 21:44:29 +0000929 EXPECT_TRUE(status.isOk());
Ady Abrahamae12e382022-01-13 18:06:21 -0800930 EXPECT_NE(std::find(allowedDisplayOrientations.begin(), allowedDisplayOrientations.end(),
931 displayOrientation),
932 allowedDisplayOrientations.end());
933}
934
ramindani2740bac2021-11-24 22:58:32 +0000935TEST_P(GraphicsComposerAidlTest, SetClientTargetSlotCount) {
ramindani431aad42022-02-01 21:44:29 +0000936 EXPECT_TRUE(mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kBufferSlotCount)
937 .isOk());
ramindani2740bac2021-11-24 22:58:32 +0000938}
939
940TEST_P(GraphicsComposerAidlTest, SetActiveConfig) {
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& [configStatus, config1] =
948 mComposerClient->getActiveConfig(getPrimaryDisplayId());
949 EXPECT_TRUE(configStatus.isOk());
ramindani2740bac2021-11-24 22:58:32 +0000950 EXPECT_EQ(config, config1);
951 }
952}
953
954TEST_P(GraphicsComposerAidlTest, SetActiveConfigPowerCycle) {
ramindani431aad42022-02-01 21:44:29 +0000955 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
956 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
ramindani2740bac2021-11-24 22:58:32 +0000957
ramindani431aad42022-02-01 21:44:29 +0000958 const auto& [status, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
959 EXPECT_TRUE(status.isOk());
960
961 for (const auto& config : configs) {
962 auto display = getEditablePrimaryDisplay();
963 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config).isOk());
964 const auto& [config1Status, config1] =
965 mComposerClient->getActiveConfig(getPrimaryDisplayId());
966 EXPECT_TRUE(config1Status.isOk());
ramindani2740bac2021-11-24 22:58:32 +0000967 EXPECT_EQ(config, config1);
968
ramindani431aad42022-02-01 21:44:29 +0000969 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
970 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
971 const auto& [config2Status, config2] =
972 mComposerClient->getActiveConfig(getPrimaryDisplayId());
973 EXPECT_TRUE(config2Status.isOk());
974 EXPECT_EQ(config, config2);
ramindani2740bac2021-11-24 22:58:32 +0000975 }
976}
977
ramindani2740bac2021-11-24 22:58:32 +0000978TEST_P(GraphicsComposerAidlTest, SetPowerModeUnsupported) {
ramindani431aad42022-02-01 21:44:29 +0000979 const auto& [status, capabilities] =
980 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
981 ASSERT_TRUE(status.isOk());
982
Ady Abraham6679baf2021-12-08 18:28:27 -0800983 const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
984 DisplayCapability::DOZE) != capabilities.end();
985 const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
986 DisplayCapability::SUSPEND) != capabilities.end();
ramindani2740bac2021-11-24 22:58:32 +0000987
ramindani431aad42022-02-01 21:44:29 +0000988 if (!isDozeSupported) {
989 const auto& powerModeDozeStatus =
990 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE);
991 EXPECT_FALSE(powerModeDozeStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000992 EXPECT_NO_FATAL_FAILURE(
993 assertServiceSpecificError(powerModeDozeStatus, IComposerClient::EX_UNSUPPORTED));
ramindani431aad42022-02-01 21:44:29 +0000994
995 const auto& powerModeDozeSuspendStatus =
996 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE_SUSPEND);
997 EXPECT_FALSE(powerModeDozeSuspendStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000998 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeDozeSuspendStatus,
999 IComposerClient::EX_UNSUPPORTED));
ramindani2740bac2021-11-24 22:58:32 +00001000 }
Ady Abraham6679baf2021-12-08 18:28:27 -08001001
1002 if (!isSuspendSupported) {
ramindani431aad42022-02-01 21:44:29 +00001003 const auto& powerModeSuspendStatus =
1004 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON_SUSPEND);
1005 EXPECT_FALSE(powerModeSuspendStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +00001006 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeSuspendStatus,
1007 IComposerClient::EX_UNSUPPORTED));
Ady Abraham6679baf2021-12-08 18:28:27 -08001008
ramindani431aad42022-02-01 21:44:29 +00001009 const auto& powerModeDozeSuspendStatus =
1010 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE_SUSPEND);
1011 EXPECT_FALSE(powerModeDozeSuspendStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +00001012 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeDozeSuspendStatus,
1013 IComposerClient::EX_UNSUPPORTED));
Ady Abraham6679baf2021-12-08 18:28:27 -08001014 }
ramindani2740bac2021-11-24 22:58:32 +00001015}
1016
1017TEST_P(GraphicsComposerAidlTest, SetVsyncEnabled) {
ramindani431aad42022-02-01 21:44:29 +00001018 mComposerClient->setVsyncAllowed(true);
ramindani2740bac2021-11-24 22:58:32 +00001019
ramindani431aad42022-02-01 21:44:29 +00001020 EXPECT_TRUE(mComposerClient->setVsync(getPrimaryDisplayId(), true).isOk());
ramindani2740bac2021-11-24 22:58:32 +00001021 usleep(60 * 1000);
ramindani431aad42022-02-01 21:44:29 +00001022 EXPECT_TRUE(mComposerClient->setVsync(getPrimaryDisplayId(), false).isOk());
ramindani2740bac2021-11-24 22:58:32 +00001023
ramindani431aad42022-02-01 21:44:29 +00001024 mComposerClient->setVsyncAllowed(false);
ramindani2740bac2021-11-24 22:58:32 +00001025}
1026
ramindanic2b8d082021-11-06 02:03:50 +00001027TEST_P(GraphicsComposerAidlTest, SetPowerMode) {
ramindani431aad42022-02-01 21:44:29 +00001028 const auto& [status, capabilities] =
1029 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
1030 ASSERT_TRUE(status.isOk());
1031
Ady Abraham6679baf2021-12-08 18:28:27 -08001032 const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
1033 DisplayCapability::DOZE) != capabilities.end();
1034 const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
1035 DisplayCapability::SUSPEND) != capabilities.end();
1036
ramindanic2b8d082021-11-06 02:03:50 +00001037 std::vector<PowerMode> modes;
1038 modes.push_back(PowerMode::OFF);
ramindanic2b8d082021-11-06 02:03:50 +00001039 modes.push_back(PowerMode::ON);
1040
Ady Abraham6679baf2021-12-08 18:28:27 -08001041 if (isSuspendSupported) {
1042 modes.push_back(PowerMode::ON_SUSPEND);
1043 }
1044
ramindani770d7082021-11-30 00:36:42 +00001045 if (isDozeSupported) {
1046 modes.push_back(PowerMode::DOZE);
Ady Abraham6679baf2021-12-08 18:28:27 -08001047 }
1048
1049 if (isSuspendSupported && isDozeSupported) {
ramindani770d7082021-11-30 00:36:42 +00001050 modes.push_back(PowerMode::DOZE_SUSPEND);
1051 }
1052
ramindanic2b8d082021-11-06 02:03:50 +00001053 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001054 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindanic2b8d082021-11-06 02:03:50 +00001055 }
1056}
1057
1058TEST_P(GraphicsComposerAidlTest, SetPowerModeVariations) {
ramindani431aad42022-02-01 21:44:29 +00001059 const auto& [status, capabilities] =
1060 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
1061 ASSERT_TRUE(status.isOk());
1062
Ady Abraham6679baf2021-12-08 18:28:27 -08001063 const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
1064 DisplayCapability::DOZE) != capabilities.end();
1065 const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
1066 DisplayCapability::SUSPEND) != capabilities.end();
1067
ramindanic2b8d082021-11-06 02:03:50 +00001068 std::vector<PowerMode> modes;
1069
1070 modes.push_back(PowerMode::OFF);
ramindani770d7082021-11-30 00:36:42 +00001071 modes.push_back(PowerMode::ON);
ramindanic2b8d082021-11-06 02:03:50 +00001072 modes.push_back(PowerMode::OFF);
ramindanic2b8d082021-11-06 02:03:50 +00001073 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001074 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindanic2b8d082021-11-06 02:03:50 +00001075 }
ramindani770d7082021-11-30 00:36:42 +00001076 modes.clear();
ramindanic2b8d082021-11-06 02:03:50 +00001077
ramindani770d7082021-11-30 00:36:42 +00001078 modes.push_back(PowerMode::OFF);
1079 modes.push_back(PowerMode::OFF);
1080 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001081 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindani770d7082021-11-30 00:36:42 +00001082 }
ramindanic2b8d082021-11-06 02:03:50 +00001083 modes.clear();
1084
1085 modes.push_back(PowerMode::ON);
1086 modes.push_back(PowerMode::ON);
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();
1091
Ady Abraham6679baf2021-12-08 18:28:27 -08001092 if (isSuspendSupported) {
1093 modes.push_back(PowerMode::ON_SUSPEND);
1094 modes.push_back(PowerMode::ON_SUSPEND);
1095 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001096 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
Ady Abraham6679baf2021-12-08 18:28:27 -08001097 }
1098 modes.clear();
ramindanic2b8d082021-11-06 02:03:50 +00001099 }
1100
ramindanic2b8d082021-11-06 02:03:50 +00001101 if (isDozeSupported) {
ramindanic2b8d082021-11-06 02:03:50 +00001102 modes.push_back(PowerMode::DOZE);
1103 modes.push_back(PowerMode::DOZE);
ramindanic2b8d082021-11-06 02:03:50 +00001104 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001105 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindanic2b8d082021-11-06 02:03:50 +00001106 }
ramindanic2b8d082021-11-06 02:03:50 +00001107 modes.clear();
Ady Abraham6679baf2021-12-08 18:28:27 -08001108 }
ramindanic2b8d082021-11-06 02:03:50 +00001109
Ady Abraham6679baf2021-12-08 18:28:27 -08001110 if (isSuspendSupported && isDozeSupported) {
ramindanic2b8d082021-11-06 02:03:50 +00001111 modes.push_back(PowerMode::DOZE_SUSPEND);
1112 modes.push_back(PowerMode::DOZE_SUSPEND);
ramindanic2b8d082021-11-06 02:03:50 +00001113 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001114 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindanic2b8d082021-11-06 02:03:50 +00001115 }
Ady Abraham6679baf2021-12-08 18:28:27 -08001116 modes.clear();
ramindanic2b8d082021-11-06 02:03:50 +00001117 }
1118}
1119
ramindani431aad42022-02-01 21:44:29 +00001120TEST_P(GraphicsComposerAidlTest, SetPowerMode_BadDisplay) {
1121 const auto& status = mComposerClient->setPowerMode(getInvalidDisplayId(), PowerMode::ON);
ramindanic2b8d082021-11-06 02:03:50 +00001122
ramindani431aad42022-02-01 21:44:29 +00001123 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00001124 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindanic2b8d082021-11-06 02:03:50 +00001125}
1126
ramindani431aad42022-02-01 21:44:29 +00001127TEST_P(GraphicsComposerAidlTest, SetPowerMode_BadParameter) {
1128 const auto& status =
1129 mComposerClient->setPowerMode(getPrimaryDisplayId(), static_cast<PowerMode>(-1));
ramindanic2b8d082021-11-06 02:03:50 +00001130
ramindani431aad42022-02-01 21:44:29 +00001131 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00001132 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
ramindanic2b8d082021-11-06 02:03:50 +00001133}
1134
ramindanic2b8d082021-11-06 02:03:50 +00001135TEST_P(GraphicsComposerAidlTest, GetDataspaceSaturationMatrix) {
ramindani431aad42022-02-01 21:44:29 +00001136 const auto& [status, matrix] =
1137 mComposerClient->getDataspaceSaturationMatrix(common::Dataspace::SRGB_LINEAR);
1138 ASSERT_TRUE(status.isOk());
1139 ASSERT_EQ(16, matrix.size()); // matrix should not be empty if call succeeded.
ramindanideb059e2021-11-18 01:57:25 +00001140
ramindanic2b8d082021-11-06 02:03:50 +00001141 // the last row is known
ramindani431aad42022-02-01 21:44:29 +00001142 EXPECT_EQ(0.0f, matrix[12]);
1143 EXPECT_EQ(0.0f, matrix[13]);
1144 EXPECT_EQ(0.0f, matrix[14]);
1145 EXPECT_EQ(1.0f, matrix[15]);
ramindanic2b8d082021-11-06 02:03:50 +00001146}
1147
ramindani431aad42022-02-01 21:44:29 +00001148TEST_P(GraphicsComposerAidlTest, GetDataspaceSaturationMatrix_BadParameter) {
1149 const auto& [status, matrix] =
1150 mComposerClient->getDataspaceSaturationMatrix(common::Dataspace::UNKNOWN);
ramindanic2b8d082021-11-06 02:03:50 +00001151
ramindani431aad42022-02-01 21:44:29 +00001152 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00001153 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
ramindanic2b8d082021-11-06 02:03:50 +00001154}
1155
ramindanidcfe3a82021-11-29 17:00:31 +00001156// Tests for Command.
1157class GraphicsComposerAidlCommandTest : public GraphicsComposerAidlTest {
1158 protected:
ramindanidcfe3a82021-11-29 17:00:31 +00001159 void TearDown() override {
Ady Abraham3192f3d2021-12-03 16:08:56 -08001160 const auto errors = mReader.takeErrors();
1161 ASSERT_TRUE(mReader.takeErrors().empty());
ramindani431aad42022-02-01 21:44:29 +00001162 ASSERT_TRUE(mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty());
Ady Abraham3192f3d2021-12-03 16:08:56 -08001163
ramindanidcfe3a82021-11-29 17:00:31 +00001164 ASSERT_NO_FATAL_FAILURE(GraphicsComposerAidlTest::TearDown());
1165 }
1166
1167 void execute() {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001168 std::vector<CommandResultPayload> payloads;
1169 for (auto& [_, writer] : mWriters) {
1170 const auto& commands = writer.getPendingCommands();
1171 if (commands.empty()) {
1172 writer.reset();
1173 continue;
1174 }
1175
1176 auto [status, results] = mComposerClient->executeCommands(commands);
1177 ASSERT_TRUE(status.isOk()) << "executeCommands failed " << status.getDescription();
1178 writer.reset();
1179
1180 payloads.reserve(payloads.size() + results.size());
1181 payloads.insert(payloads.end(), std::make_move_iterator(results.begin()),
1182 std::make_move_iterator(results.end()));
ramindanidcfe3a82021-11-29 17:00:31 +00001183 }
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001184 mReader.parse(std::move(payloads));
ramindanidcfe3a82021-11-29 17:00:31 +00001185 }
1186
1187 static inline auto toTimePoint(nsecs_t time) {
1188 return std::chrono::time_point<std::chrono::steady_clock>(std::chrono::nanoseconds(time));
1189 }
1190
ramindanidcfe3a82021-11-29 17:00:31 +00001191 void forEachTwoConfigs(int64_t display, std::function<void(int32_t, int32_t)> func) {
ramindani431aad42022-02-01 21:44:29 +00001192 const auto& [status, displayConfigs] = mComposerClient->getDisplayConfigs(display);
1193 ASSERT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001194 for (const int32_t config1 : displayConfigs) {
1195 for (const int32_t config2 : displayConfigs) {
1196 if (config1 != config2) {
1197 func(config1, config2);
1198 }
1199 }
1200 }
1201 }
1202
1203 void waitForVsyncPeriodChange(int64_t display, const VsyncPeriodChangeTimeline& timeline,
1204 int64_t desiredTimeNanos, int64_t oldPeriodNanos,
1205 int64_t newPeriodNanos) {
1206 const auto kChangeDeadline = toTimePoint(timeline.newVsyncAppliedTimeNanos) + 100ms;
1207 while (std::chrono::steady_clock::now() <= kChangeDeadline) {
ramindani431aad42022-02-01 21:44:29 +00001208 const auto& [status, vsyncPeriodNanos] =
1209 mComposerClient->getDisplayVsyncPeriod(display);
1210 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001211 if (systemTime() <= desiredTimeNanos) {
1212 EXPECT_EQ(vsyncPeriodNanos, oldPeriodNanos);
1213 } else if (vsyncPeriodNanos == newPeriodNanos) {
1214 break;
1215 }
1216 std::this_thread::sleep_for(std::chrono::nanoseconds(oldPeriodNanos));
1217 }
1218 }
1219
ramindani9dd8c482023-02-21 18:07:56 -08001220 bool checkIfCallbackRefreshRateChangedDebugEnabledReceived(
1221 std::function<bool(RefreshRateChangedDebugData)> filter) {
1222 const auto list = mComposerClient->takeListOfRefreshRateChangedDebugData();
1223 return std::any_of(list.begin(), list.end(), [&](auto refreshRateChangedDebugData) {
1224 return filter(refreshRateChangedDebugData);
1225 });
1226 }
1227
Brian Lindahlca3eef22022-12-09 00:32:11 -07001228 sp<GraphicBuffer> allocate(::android::PixelFormat pixelFormat) {
Brian Lindahl14bd07b2023-01-17 14:54:39 -07001229 return sp<GraphicBuffer>::make(
1230 static_cast<uint32_t>(getPrimaryDisplay().getDisplayWidth()),
1231 static_cast<uint32_t>(getPrimaryDisplay().getDisplayHeight()), pixelFormat,
1232 /*layerCount*/ 1U,
1233 (static_cast<uint64_t>(common::BufferUsage::CPU_WRITE_OFTEN) |
1234 static_cast<uint64_t>(common::BufferUsage::CPU_READ_OFTEN) |
1235 static_cast<uint64_t>(common::BufferUsage::COMPOSER_OVERLAY)),
1236 "VtsHalGraphicsComposer3_TargetTest");
Brian Lindahlca3eef22022-12-09 00:32:11 -07001237 }
1238
ramindanidcfe3a82021-11-29 17:00:31 +00001239 void sendRefreshFrame(const VtsDisplay& display, const VsyncPeriodChangeTimeline* timeline) {
1240 if (timeline != nullptr) {
1241 // Refresh time should be before newVsyncAppliedTimeNanos
1242 EXPECT_LT(timeline->refreshTimeNanos, timeline->newVsyncAppliedTimeNanos);
1243
1244 std::this_thread::sleep_until(toTimePoint(timeline->refreshTimeNanos));
1245 }
1246
ramindani431aad42022-02-01 21:44:29 +00001247 EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::ON).isOk());
1248 EXPECT_TRUE(mComposerClient
1249 ->setColorMode(display.getDisplayId(), ColorMode::NATIVE,
1250 RenderIntent::COLORIMETRIC)
1251 .isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001252
ramindani431aad42022-02-01 21:44:29 +00001253 const auto& [status, layer] =
1254 mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount);
1255 EXPECT_TRUE(status.isOk());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001256 auto& writer = getWriter(display.getDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001257 {
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001258 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindanidcfe3a82021-11-29 17:00:31 +00001259 ASSERT_NE(nullptr, buffer);
1260 ASSERT_EQ(::android::OK, buffer->initCheck());
1261 ASSERT_NE(nullptr, buffer->handle);
1262
ramindani431aad42022-02-01 21:44:29 +00001263 configureLayer(display, layer, Composition::DEVICE, display.getFrameRect(),
1264 display.getCrop());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001265 writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, buffer->handle,
1266 /*acquireFence*/ -1);
1267 writer.setLayerDataspace(display.getDisplayId(), layer, common::Dataspace::UNKNOWN);
ramindanidcfe3a82021-11-29 17:00:31 +00001268
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001269 writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp);
ramindanidcfe3a82021-11-29 17:00:31 +00001270 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001271 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001272
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001273 writer.presentDisplay(display.getDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001274 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001275 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001276 }
1277
1278 {
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001279 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindanidcfe3a82021-11-29 17:00:31 +00001280 ASSERT_NE(nullptr, buffer->handle);
1281
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001282 writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, buffer->handle,
1283 /*acquireFence*/ -1);
1284 writer.setLayerSurfaceDamage(display.getDisplayId(), layer,
1285 std::vector<Rect>(1, {0, 0, 10, 10}));
1286 writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp);
ramindanidcfe3a82021-11-29 17:00:31 +00001287 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001288 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001289
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001290 writer.presentDisplay(display.getDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001291 execute();
1292 }
1293
ramindani431aad42022-02-01 21:44:29 +00001294 EXPECT_TRUE(mComposerClient->destroyLayer(display.getDisplayId(), layer).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001295 }
1296
Ady Abraham72c5b502021-12-10 17:23:39 -08001297 sp<::android::Fence> presentAndGetFence(
1298 std::optional<ClockMonotonicTimestamp> expectedPresentTime) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001299 auto& writer = getWriter(getPrimaryDisplayId());
1300 writer.validateDisplay(getPrimaryDisplayId(), expectedPresentTime);
Ady Abraham72c5b502021-12-10 17:23:39 -08001301 execute();
1302 EXPECT_TRUE(mReader.takeErrors().empty());
1303
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001304 writer.presentDisplay(getPrimaryDisplayId());
Ady Abraham72c5b502021-12-10 17:23:39 -08001305 execute();
1306 EXPECT_TRUE(mReader.takeErrors().empty());
1307
ramindani431aad42022-02-01 21:44:29 +00001308 auto presentFence = mReader.takePresentFence(getPrimaryDisplayId());
Ady Abraham46219f52021-12-20 09:44:31 -08001309 // take ownership
1310 const int fenceOwner = presentFence.get();
1311 *presentFence.getR() = -1;
1312 EXPECT_NE(-1, fenceOwner);
1313 return sp<::android::Fence>::make(fenceOwner);
Ady Abraham72c5b502021-12-10 17:23:39 -08001314 }
1315
1316 int32_t getVsyncPeriod() {
ramindani431aad42022-02-01 21:44:29 +00001317 const auto& [status, activeConfig] =
1318 mComposerClient->getActiveConfig(getPrimaryDisplayId());
1319 EXPECT_TRUE(status.isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001320
ramindani431aad42022-02-01 21:44:29 +00001321 const auto& [vsyncPeriodStatus, vsyncPeriod] = mComposerClient->getDisplayAttribute(
1322 getPrimaryDisplayId(), activeConfig, DisplayAttribute::VSYNC_PERIOD);
1323 EXPECT_TRUE(vsyncPeriodStatus.isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001324 return vsyncPeriod;
1325 }
1326
ramindani9dd8c482023-02-21 18:07:56 -08001327 int64_t createOnScreenLayer(Composition composition = Composition::DEVICE) {
ramindani431aad42022-02-01 21:44:29 +00001328 const auto& [status, layer] =
1329 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1330 EXPECT_TRUE(status.isOk());
1331 Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
1332 getPrimaryDisplay().getDisplayHeight()};
1333 FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
1334 (float)getPrimaryDisplay().getDisplayHeight()};
ramindani9dd8c482023-02-21 18:07:56 -08001335 configureLayer(getPrimaryDisplay(), layer, composition, displayFrame, cropRect);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001336 auto& writer = getWriter(getPrimaryDisplayId());
1337 writer.setLayerDataspace(getPrimaryDisplayId(), layer, common::Dataspace::UNKNOWN);
Ady Abraham72c5b502021-12-10 17:23:39 -08001338 return layer;
1339 }
1340
ramindani9dd8c482023-02-21 18:07:56 -08001341 void sendBufferUpdate(int64_t layer) {
1342 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1343 ASSERT_NE(nullptr, buffer->handle);
1344
1345 auto& writer = getWriter(getPrimaryDisplayId());
1346 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer->handle,
1347 /*acquireFence*/ -1);
1348
1349 const sp<::android::Fence> presentFence =
1350 presentAndGetFence(ComposerClientWriter::kNoTimestamp);
1351 presentFence->waitForever(LOG_TAG);
1352 }
1353
Midas Chiena0b56bd2022-01-13 23:27:33 +08001354 bool hasDisplayCapability(int64_t display, DisplayCapability cap) {
ramindani431aad42022-02-01 21:44:29 +00001355 const auto& [status, capabilities] = mComposerClient->getDisplayCapabilities(display);
1356 EXPECT_TRUE(status.isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08001357
1358 return std::find(capabilities.begin(), capabilities.end(), cap) != capabilities.end();
1359 }
1360
ramindanidcfe3a82021-11-29 17:00:31 +00001361 void Test_setActiveConfigWithConstraints(const TestParameters& params) {
1362 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +00001363 forEachTwoConfigs(display.getDisplayId(), [&](int32_t config1, int32_t config2) {
1364 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001365 sendRefreshFrame(display, nullptr);
1366
ramindani431aad42022-02-01 21:44:29 +00001367 const auto displayConfigGroup1 = display.getDisplayConfig(config1);
1368 int32_t vsyncPeriod1 = displayConfigGroup1.vsyncPeriod;
1369 int32_t configGroup1 = displayConfigGroup1.configGroup;
1370
1371 const auto displayConfigGroup2 = display.getDisplayConfig(config2);
1372 int32_t vsyncPeriod2 = displayConfigGroup2.vsyncPeriod;
1373 int32_t configGroup2 = displayConfigGroup2.configGroup;
ramindanidcfe3a82021-11-29 17:00:31 +00001374
1375 if (vsyncPeriod1 == vsyncPeriod2) {
1376 return; // continue
1377 }
1378
1379 // We don't allow delayed change when changing config groups
1380 if (params.delayForChange > 0 && configGroup1 != configGroup2) {
1381 return; // continue
1382 }
1383
ramindanidcfe3a82021-11-29 17:00:31 +00001384 VsyncPeriodChangeConstraints constraints = {
1385 .desiredTimeNanos = systemTime() + params.delayForChange,
1386 .seamlessRequired = false};
ramindani431aad42022-02-01 21:44:29 +00001387 const auto& [status, timeline] = mComposerClient->setActiveConfigWithConstraints(
1388 &display, config2, constraints);
1389 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001390
1391 EXPECT_TRUE(timeline.newVsyncAppliedTimeNanos >= constraints.desiredTimeNanos);
1392 // Refresh rate should change within a reasonable time
1393 constexpr std::chrono::nanoseconds kReasonableTimeForChange = 1s; // 1 second
1394 EXPECT_TRUE(timeline.newVsyncAppliedTimeNanos - constraints.desiredTimeNanos <=
1395 kReasonableTimeForChange.count());
1396
1397 if (timeline.refreshRequired) {
1398 if (params.refreshMiss) {
1399 // Miss the refresh frame on purpose to make sure the implementation sends a
1400 // callback
1401 std::this_thread::sleep_until(toTimePoint(timeline.refreshTimeNanos) +
1402 100ms);
1403 }
1404 sendRefreshFrame(display, &timeline);
1405 }
ramindani431aad42022-02-01 21:44:29 +00001406 waitForVsyncPeriodChange(display.getDisplayId(), timeline,
1407 constraints.desiredTimeNanos, vsyncPeriod1, vsyncPeriod2);
ramindanidcfe3a82021-11-29 17:00:31 +00001408
1409 // At this point the refresh rate should have changed already, however in rare
1410 // cases the implementation might have missed the deadline. In this case a new
1411 // timeline should have been provided.
ramindani431aad42022-02-01 21:44:29 +00001412 auto newTimeline = mComposerClient->takeLastVsyncPeriodChangeTimeline();
ramindanidcfe3a82021-11-29 17:00:31 +00001413 if (timeline.refreshRequired && params.refreshMiss) {
1414 EXPECT_TRUE(newTimeline.has_value());
1415 }
1416
1417 if (newTimeline.has_value()) {
1418 if (newTimeline->refreshRequired) {
1419 sendRefreshFrame(display, &newTimeline.value());
1420 }
ramindani431aad42022-02-01 21:44:29 +00001421 waitForVsyncPeriodChange(display.getDisplayId(), newTimeline.value(),
ramindanidcfe3a82021-11-29 17:00:31 +00001422 constraints.desiredTimeNanos, vsyncPeriod1,
1423 vsyncPeriod2);
1424 }
1425
ramindani431aad42022-02-01 21:44:29 +00001426 const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanos] =
1427 mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
1428 EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001429 EXPECT_EQ(vsyncPeriodNanos, vsyncPeriod2);
1430 });
1431 }
1432 }
1433
Ady Abraham72c5b502021-12-10 17:23:39 -08001434 void Test_expectedPresentTime(std::optional<int> framesDelay) {
Jason Macnak325e8232022-01-24 14:48:55 -08001435 if (hasCapability(Capability::PRESENT_FENCE_IS_NOT_RELIABLE)) {
1436 GTEST_SUCCEED() << "Device has unreliable present fences capability, skipping";
1437 return;
1438 }
1439
ramindani431aad42022-02-01 21:44:29 +00001440 ASSERT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001441
1442 const auto vsyncPeriod = getVsyncPeriod();
1443
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001444 const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1445 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
Ady Abraham72c5b502021-12-10 17:23:39 -08001446 ASSERT_NE(nullptr, buffer1);
1447 ASSERT_NE(nullptr, buffer2);
1448
1449 const auto layer = createOnScreenLayer();
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001450 auto& writer = getWriter(getPrimaryDisplayId());
1451 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer1->handle,
1452 /*acquireFence*/ -1);
Ady Abraham72c5b502021-12-10 17:23:39 -08001453 const sp<::android::Fence> presentFence1 =
1454 presentAndGetFence(ComposerClientWriter::kNoTimestamp);
1455 presentFence1->waitForever(LOG_TAG);
1456
1457 auto expectedPresentTime = presentFence1->getSignalTime() + vsyncPeriod;
1458 if (framesDelay.has_value()) {
1459 expectedPresentTime += *framesDelay * vsyncPeriod;
1460 }
1461
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001462 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer2->handle,
1463 /*acquireFence*/ -1);
Ady Abraham72c5b502021-12-10 17:23:39 -08001464 const auto setExpectedPresentTime = [&]() -> std::optional<ClockMonotonicTimestamp> {
1465 if (!framesDelay.has_value()) {
1466 return ComposerClientWriter::kNoTimestamp;
1467 } else if (*framesDelay == 0) {
1468 return ClockMonotonicTimestamp{0};
1469 }
1470 return ClockMonotonicTimestamp{expectedPresentTime};
1471 }();
1472
1473 const sp<::android::Fence> presentFence2 = presentAndGetFence(setExpectedPresentTime);
1474 presentFence2->waitForever(LOG_TAG);
1475
1476 const auto actualPresentTime = presentFence2->getSignalTime();
Ady Abrahamdf084f32022-01-10 14:10:23 -08001477 EXPECT_GE(actualPresentTime, expectedPresentTime - vsyncPeriod / 2);
Ady Abraham72c5b502021-12-10 17:23:39 -08001478
ramindani431aad42022-02-01 21:44:29 +00001479 ASSERT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001480 }
1481
ramindani431aad42022-02-01 21:44:29 +00001482 void configureLayer(const VtsDisplay& display, int64_t layer, Composition composition,
1483 const Rect& displayFrame, const FRect& cropRect) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001484 auto& writer = getWriter(display.getDisplayId());
1485 writer.setLayerCompositionType(display.getDisplayId(), layer, composition);
1486 writer.setLayerDisplayFrame(display.getDisplayId(), layer, displayFrame);
1487 writer.setLayerPlaneAlpha(display.getDisplayId(), layer, /*alpha*/ 1);
1488 writer.setLayerSourceCrop(display.getDisplayId(), layer, cropRect);
1489 writer.setLayerTransform(display.getDisplayId(), layer, static_cast<Transform>(0));
1490 writer.setLayerVisibleRegion(display.getDisplayId(), layer,
1491 std::vector<Rect>(1, displayFrame));
1492 writer.setLayerZOrder(display.getDisplayId(), layer, /*z*/ 10);
1493 writer.setLayerBlendMode(display.getDisplayId(), layer, BlendMode::NONE);
1494 writer.setLayerSurfaceDamage(display.getDisplayId(), layer,
1495 std::vector<Rect>(1, displayFrame));
ramindani431aad42022-02-01 21:44:29 +00001496 }
ramindanidcfe3a82021-11-29 17:00:31 +00001497 // clang-format off
1498 const std::array<float, 16> kIdentity = {{
1499 1.0f, 0.0f, 0.0f, 0.0f,
1500 0.0f, 1.0f, 0.0f, 0.0f,
1501 0.0f, 0.0f, 1.0f, 0.0f,
1502 0.0f, 0.0f, 0.0f, 1.0f,
1503 }};
1504 // clang-format on
1505
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001506 ComposerClientWriter& getWriter(int64_t display) {
1507 auto [it, _] = mWriters.try_emplace(display, display);
1508 return it->second;
1509 }
1510
Ady Abraham91c9d1a2021-12-15 18:14:45 -08001511 ComposerClientReader mReader;
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001512
1513 private:
1514 std::unordered_map<int64_t, ComposerClientWriter> mWriters;
ramindanidcfe3a82021-11-29 17:00:31 +00001515};
1516
ramindani431aad42022-02-01 21:44:29 +00001517TEST_P(GraphicsComposerAidlCommandTest, SetColorTransform) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001518 auto& writer = getWriter(getPrimaryDisplayId());
1519 writer.setColorTransform(getPrimaryDisplayId(), kIdentity.data());
ramindanidcfe3a82021-11-29 17:00:31 +00001520 execute();
1521}
1522
1523TEST_P(GraphicsComposerAidlCommandTest, SetLayerColorTransform) {
ramindani431aad42022-02-01 21:44:29 +00001524 const auto& [status, layer] =
1525 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1526 EXPECT_TRUE(status.isOk());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001527 auto& writer = getWriter(getPrimaryDisplayId());
1528 writer.setLayerColorTransform(getPrimaryDisplayId(), layer, kIdentity.data());
ramindanidcfe3a82021-11-29 17:00:31 +00001529 execute();
1530
Ady Abraham3192f3d2021-12-03 16:08:56 -08001531 const auto errors = mReader.takeErrors();
Jason Macnak062bc9a2022-01-20 15:00:09 -08001532 if (errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_UNSUPPORTED) {
ramindanidcfe3a82021-11-29 17:00:31 +00001533 GTEST_SUCCEED() << "setLayerColorTransform is not supported";
1534 return;
1535 }
1536}
1537
Alec Mouri60564e12021-12-09 18:48:20 -08001538TEST_P(GraphicsComposerAidlCommandTest, SetDisplayBrightness) {
ramindani431aad42022-02-01 21:44:29 +00001539 const auto& [status, capabilities] =
1540 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
1541 ASSERT_TRUE(status.isOk());
Alec Mouri60564e12021-12-09 18:48:20 -08001542 bool brightnessSupport = std::find(capabilities.begin(), capabilities.end(),
1543 DisplayCapability::BRIGHTNESS) != capabilities.end();
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001544 auto& writer = getWriter(getPrimaryDisplayId());
Alec Mouri60564e12021-12-09 18:48:20 -08001545 if (!brightnessSupport) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001546 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.5f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001547 execute();
1548 const auto errors = mReader.takeErrors();
1549 EXPECT_EQ(1, errors.size());
Jason Macnak062bc9a2022-01-20 15:00:09 -08001550 EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, errors[0].errorCode);
Alec Mouri60564e12021-12-09 18:48:20 -08001551 GTEST_SUCCEED() << "SetDisplayBrightness is not supported";
1552 return;
1553 }
1554
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001555 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001556 execute();
1557 EXPECT_TRUE(mReader.takeErrors().empty());
1558
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001559 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.5f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001560 execute();
1561 EXPECT_TRUE(mReader.takeErrors().empty());
1562
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001563 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 1.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001564 execute();
1565 EXPECT_TRUE(mReader.takeErrors().empty());
1566
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001567 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ -1.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001568 execute();
1569 EXPECT_TRUE(mReader.takeErrors().empty());
1570
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001571 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 2.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001572 execute();
1573 {
1574 const auto errors = mReader.takeErrors();
ramindanib3bdf052022-01-12 18:27:05 +00001575 ASSERT_EQ(1, errors.size());
Alec Mouri60564e12021-12-09 18:48:20 -08001576 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
1577 }
1578
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001579 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ -2.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001580 execute();
1581 {
1582 const auto errors = mReader.takeErrors();
ramindanib3bdf052022-01-12 18:27:05 +00001583 ASSERT_EQ(1, errors.size());
Alec Mouri60564e12021-12-09 18:48:20 -08001584 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
1585 }
1586}
1587
ramindani431aad42022-02-01 21:44:29 +00001588TEST_P(GraphicsComposerAidlCommandTest, SetClientTarget) {
1589 EXPECT_TRUE(mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kBufferSlotCount)
1590 .isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001591
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001592 auto& writer = getWriter(getPrimaryDisplayId());
1593 writer.setClientTarget(getPrimaryDisplayId(), /*slot*/ 0, nullptr, /*acquireFence*/ -1,
1594 Dataspace::UNKNOWN, std::vector<Rect>());
ramindanidcfe3a82021-11-29 17:00:31 +00001595
1596 execute();
1597}
1598
ramindani431aad42022-02-01 21:44:29 +00001599TEST_P(GraphicsComposerAidlCommandTest, SetOutputBuffer) {
1600 const auto& [status, virtualDisplayCount] = mComposerClient->getMaxVirtualDisplayCount();
1601 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001602 if (virtualDisplayCount == 0) {
1603 GTEST_SUCCEED() << "no virtual display support";
1604 return;
1605 }
1606
ramindani431aad42022-02-01 21:44:29 +00001607 const auto& [displayStatus, display] = mComposerClient->createVirtualDisplay(
1608 /*width*/ 64, /*height*/ 64, common::PixelFormat::IMPLEMENTATION_DEFINED,
1609 kBufferSlotCount);
1610 EXPECT_TRUE(displayStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001611
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001612 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001613 const auto handle = buffer->handle;
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001614 auto& writer = getWriter(display.display);
1615 writer.setOutputBuffer(display.display, /*slot*/ 0, handle, /*releaseFence*/ -1);
ramindanidcfe3a82021-11-29 17:00:31 +00001616 execute();
1617}
1618
ramindani431aad42022-02-01 21:44:29 +00001619TEST_P(GraphicsComposerAidlCommandTest, ValidDisplay) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001620 auto& writer = getWriter(getPrimaryDisplayId());
1621 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
ramindanidcfe3a82021-11-29 17:00:31 +00001622 execute();
1623}
1624
ramindani431aad42022-02-01 21:44:29 +00001625TEST_P(GraphicsComposerAidlCommandTest, AcceptDisplayChanges) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001626 auto& writer = getWriter(getPrimaryDisplayId());
1627 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
1628 writer.acceptDisplayChanges(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001629 execute();
1630}
1631
ramindani431aad42022-02-01 21:44:29 +00001632TEST_P(GraphicsComposerAidlCommandTest, PresentDisplay) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001633 auto& writer = getWriter(getPrimaryDisplayId());
1634 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
1635 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001636 execute();
1637}
1638
1639/**
1640 * Test IComposerClient::Command::PRESENT_DISPLAY
1641 *
1642 * Test that IComposerClient::Command::PRESENT_DISPLAY works without
1643 * additional call to validateDisplay when only the layer buffer handle and
1644 * surface damage have been set
1645 */
ramindani431aad42022-02-01 21:44:29 +00001646TEST_P(GraphicsComposerAidlCommandTest, PresentDisplayNoLayerStateChanges) {
Jason Macnak325e8232022-01-24 14:48:55 -08001647 if (!hasCapability(Capability::SKIP_VALIDATE)) {
ramindanidcfe3a82021-11-29 17:00:31 +00001648 GTEST_SUCCEED() << "Device does not have skip validate capability, skipping";
1649 return;
1650 }
ramindani431aad42022-02-01 21:44:29 +00001651 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001652
ramindani431aad42022-02-01 21:44:29 +00001653 const auto& [renderIntentsStatus, renderIntents] =
1654 mComposerClient->getRenderIntents(getPrimaryDisplayId(), ColorMode::NATIVE);
1655 EXPECT_TRUE(renderIntentsStatus.isOk());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001656 auto& writer = getWriter(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001657 for (auto intent : renderIntents) {
ramindani431aad42022-02-01 21:44:29 +00001658 EXPECT_TRUE(mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE, intent)
1659 .isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001660
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001661 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001662 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001663 ASSERT_NE(nullptr, handle);
1664
ramindani431aad42022-02-01 21:44:29 +00001665 const auto& [layerStatus, layer] =
1666 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1667 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001668
ramindani431aad42022-02-01 21:44:29 +00001669 Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
1670 getPrimaryDisplay().getDisplayHeight()};
1671 FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
1672 (float)getPrimaryDisplay().getDisplayHeight()};
1673 configureLayer(getPrimaryDisplay(), layer, Composition::CURSOR, displayFrame, cropRect);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001674 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle,
1675 /*acquireFence*/ -1);
1676 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
1677 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
ramindanidcfe3a82021-11-29 17:00:31 +00001678 execute();
ramindani431aad42022-02-01 21:44:29 +00001679 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
ramindanidcfe3a82021-11-29 17:00:31 +00001680 GTEST_SUCCEED() << "Composition change requested, skipping test";
1681 return;
1682 }
1683
Ady Abraham3192f3d2021-12-03 16:08:56 -08001684 ASSERT_TRUE(mReader.takeErrors().empty());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001685 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001686 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001687 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001688
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001689 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001690 const auto handle2 = buffer2->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001691 ASSERT_NE(nullptr, handle2);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001692 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle2,
1693 /*acquireFence*/ -1);
1694 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer,
1695 std::vector<Rect>(1, {0, 0, 10, 10}));
1696 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001697 execute();
1698 }
1699}
1700
ramindani431aad42022-02-01 21:44:29 +00001701TEST_P(GraphicsComposerAidlCommandTest, SetLayerCursorPosition) {
1702 const auto& [layerStatus, layer] =
1703 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1704 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001705
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001706 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001707 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001708 ASSERT_NE(nullptr, handle);
ramindanidcfe3a82021-11-29 17:00:31 +00001709
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001710 auto& writer = getWriter(getPrimaryDisplayId());
1711 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle, /*acquireFence*/ -1);
ramindani431aad42022-02-01 21:44:29 +00001712
1713 Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
1714 getPrimaryDisplay().getDisplayHeight()};
1715 FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
1716 (float)getPrimaryDisplay().getDisplayHeight()};
1717 configureLayer(getPrimaryDisplay(), layer, Composition::CURSOR, displayFrame, cropRect);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001718 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
1719 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
ramindanidcfe3a82021-11-29 17:00:31 +00001720
1721 execute();
Ady Abraham46219f52021-12-20 09:44:31 -08001722
ramindani431aad42022-02-01 21:44:29 +00001723 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
ramindanidcfe3a82021-11-29 17:00:31 +00001724 GTEST_SUCCEED() << "Composition change requested, skipping test";
1725 return;
1726 }
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001727 writer.presentDisplay(getPrimaryDisplayId());
Ady Abraham3192f3d2021-12-03 16:08:56 -08001728 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001729
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001730 writer.setLayerCursorPosition(getPrimaryDisplayId(), layer, /*x*/ 1, /*y*/ 1);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001731 execute();
1732
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001733 writer.setLayerCursorPosition(getPrimaryDisplayId(), layer, /*x*/ 0, /*y*/ 0);
1734 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
1735 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001736 execute();
1737}
1738
ramindani431aad42022-02-01 21:44:29 +00001739TEST_P(GraphicsComposerAidlCommandTest, SetLayerBuffer) {
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001740 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001741 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001742 ASSERT_NE(nullptr, handle);
1743
ramindani431aad42022-02-01 21:44:29 +00001744 const auto& [layerStatus, layer] =
1745 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1746 EXPECT_TRUE(layerStatus.isOk());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001747 auto& writer = getWriter(getPrimaryDisplayId());
1748 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle, /*acquireFence*/ -1);
ramindanidcfe3a82021-11-29 17:00:31 +00001749 execute();
1750}
1751
ramindani431aad42022-02-01 21:44:29 +00001752TEST_P(GraphicsComposerAidlCommandTest, SetLayerSurfaceDamage) {
1753 const auto& [layerStatus, layer] =
1754 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1755 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001756
1757 Rect empty{0, 0, 0, 0};
1758 Rect unit{0, 0, 1, 1};
1759
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001760 auto& writer = getWriter(getPrimaryDisplayId());
1761 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
ramindanidcfe3a82021-11-29 17:00:31 +00001762 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001763 ASSERT_TRUE(mReader.takeErrors().empty());
1764
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001765 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
Ady Abraham3192f3d2021-12-03 16:08:56 -08001766 execute();
1767 ASSERT_TRUE(mReader.takeErrors().empty());
1768
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001769 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>());
Ady Abraham3192f3d2021-12-03 16:08:56 -08001770 execute();
1771 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001772}
1773
ramindani431aad42022-02-01 21:44:29 +00001774TEST_P(GraphicsComposerAidlCommandTest, SetLayerBlockingRegion) {
1775 const auto& [layerStatus, layer] =
1776 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1777 EXPECT_TRUE(layerStatus.isOk());
Leon Scroggins III03318152022-01-13 12:24:19 -05001778
1779 Rect empty{0, 0, 0, 0};
1780 Rect unit{0, 0, 1, 1};
1781
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001782 auto& writer = getWriter(getPrimaryDisplayId());
1783 writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
Leon Scroggins III03318152022-01-13 12:24:19 -05001784 execute();
1785 ASSERT_TRUE(mReader.takeErrors().empty());
1786
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001787 writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
Leon Scroggins III03318152022-01-13 12:24:19 -05001788 execute();
1789 ASSERT_TRUE(mReader.takeErrors().empty());
1790
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001791 writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>());
Leon Scroggins III03318152022-01-13 12:24:19 -05001792 execute();
1793 ASSERT_TRUE(mReader.takeErrors().empty());
1794}
1795
ramindani431aad42022-02-01 21:44:29 +00001796TEST_P(GraphicsComposerAidlCommandTest, SetLayerBlendMode) {
1797 const auto& [layerStatus, layer] =
1798 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1799 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001800
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001801 auto& writer = getWriter(getPrimaryDisplayId());
1802 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::NONE);
ramindanidcfe3a82021-11-29 17:00:31 +00001803 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001804 ASSERT_TRUE(mReader.takeErrors().empty());
1805
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001806 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::PREMULTIPLIED);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001807 execute();
1808 ASSERT_TRUE(mReader.takeErrors().empty());
1809
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001810 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::COVERAGE);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001811 execute();
1812 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001813}
1814
ramindani431aad42022-02-01 21:44:29 +00001815TEST_P(GraphicsComposerAidlCommandTest, SetLayerColor) {
1816 const auto& [layerStatus, layer] =
1817 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1818 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001819
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001820 auto& writer = getWriter(getPrimaryDisplayId());
1821 writer.setLayerColor(getPrimaryDisplayId(), layer, Color{1.0f, 1.0f, 1.0f, 1.0f});
ramindanidcfe3a82021-11-29 17:00:31 +00001822 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001823 ASSERT_TRUE(mReader.takeErrors().empty());
1824
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001825 writer.setLayerColor(getPrimaryDisplayId(), layer, Color{0.0f, 0.0f, 0.0f, 0.0f});
Ady Abraham3192f3d2021-12-03 16:08:56 -08001826 execute();
1827 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001828}
1829
ramindani431aad42022-02-01 21:44:29 +00001830TEST_P(GraphicsComposerAidlCommandTest, SetLayerCompositionType) {
1831 const auto& [layerStatus, layer] =
1832 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1833 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001834
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001835 auto& writer = getWriter(getPrimaryDisplayId());
1836 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::CLIENT);
ramindanidcfe3a82021-11-29 17:00:31 +00001837 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001838 ASSERT_TRUE(mReader.takeErrors().empty());
1839
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001840 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::DEVICE);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001841 execute();
1842 ASSERT_TRUE(mReader.takeErrors().empty());
1843
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001844 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::SOLID_COLOR);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001845 execute();
1846 ASSERT_TRUE(mReader.takeErrors().empty());
1847
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001848 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::CURSOR);
ramindani431aad42022-02-01 21:44:29 +00001849 execute();
1850}
1851
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001852TEST_P(GraphicsComposerAidlCommandTest, DisplayDecoration) {
1853 for (VtsDisplay& display : mDisplays) {
1854 const auto [layerStatus, layer] =
1855 mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount);
1856 EXPECT_TRUE(layerStatus.isOk());
1857
1858 const auto [error, support] =
1859 mComposerClient->getDisplayDecorationSupport(display.getDisplayId());
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001860
Leon Scroggins III91590872022-02-23 09:51:21 -05001861 const auto format = (error.isOk() && support) ? support->format
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001862 : aidl::android::hardware::graphics::common::PixelFormat::RGBA_8888;
1863 const auto decorBuffer = allocate(static_cast<::android::PixelFormat>(format));
1864 ASSERT_NE(nullptr, decorBuffer);
1865 if (::android::OK != decorBuffer->initCheck()) {
1866 if (support) {
1867 FAIL() << "Device advertised display decoration support with format "
1868 << aidl::android::hardware::graphics::common::toString(format)
1869 << " but failed to allocate it!";
1870 } else {
1871 FAIL() << "Device advertised NO display decoration support, but it should "
1872 << "still be able to allocate "
1873 << aidl::android::hardware::graphics::common::toString(format);
1874 }
1875 }
1876
Midas Chien7d55d422022-06-07 02:32:28 +08001877 configureLayer(display, layer, Composition::DISPLAY_DECORATION, display.getFrameRect(),
1878 display.getCrop());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001879 auto& writer = getWriter(display.getDisplayId());
1880 writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, decorBuffer->handle,
1881 /*acquireFence*/ -1);
1882 writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp);
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001883 execute();
1884 if (support) {
1885 ASSERT_TRUE(mReader.takeErrors().empty());
1886 } else {
1887 const auto errors = mReader.takeErrors();
1888 ASSERT_EQ(1, errors.size());
Leon Scroggins III6455e792022-02-24 12:18:58 -05001889 EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, errors[0].errorCode);
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001890 }
1891 }
1892}
1893
ramindani431aad42022-02-01 21:44:29 +00001894TEST_P(GraphicsComposerAidlCommandTest, SetLayerDataspace) {
1895 const auto& [layerStatus, layer] =
1896 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1897 EXPECT_TRUE(layerStatus.isOk());
1898
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001899 auto& writer = getWriter(getPrimaryDisplayId());
1900 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
ramindani431aad42022-02-01 21:44:29 +00001901 execute();
1902}
1903
1904TEST_P(GraphicsComposerAidlCommandTest, SetLayerDisplayFrame) {
1905 const auto& [layerStatus, layer] =
1906 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1907 EXPECT_TRUE(layerStatus.isOk());
1908
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001909 auto& writer = getWriter(getPrimaryDisplayId());
1910 writer.setLayerDisplayFrame(getPrimaryDisplayId(), layer, Rect{0, 0, 1, 1});
ramindani431aad42022-02-01 21:44:29 +00001911 execute();
1912}
1913
1914TEST_P(GraphicsComposerAidlCommandTest, SetLayerPlaneAlpha) {
1915 const auto& [layerStatus, layer] =
1916 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1917 EXPECT_TRUE(layerStatus.isOk());
1918
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001919 auto& writer = getWriter(getPrimaryDisplayId());
1920 writer.setLayerPlaneAlpha(getPrimaryDisplayId(), layer, /*alpha*/ 0.0f);
ramindani431aad42022-02-01 21:44:29 +00001921 execute();
1922 ASSERT_TRUE(mReader.takeErrors().empty());
1923
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001924 writer.setLayerPlaneAlpha(getPrimaryDisplayId(), layer, /*alpha*/ 1.0f);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001925 execute();
1926 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001927}
1928
ramindani431aad42022-02-01 21:44:29 +00001929TEST_P(GraphicsComposerAidlCommandTest, SetLayerSidebandStream) {
Jason Macnak325e8232022-01-24 14:48:55 -08001930 if (!hasCapability(Capability::SIDEBAND_STREAM)) {
ramindanidcfe3a82021-11-29 17:00:31 +00001931 GTEST_SUCCEED() << "no sideband stream support";
1932 return;
1933 }
1934
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001935 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001936 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001937 ASSERT_NE(nullptr, handle);
1938
ramindani431aad42022-02-01 21:44:29 +00001939 const auto& [layerStatus, layer] =
1940 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1941 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001942
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001943 auto& writer = getWriter(getPrimaryDisplayId());
1944 writer.setLayerSidebandStream(getPrimaryDisplayId(), layer, handle);
ramindanidcfe3a82021-11-29 17:00:31 +00001945 execute();
1946}
1947
ramindani431aad42022-02-01 21:44:29 +00001948TEST_P(GraphicsComposerAidlCommandTest, SetLayerSourceCrop) {
1949 const auto& [layerStatus, layer] =
1950 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1951 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001952
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001953 auto& writer = getWriter(getPrimaryDisplayId());
1954 writer.setLayerSourceCrop(getPrimaryDisplayId(), layer, FRect{0.0f, 0.0f, 1.0f, 1.0f});
ramindanidcfe3a82021-11-29 17:00:31 +00001955 execute();
1956}
1957
ramindani431aad42022-02-01 21:44:29 +00001958TEST_P(GraphicsComposerAidlCommandTest, SetLayerTransform) {
1959 const auto& [layerStatus, layer] =
1960 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1961 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001962
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001963 auto& writer = getWriter(getPrimaryDisplayId());
1964 writer.setLayerTransform(getPrimaryDisplayId(), layer, static_cast<Transform>(0));
ramindanidcfe3a82021-11-29 17:00:31 +00001965 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001966 ASSERT_TRUE(mReader.takeErrors().empty());
1967
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001968 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::FLIP_H);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001969 execute();
1970 ASSERT_TRUE(mReader.takeErrors().empty());
1971
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001972 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::FLIP_V);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001973 execute();
1974 ASSERT_TRUE(mReader.takeErrors().empty());
1975
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001976 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_90);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001977 execute();
1978 ASSERT_TRUE(mReader.takeErrors().empty());
1979
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001980 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_180);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001981 execute();
1982 ASSERT_TRUE(mReader.takeErrors().empty());
1983
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001984 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_270);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001985 execute();
1986 ASSERT_TRUE(mReader.takeErrors().empty());
1987
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001988 writer.setLayerTransform(getPrimaryDisplayId(), layer,
1989 static_cast<Transform>(static_cast<int>(Transform::FLIP_H) |
1990 static_cast<int>(Transform::ROT_90)));
Ady Abraham3192f3d2021-12-03 16:08:56 -08001991 execute();
1992 ASSERT_TRUE(mReader.takeErrors().empty());
1993
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001994 writer.setLayerTransform(getPrimaryDisplayId(), layer,
1995 static_cast<Transform>(static_cast<int>(Transform::FLIP_V) |
1996 static_cast<int>(Transform::ROT_90)));
Ady Abraham3192f3d2021-12-03 16:08:56 -08001997 execute();
1998 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001999}
2000
ramindani431aad42022-02-01 21:44:29 +00002001TEST_P(GraphicsComposerAidlCommandTest, SetLayerVisibleRegion) {
2002 const auto& [layerStatus, layer] =
2003 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2004 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002005
2006 Rect empty{0, 0, 0, 0};
2007 Rect unit{0, 0, 1, 1};
2008
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002009 auto& writer = getWriter(getPrimaryDisplayId());
2010 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
ramindanidcfe3a82021-11-29 17:00:31 +00002011 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002012 ASSERT_TRUE(mReader.takeErrors().empty());
2013
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002014 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
Ady Abraham3192f3d2021-12-03 16:08:56 -08002015 execute();
2016 ASSERT_TRUE(mReader.takeErrors().empty());
2017
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002018 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>());
Ady Abraham3192f3d2021-12-03 16:08:56 -08002019 execute();
2020 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002021}
2022
ramindani431aad42022-02-01 21:44:29 +00002023TEST_P(GraphicsComposerAidlCommandTest, SetLayerZOrder) {
2024 const auto& [layerStatus, layer] =
2025 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2026 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002027
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002028 auto& writer = getWriter(getPrimaryDisplayId());
2029 writer.setLayerZOrder(getPrimaryDisplayId(), layer, /*z*/ 10);
ramindanidcfe3a82021-11-29 17:00:31 +00002030 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002031 ASSERT_TRUE(mReader.takeErrors().empty());
2032
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002033 writer.setLayerZOrder(getPrimaryDisplayId(), layer, /*z*/ 0);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002034 execute();
2035 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002036}
2037
ramindani431aad42022-02-01 21:44:29 +00002038TEST_P(GraphicsComposerAidlCommandTest, SetLayerPerFrameMetadata) {
2039 const auto& [layerStatus, layer] =
2040 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2041 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002042
ramindanidcfe3a82021-11-29 17:00:31 +00002043 /**
2044 * DISPLAY_P3 is a color space that uses the DCI_P3 primaries,
2045 * the D65 white point and the SRGB transfer functions.
2046 * Rendering Intent: Colorimetric
2047 * Primaries:
2048 * x y
2049 * green 0.265 0.690
2050 * blue 0.150 0.060
2051 * red 0.680 0.320
2052 * white (D65) 0.3127 0.3290
2053 */
2054
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002055 auto& writer = getWriter(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00002056 std::vector<PerFrameMetadata> aidlMetadata;
2057 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X, 0.680f});
2058 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y, 0.320f});
2059 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X, 0.265f});
2060 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y, 0.690f});
2061 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X, 0.150f});
2062 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y, 0.060f});
2063 aidlMetadata.push_back({PerFrameMetadataKey::WHITE_POINT_X, 0.3127f});
2064 aidlMetadata.push_back({PerFrameMetadataKey::WHITE_POINT_Y, 0.3290f});
2065 aidlMetadata.push_back({PerFrameMetadataKey::MAX_LUMINANCE, 100.0f});
2066 aidlMetadata.push_back({PerFrameMetadataKey::MIN_LUMINANCE, 0.1f});
2067 aidlMetadata.push_back({PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL, 78.0});
2068 aidlMetadata.push_back({PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL, 62.0});
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002069 writer.setLayerPerFrameMetadata(getPrimaryDisplayId(), layer, aidlMetadata);
ramindanidcfe3a82021-11-29 17:00:31 +00002070 execute();
2071
Ady Abraham3192f3d2021-12-03 16:08:56 -08002072 const auto errors = mReader.takeErrors();
2073 if (errors.size() == 1 && errors[0].errorCode == EX_UNSUPPORTED_OPERATION) {
ramindanidcfe3a82021-11-29 17:00:31 +00002074 GTEST_SUCCEED() << "SetLayerPerFrameMetadata is not supported";
ramindani431aad42022-02-01 21:44:29 +00002075 EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002076 return;
2077 }
2078
ramindani431aad42022-02-01 21:44:29 +00002079 EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002080}
2081
Alec Mourib1f16722022-02-07 13:03:44 -08002082TEST_P(GraphicsComposerAidlCommandTest, setLayerBrightness) {
ramindani431aad42022-02-01 21:44:29 +00002083 const auto& [layerStatus, layer] =
2084 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
Alec Mouri95e490b2022-01-06 13:46:58 -08002085
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002086 auto& writer = getWriter(getPrimaryDisplayId());
2087 writer.setLayerBrightness(getPrimaryDisplayId(), layer, 0.2f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002088 execute();
2089 ASSERT_TRUE(mReader.takeErrors().empty());
2090
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002091 writer.setLayerBrightness(getPrimaryDisplayId(), layer, 1.f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002092 execute();
2093 ASSERT_TRUE(mReader.takeErrors().empty());
2094
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002095 writer.setLayerBrightness(getPrimaryDisplayId(), layer, 0.f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002096 execute();
2097 ASSERT_TRUE(mReader.takeErrors().empty());
2098
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002099 writer.setLayerBrightness(getPrimaryDisplayId(), layer, -1.f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002100 execute();
Alec Mourib1f16722022-02-07 13:03:44 -08002101 {
2102 const auto errors = mReader.takeErrors();
2103 ASSERT_EQ(1, errors.size());
2104 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
2105 }
2106
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002107 writer.setLayerBrightness(getPrimaryDisplayId(), layer, std::nanf(""));
Alec Mourib1f16722022-02-07 13:03:44 -08002108 execute();
2109 {
2110 const auto errors = mReader.takeErrors();
2111 ASSERT_EQ(1, errors.size());
2112 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
2113 }
Alec Mouri95e490b2022-01-06 13:46:58 -08002114}
2115
ramindani431aad42022-02-01 21:44:29 +00002116TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints) {
ramindanidcfe3a82021-11-29 17:00:31 +00002117 Test_setActiveConfigWithConstraints({.delayForChange = 0, .refreshMiss = false});
2118}
2119
ramindani431aad42022-02-01 21:44:29 +00002120TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_Delayed) {
ramindanidcfe3a82021-11-29 17:00:31 +00002121 Test_setActiveConfigWithConstraints({.delayForChange = 300'000'000, // 300ms
2122 .refreshMiss = false});
2123}
2124
ramindani431aad42022-02-01 21:44:29 +00002125TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_MissRefresh) {
ramindanidcfe3a82021-11-29 17:00:31 +00002126 Test_setActiveConfigWithConstraints({.delayForChange = 0, .refreshMiss = true});
2127}
2128
ramindani431aad42022-02-01 21:44:29 +00002129TEST_P(GraphicsComposerAidlCommandTest, GetDisplayVsyncPeriod) {
ramindanidcfe3a82021-11-29 17:00:31 +00002130 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +00002131 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
2132 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002133
ramindani431aad42022-02-01 21:44:29 +00002134 for (int32_t config : configs) {
2135 int32_t expectedVsyncPeriodNanos = display.getDisplayConfig(config).vsyncPeriod;
2136
ramindanidcfe3a82021-11-29 17:00:31 +00002137 VsyncPeriodChangeConstraints constraints;
2138
2139 constraints.desiredTimeNanos = systemTime();
2140 constraints.seamlessRequired = false;
ramindani431aad42022-02-01 21:44:29 +00002141
2142 const auto& [timelineStatus, timeline] =
2143 mComposerClient->setActiveConfigWithConstraints(&display, config, constraints);
2144 EXPECT_TRUE(timelineStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002145
2146 if (timeline.refreshRequired) {
2147 sendRefreshFrame(display, &timeline);
2148 }
ramindani431aad42022-02-01 21:44:29 +00002149 waitForVsyncPeriodChange(display.getDisplayId(), timeline, constraints.desiredTimeNanos,
2150 /*odPeriodNanos*/ 0, expectedVsyncPeriodNanos);
ramindanidcfe3a82021-11-29 17:00:31 +00002151
2152 int32_t vsyncPeriodNanos;
2153 int retryCount = 100;
2154 do {
2155 std::this_thread::sleep_for(10ms);
ramindani431aad42022-02-01 21:44:29 +00002156 const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanosValue] =
2157 mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
2158
2159 EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
2160 vsyncPeriodNanos = vsyncPeriodNanosValue;
ramindanidcfe3a82021-11-29 17:00:31 +00002161 --retryCount;
2162 } while (vsyncPeriodNanos != expectedVsyncPeriodNanos && retryCount > 0);
2163
2164 EXPECT_EQ(vsyncPeriodNanos, expectedVsyncPeriodNanos);
2165
2166 // Make sure that the vsync period stays the same if the active config is not
2167 // changed.
2168 auto timeout = 1ms;
2169 for (int i = 0; i < 10; i++) {
2170 std::this_thread::sleep_for(timeout);
2171 timeout *= 2;
2172 vsyncPeriodNanos = 0;
ramindani431aad42022-02-01 21:44:29 +00002173 const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanosValue] =
2174 mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
2175
2176 EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
2177 vsyncPeriodNanos = vsyncPeriodNanosValue;
ramindanidcfe3a82021-11-29 17:00:31 +00002178 EXPECT_EQ(vsyncPeriodNanos, expectedVsyncPeriodNanos);
2179 }
2180 }
2181 }
2182}
2183
ramindani431aad42022-02-01 21:44:29 +00002184TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_SeamlessNotAllowed) {
ramindanidcfe3a82021-11-29 17:00:31 +00002185 VsyncPeriodChangeConstraints constraints;
ramindanidcfe3a82021-11-29 17:00:31 +00002186 constraints.seamlessRequired = true;
2187 constraints.desiredTimeNanos = systemTime();
2188
2189 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +00002190 forEachTwoConfigs(display.getDisplayId(), [&](int32_t config1, int32_t config2) {
2191 int32_t configGroup1 = display.getDisplayConfig(config1).configGroup;
2192 int32_t configGroup2 = display.getDisplayConfig(config2).configGroup;
ramindanidcfe3a82021-11-29 17:00:31 +00002193 if (configGroup1 != configGroup2) {
ramindani431aad42022-02-01 21:44:29 +00002194 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002195 sendRefreshFrame(display, nullptr);
ramindani431aad42022-02-01 21:44:29 +00002196 const auto& [status, _] = mComposerClient->setActiveConfigWithConstraints(
2197 &display, config2, constraints);
2198 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00002199 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(
2200 status, IComposerClient::EX_SEAMLESS_NOT_ALLOWED));
ramindanidcfe3a82021-11-29 17:00:31 +00002201 }
2202 });
2203 }
2204}
2205
ramindani431aad42022-02-01 21:44:29 +00002206TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_NoTimestamp) {
2207 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ std::nullopt));
Ady Abraham72c5b502021-12-10 17:23:39 -08002208}
2209
ramindani431aad42022-02-01 21:44:29 +00002210TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_0) {
2211 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ 0));
Ady Abraham72c5b502021-12-10 17:23:39 -08002212}
2213
ramindani431aad42022-02-01 21:44:29 +00002214TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_5) {
2215 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ 5));
Ady Abraham72c5b502021-12-10 17:23:39 -08002216}
2217
ramindani431aad42022-02-01 21:44:29 +00002218TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Unsupported) {
2219 const bool hasDisplayIdleTimerSupport =
2220 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002221 if (!hasDisplayIdleTimerSupport) {
ramindani431aad42022-02-01 21:44:29 +00002222 const auto& status =
2223 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0);
2224 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00002225 EXPECT_NO_FATAL_FAILURE(
2226 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
Midas Chiena0b56bd2022-01-13 23:27:33 +08002227 }
2228}
2229
ramindani431aad42022-02-01 21:44:29 +00002230TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_BadParameter) {
2231 const bool hasDisplayIdleTimerSupport =
2232 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002233 if (!hasDisplayIdleTimerSupport) {
2234 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2235 return;
2236 }
2237
ramindani431aad42022-02-01 21:44:29 +00002238 const auto& status =
2239 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ -1);
2240 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00002241 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
Midas Chiena0b56bd2022-01-13 23:27:33 +08002242}
2243
ramindani431aad42022-02-01 21:44:29 +00002244TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Disable) {
2245 const bool hasDisplayIdleTimerSupport =
2246 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002247 if (!hasDisplayIdleTimerSupport) {
2248 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2249 return;
2250 }
2251
ramindani431aad42022-02-01 21:44:29 +00002252 EXPECT_TRUE(mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002253 std::this_thread::sleep_for(1s);
ramindani431aad42022-02-01 21:44:29 +00002254 EXPECT_EQ(0, mComposerClient->getVsyncIdleCount());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002255}
2256
ramindani431aad42022-02-01 21:44:29 +00002257TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Timeout_2) {
2258 const bool hasDisplayIdleTimerSupport =
2259 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002260 if (!hasDisplayIdleTimerSupport) {
2261 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2262 return;
2263 }
2264
ramindani431aad42022-02-01 21:44:29 +00002265 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
2266 EXPECT_TRUE(mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002267
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002268 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002269 ASSERT_NE(nullptr, buffer->handle);
2270
2271 const auto layer = createOnScreenLayer();
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002272 auto& writer = getWriter(getPrimaryDisplayId());
2273 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer->handle,
2274 /*acquireFence*/ -1);
ramindani431aad42022-02-01 21:44:29 +00002275 int32_t vsyncIdleCount = mComposerClient->getVsyncIdleCount();
Midas Chiena0b56bd2022-01-13 23:27:33 +08002276 auto earlyVsyncIdleTime = systemTime() + std::chrono::nanoseconds(2s).count();
ramindani431aad42022-02-01 21:44:29 +00002277 EXPECT_TRUE(
2278 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 2000).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002279
2280 const sp<::android::Fence> presentFence =
ramindani431aad42022-02-01 21:44:29 +00002281 presentAndGetFence(ComposerClientWriter::kNoTimestamp);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002282 presentFence->waitForever(LOG_TAG);
2283
2284 std::this_thread::sleep_for(3s);
ramindani431aad42022-02-01 21:44:29 +00002285 if (vsyncIdleCount < mComposerClient->getVsyncIdleCount()) {
2286 EXPECT_GE(mComposerClient->getVsyncIdleTime(), earlyVsyncIdleTime);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002287 }
2288
ramindani431aad42022-02-01 21:44:29 +00002289 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002290}
2291
ramindani9dd8c482023-02-21 18:07:56 -08002292TEST_P(GraphicsComposerAidlCommandTest, SetRefreshRateChangedCallbackDebug_Unsupported) {
2293 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2294 auto status = mComposerClient->setRefreshRateChangedCallbackDebugEnabled(
2295 getPrimaryDisplayId(), /*enabled*/ true);
2296 EXPECT_FALSE(status.isOk());
2297 EXPECT_NO_FATAL_FAILURE(
2298 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
2299
2300 status = mComposerClient->setRefreshRateChangedCallbackDebugEnabled(getPrimaryDisplayId(),
2301 /*enabled*/ false);
2302 EXPECT_FALSE(status.isOk());
2303 EXPECT_NO_FATAL_FAILURE(
2304 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
2305 }
2306}
2307
2308TEST_P(GraphicsComposerAidlCommandTest, SetRefreshRateChangedCallbackDebug_Enabled) {
2309 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2310 GTEST_SUCCEED() << "Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG is not supported";
2311 return;
2312 }
2313
2314 const auto displayId = getPrimaryDisplayId();
2315 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2316 // Enable the callback
2317 ASSERT_TRUE(mComposerClient
2318 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2319 /*enabled*/ true)
2320 .isOk());
2321 std::this_thread::sleep_for(100ms);
2322
ramindani91518892023-03-03 16:55:09 +00002323 const auto displayFilter = [displayId](auto refreshRateChangedDebugData) {
2324 return displayId == refreshRateChangedDebugData.display;
2325 };
ramindani9dd8c482023-02-21 18:07:56 -08002326
2327 // Check that we immediately got a callback
ramindani91518892023-03-03 16:55:09 +00002328 EXPECT_TRUE(checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter));
ramindani9dd8c482023-02-21 18:07:56 -08002329
2330 ASSERT_TRUE(mComposerClient
2331 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2332 /*enabled*/ false)
2333 .isOk());
2334}
2335
2336TEST_P(GraphicsComposerAidlCommandTest,
2337 SetRefreshRateChangedCallbackDebugEnabled_noCallbackWhenIdle) {
2338 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2339 GTEST_SUCCEED() << "Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG is not supported";
2340 return;
2341 }
2342
2343 auto display = getEditablePrimaryDisplay();
2344 const auto displayId = display.getDisplayId();
2345
2346 if (!hasDisplayCapability(displayId, DisplayCapability::DISPLAY_IDLE_TIMER)) {
2347 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2348 return;
2349 }
2350
2351 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2352 EXPECT_TRUE(mComposerClient->setPeakRefreshRateConfig(&display).isOk());
2353
2354 ASSERT_TRUE(mComposerClient->setIdleTimerEnabled(displayId, /*timeoutMs*/ 500).isOk());
2355 // Enable the callback
2356 ASSERT_TRUE(mComposerClient
2357 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2358 /*enabled*/ true)
2359 .isOk());
2360
ramindani91518892023-03-03 16:55:09 +00002361 const auto displayFilter = [displayId](auto refreshRateChangedDebugData) {
2362 return displayId == refreshRateChangedDebugData.display;
2363 };
ramindani9dd8c482023-02-21 18:07:56 -08002364
2365 int retryCount = 3;
2366 do {
2367 // Wait for 1s so that we enter the idle state
2368 std::this_thread::sleep_for(1s);
ramindani91518892023-03-03 16:55:09 +00002369 if (!checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter)) {
ramindani9dd8c482023-02-21 18:07:56 -08002370 // DID NOT receive a callback, we are in the idle state.
2371 break;
2372 }
2373 } while (--retryCount > 0);
2374
2375 if (retryCount == 0) {
2376 GTEST_SUCCEED() << "Unable to enter the idle mode";
2377 return;
2378 }
2379
2380 // Send the REFRESH_RATE_INDICATOR update
2381 ASSERT_NO_FATAL_FAILURE(
2382 sendBufferUpdate(createOnScreenLayer(Composition::REFRESH_RATE_INDICATOR)));
2383 std::this_thread::sleep_for(1s);
ramindani91518892023-03-03 16:55:09 +00002384 EXPECT_FALSE(checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter))
ramindani9dd8c482023-02-21 18:07:56 -08002385 << "A callback should not be received for REFRESH_RATE_INDICATOR";
2386
2387 EXPECT_TRUE(mComposerClient
2388 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2389 /*enabled*/ false)
2390 .isOk());
2391}
2392
2393TEST_P(GraphicsComposerAidlCommandTest,
2394 SetRefreshRateChangedCallbackDebugEnabled_SetActiveConfigWithConstraints) {
2395 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2396 GTEST_SUCCEED() << "Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG is not supported";
2397 return;
2398 }
2399
2400 VsyncPeriodChangeConstraints constraints;
2401 constraints.seamlessRequired = false;
2402 constraints.desiredTimeNanos = systemTime();
2403
2404 for (VtsDisplay& display : mDisplays) {
2405 const auto displayId = display.getDisplayId();
2406 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2407
2408 // Enable the callback
2409 ASSERT_TRUE(mComposerClient
2410 ->setRefreshRateChangedCallbackDebugEnabled(displayId, /*enabled*/ true)
2411 .isOk());
2412
2413 forEachTwoConfigs(displayId, [&](int32_t config1, int32_t config2) {
2414 const int32_t vsyncPeriod1 = display.getDisplayConfig(config1).vsyncPeriod;
2415 const int32_t vsyncPeriod2 = display.getDisplayConfig(config2).vsyncPeriod;
2416
2417 if (vsyncPeriod1 == vsyncPeriod2) {
2418 return; // continue
2419 }
2420
2421 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
2422 sendRefreshFrame(display, nullptr);
2423
2424 const auto& [status, timeline] =
2425 mComposerClient->setActiveConfigWithConstraints(&display, config2, constraints);
2426 EXPECT_TRUE(status.isOk());
2427
2428 if (timeline.refreshRequired) {
2429 sendRefreshFrame(display, &timeline);
2430 }
2431
ramindani91518892023-03-03 16:55:09 +00002432 const auto callbackFilter = [displayId,
2433 vsyncPeriod2](auto refreshRateChangedDebugData) {
2434 constexpr int kVsyncThreshold = 1000;
2435 return displayId == refreshRateChangedDebugData.display &&
2436 std::abs(vsyncPeriod2 - refreshRateChangedDebugData.vsyncPeriodNanos) <=
2437 kVsyncThreshold;
2438 };
ramindani9dd8c482023-02-21 18:07:56 -08002439
2440 int retryCount = 3;
2441 do {
2442 std::this_thread::sleep_for(100ms);
ramindani91518892023-03-03 16:55:09 +00002443 if (checkIfCallbackRefreshRateChangedDebugEnabledReceived(callbackFilter)) {
ramindani9dd8c482023-02-21 18:07:56 -08002444 GTEST_SUCCEED() << "Received a callback successfully";
2445 break;
2446 }
2447 } while (--retryCount > 0);
2448
2449 if (retryCount == 0) {
2450 GTEST_FAIL() << "failed to get a callback for the display " << displayId
2451 << " with config " << config2;
2452 }
2453 });
2454
2455 EXPECT_TRUE(
2456 mComposerClient
2457 ->setRefreshRateChangedCallbackDebugEnabled(displayId, /*enabled*/ false)
2458 .isOk());
2459 }
2460}
2461
Kriti Dang4efe8602022-05-03 16:55:59 +02002462/*
2463 * Test that no two display configs are exactly the same.
2464 */
2465TEST_P(GraphicsComposerAidlTest, GetDisplayConfigNoRepetitions) {
2466 for (const auto& display : mDisplays) {
2467 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
2468 for (std::vector<int>::size_type i = 0; i < configs.size(); i++) {
2469 for (std::vector<int>::size_type j = i + 1; j < configs.size(); j++) {
2470 const auto& [widthStatus1, width1] = mComposerClient->getDisplayAttribute(
2471 display.getDisplayId(), configs[i], DisplayAttribute::WIDTH);
2472 const auto& [heightStatus1, height1] = mComposerClient->getDisplayAttribute(
2473 display.getDisplayId(), configs[i], DisplayAttribute::HEIGHT);
2474 const auto& [vsyncPeriodStatus1, vsyncPeriod1] =
2475 mComposerClient->getDisplayAttribute(display.getDisplayId(), configs[i],
2476 DisplayAttribute::VSYNC_PERIOD);
2477 const auto& [groupStatus1, group1] = mComposerClient->getDisplayAttribute(
2478 display.getDisplayId(), configs[i], DisplayAttribute::CONFIG_GROUP);
2479
2480 const auto& [widthStatus2, width2] = mComposerClient->getDisplayAttribute(
2481 display.getDisplayId(), configs[j], DisplayAttribute::WIDTH);
2482 const auto& [heightStatus2, height2] = mComposerClient->getDisplayAttribute(
2483 display.getDisplayId(), configs[j], DisplayAttribute::HEIGHT);
2484 const auto& [vsyncPeriodStatus2, vsyncPeriod2] =
2485 mComposerClient->getDisplayAttribute(display.getDisplayId(), configs[j],
2486 DisplayAttribute::VSYNC_PERIOD);
2487 const auto& [groupStatus2, group2] = mComposerClient->getDisplayAttribute(
2488 display.getDisplayId(), configs[j], DisplayAttribute::CONFIG_GROUP);
2489
2490 ASSERT_FALSE(width1 == width2 && height1 == height2 &&
2491 vsyncPeriod1 == vsyncPeriod2 && group1 == group2);
2492 }
2493 }
2494 }
2495}
2496
Carlos Martinez Romerocd043612023-01-05 22:28:05 +00002497/**
2498 * Test Capability::SKIP_VALIDATE
2499 *
2500 * Capability::SKIP_VALIDATE has been deprecated and should not be enabled.
2501 */
2502TEST_P(GraphicsComposerAidlCommandTest, SkipValidateDeprecatedTest) {
2503 const auto& [versionStatus, version] = mComposerClient->getInterfaceVersion();
2504 ASSERT_TRUE(versionStatus.isOk());
2505 if (version <= 1) {
2506 GTEST_SUCCEED() << "HAL at version 1 or lower can contain Capability::SKIP_VALIDATE.";
2507 return;
2508 }
2509 ASSERT_FALSE(hasCapability(Capability::SKIP_VALIDATE))
2510 << "Found Capability::SKIP_VALIDATE capability.";
2511}
2512
ramindanidcfe3a82021-11-29 17:00:31 +00002513GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlCommandTest);
2514INSTANTIATE_TEST_SUITE_P(
2515 PerInstance, GraphicsComposerAidlCommandTest,
2516 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
2517 ::android::PrintInstanceNameToString);
2518
ramindanid32ae8e2021-10-01 18:48:39 +00002519GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlTest);
2520INSTANTIATE_TEST_SUITE_P(
2521 PerInstance, GraphicsComposerAidlTest,
2522 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
2523 ::android::PrintInstanceNameToString);
2524} // namespace
2525} // namespace aidl::android::hardware::graphics::composer3::vts
2526
2527int main(int argc, char** argv) {
2528 ::testing::InitGoogleTest(&argc, argv);
2529
2530 using namespace std::chrono_literals;
2531 if (!android::base::WaitForProperty("init.svc.surfaceflinger", "stopped", 10s)) {
2532 ALOGE("Failed to stop init.svc.surfaceflinger");
2533 return -1;
2534 }
ramindanibeea10e2021-12-07 21:02:49 +00002535
2536 android::ProcessState::self()->setThreadPoolMaxThreadCount(4);
2537
2538 // The binder threadpool we start will inherit sched policy and priority
2539 // of (this) creating thread. We want the binder thread pool to have
2540 // SCHED_FIFO policy and priority 1 (lowest RT priority)
2541 // Once the pool is created we reset this thread's priority back to
2542 // original.
2543 // This thread policy is based on what we do in the SurfaceFlinger while starting
2544 // the thread pool and we need to replicate that for the VTS tests.
2545 int newPriority = 0;
2546 int origPolicy = sched_getscheduler(0);
2547 struct sched_param origSchedParam;
2548
2549 int errorInPriorityModification = sched_getparam(0, &origSchedParam);
2550 if (errorInPriorityModification == 0) {
2551 int policy = SCHED_FIFO;
2552 newPriority = sched_get_priority_min(policy);
2553
2554 struct sched_param param;
2555 param.sched_priority = newPriority;
2556
2557 errorInPriorityModification = sched_setscheduler(0, policy, &param);
2558 }
2559
2560 // start the thread pool
2561 android::ProcessState::self()->startThreadPool();
2562
2563 // Reset current thread's policy and priority
2564 if (errorInPriorityModification == 0) {
2565 errorInPriorityModification = sched_setscheduler(0, origPolicy, &origSchedParam);
2566 } else {
2567 ALOGE("Failed to set VtsHalGraphicsComposer3_TargetTest binder threadpool priority to "
2568 "SCHED_FIFO");
2569 }
2570
ramindanid32ae8e2021-10-01 18:48:39 +00002571 return RUN_ALL_TESTS();
Leon Scroggins III45095052023-03-23 18:23:15 -04002572}