blob: 30ee1ebc701522db48f81cf8b72aea4a4827e47a [file] [log] [blame]
ramindani431aad42022-02-01 21:44:29 +00001/**
2 * Copyright (c) 2022, The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
Sally Qi2600d342022-08-16 12:46:17 -070016
ramindanid32ae8e2021-10-01 18:48:39 +000017#include <aidl/Gtest.h>
18#include <aidl/Vintf.h>
Ady Abraham3192f3d2021-12-03 16:08:56 -080019#include <aidl/android/hardware/graphics/common/BlendMode.h>
ramindani3335f7a2021-10-25 17:22:35 +000020#include <aidl/android/hardware/graphics/common/BufferUsage.h>
21#include <aidl/android/hardware/graphics/common/FRect.h>
Leon Scroggins IIIde057582022-01-13 12:26:00 -050022#include <aidl/android/hardware/graphics/common/PixelFormat.h>
ramindani3335f7a2021-10-25 17:22:35 +000023#include <aidl/android/hardware/graphics/common/Rect.h>
ramindani3335f7a2021-10-25 17:22:35 +000024#include <aidl/android/hardware/graphics/composer3/Composition.h>
ramindanid32ae8e2021-10-01 18:48:39 +000025#include <aidl/android/hardware/graphics/composer3/IComposer.h>
26#include <android-base/properties.h>
ramindania9780262021-10-01 18:48:39 +000027#include <android/binder_process.h>
Ady Abraham91c9d1a2021-12-15 18:14:45 -080028#include <android/hardware/graphics/composer3/ComposerClientReader.h>
29#include <android/hardware/graphics/composer3/ComposerClientWriter.h>
ramindanid32ae8e2021-10-01 18:48:39 +000030#include <binder/ProcessState.h>
31#include <gtest/gtest.h>
Ady Abraham72c5b502021-12-10 17:23:39 -080032#include <ui/Fence.h>
ramindani3335f7a2021-10-25 17:22:35 +000033#include <ui/GraphicBuffer.h>
34#include <ui/PixelFormat.h>
ramindani0291f112021-11-04 03:45:46 +000035#include <algorithm>
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -040036#include <iterator>
ramindani592b6512021-10-08 21:15:19 +000037#include <numeric>
ramindanid32ae8e2021-10-01 18:48:39 +000038#include <string>
ramindani1cb794e2021-10-13 20:45:23 +000039#include <thread>
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -040040#include <unordered_map>
ramindani458e53e2022-02-23 17:30:16 +000041#include "GraphicsComposerCallback.h"
42#include "VtsComposerClient.h"
ramindani3335f7a2021-10-25 17:22:35 +000043
ramindanid32ae8e2021-10-01 18:48:39 +000044#undef LOG_TAG
45#define LOG_TAG "VtsHalGraphicsComposer3_TargetTest"
46
47namespace aidl::android::hardware::graphics::composer3::vts {
48namespace {
49
ramindani1cb794e2021-10-13 20:45:23 +000050using namespace std::chrono_literals;
51
ramindanidcfe3a82021-11-29 17:00:31 +000052using ::android::GraphicBuffer;
53using ::android::sp;
54
ramindanid32ae8e2021-10-01 18:48:39 +000055class GraphicsComposerAidlTest : public ::testing::TestWithParam<std::string> {
ramindania9780262021-10-01 18:48:39 +000056 protected:
57 void SetUp() override {
ramindani431aad42022-02-01 21:44:29 +000058 mComposerClient = std::make_unique<VtsComposerClient>(GetParam());
59 ASSERT_TRUE(mComposerClient->createClient().isOk());
Jason Macnake531a092022-01-20 08:49:09 -080060
ramindani431aad42022-02-01 21:44:29 +000061 const auto& [status, displays] = mComposerClient->getDisplays();
Jason Macnake531a092022-01-20 08:49:09 -080062 ASSERT_TRUE(status.isOk());
ramindani431aad42022-02-01 21:44:29 +000063 mDisplays = displays;
ramindanidcfe3a82021-11-29 17:00:31 +000064
ramindani3335f7a2021-10-25 17:22:35 +000065 // explicitly disable vsync
66 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +000067 EXPECT_TRUE(mComposerClient->setVsync(display.getDisplayId(), false).isOk());
ramindani3335f7a2021-10-25 17:22:35 +000068 }
ramindani431aad42022-02-01 21:44:29 +000069 mComposerClient->setVsyncAllowed(false);
ramindania9780262021-10-01 18:48:39 +000070 }
71
ramindani3335f7a2021-10-25 17:22:35 +000072 void TearDown() override {
ramindani431aad42022-02-01 21:44:29 +000073 ASSERT_TRUE(mComposerClient->tearDown());
74 mComposerClient.reset();
ramindani3335f7a2021-10-25 17:22:35 +000075 }
ramindanic2b8d082021-11-06 02:03:50 +000076
ramindanid5751092022-04-22 22:30:20 +000077 void assertServiceSpecificError(const ScopedAStatus& status, int32_t serviceSpecificError) {
78 ASSERT_EQ(status.getExceptionCode(), EX_SERVICE_SPECIFIC);
79 ASSERT_EQ(status.getServiceSpecificError(), serviceSpecificError);
80 }
81
ramindani431aad42022-02-01 21:44:29 +000082 void Test_setContentTypeForDisplay(int64_t display,
83 const std::vector<ContentType>& supportedContentTypes,
84 ContentType contentType, const char* contentTypeStr) {
85 const bool contentTypeSupport =
86 std::find(supportedContentTypes.begin(), supportedContentTypes.end(),
87 contentType) != supportedContentTypes.end();
ramindanidcfe3a82021-11-29 17:00:31 +000088
89 if (!contentTypeSupport) {
ramindani431aad42022-02-01 21:44:29 +000090 const auto& status = mComposerClient->setContentType(display, contentType);
91 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +000092 EXPECT_NO_FATAL_FAILURE(
93 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
ramindanidcfe3a82021-11-29 17:00:31 +000094 GTEST_SUCCEED() << contentTypeStr << " content type is not supported on display "
95 << std::to_string(display) << ", skipping test";
96 return;
97 }
98
99 EXPECT_TRUE(mComposerClient->setContentType(display, contentType).isOk());
100 EXPECT_TRUE(mComposerClient->setContentType(display, ContentType::NONE).isOk());
101 }
102
ramindani431aad42022-02-01 21:44:29 +0000103 void Test_setContentType(ContentType contentType, const char* contentTypeStr) {
ramindanidcfe3a82021-11-29 17:00:31 +0000104 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000105 const auto& [status, supportedContentTypes] =
106 mComposerClient->getSupportedContentTypes(display.getDisplayId());
107 EXPECT_TRUE(status.isOk());
108 Test_setContentTypeForDisplay(display.getDisplayId(), supportedContentTypes,
109 contentType, contentTypeStr);
ramindanidcfe3a82021-11-29 17:00:31 +0000110 }
111 }
112
Jason Macnak325e8232022-01-24 14:48:55 -0800113 bool hasCapability(Capability capability) {
ramindani431aad42022-02-01 21:44:29 +0000114 const auto& [status, capabilities] = mComposerClient->getCapabilities();
115 EXPECT_TRUE(status.isOk());
Jason Macnak325e8232022-01-24 14:48:55 -0800116 return std::any_of(
117 capabilities.begin(), capabilities.end(),
118 [&](const Capability& activeCapability) { return activeCapability == capability; });
119 }
120
ramindani431aad42022-02-01 21:44:29 +0000121 const VtsDisplay& getPrimaryDisplay() const { return mDisplays[0]; }
ramindania9780262021-10-01 18:48:39 +0000122
ramindani431aad42022-02-01 21:44:29 +0000123 int64_t getPrimaryDisplayId() const { return getPrimaryDisplay().getDisplayId(); }
ramindania9780262021-10-01 18:48:39 +0000124
ramindani431aad42022-02-01 21:44:29 +0000125 int64_t getInvalidDisplayId() const { return mComposerClient->getInvalidDisplayId(); }
ramindani1cb794e2021-10-13 20:45:23 +0000126
ramindani431aad42022-02-01 21:44:29 +0000127 VtsDisplay& getEditablePrimaryDisplay() { return mDisplays[0]; }
ramindani0291f112021-11-04 03:45:46 +0000128
ramindani3335f7a2021-10-25 17:22:35 +0000129 struct TestParameters {
130 nsecs_t delayForChange;
131 bool refreshMiss;
132 };
133
ramindani431aad42022-02-01 21:44:29 +0000134 std::unique_ptr<VtsComposerClient> mComposerClient;
ramindani1cb794e2021-10-13 20:45:23 +0000135 std::vector<VtsDisplay> mDisplays;
ramindani3335f7a2021-10-25 17:22:35 +0000136 // use the slot count usually set by SF
137 static constexpr uint32_t kBufferSlotCount = 64;
ramindanid32ae8e2021-10-01 18:48:39 +0000138};
139
ramindani431aad42022-02-01 21:44:29 +0000140TEST_P(GraphicsComposerAidlTest, GetDisplayCapabilities_BadDisplay) {
141 const auto& [status, _] = mComposerClient->getDisplayCapabilities(getInvalidDisplayId());
ramindani5f696942021-10-14 16:24:18 +0000142
ramindani431aad42022-02-01 21:44:29 +0000143 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000144 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindania9780262021-10-01 18:48:39 +0000145}
146
ramindani431aad42022-02-01 21:44:29 +0000147TEST_P(GraphicsComposerAidlTest, GetDisplayCapabilities) {
ramindania9780262021-10-01 18:48:39 +0000148 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000149 const auto& [status, capabilities] =
150 mComposerClient->getDisplayCapabilities(display.getDisplayId());
ramindania9780262021-10-01 18:48:39 +0000151
ramindani431aad42022-02-01 21:44:29 +0000152 EXPECT_TRUE(status.isOk());
ramindania9780262021-10-01 18:48:39 +0000153 }
ramindanid32ae8e2021-10-01 18:48:39 +0000154}
155
ramindani2740bac2021-11-24 22:58:32 +0000156TEST_P(GraphicsComposerAidlTest, DumpDebugInfo) {
ramindani431aad42022-02-01 21:44:29 +0000157 ASSERT_TRUE(mComposerClient->dumpDebugInfo().isOk());
ramindani2740bac2021-11-24 22:58:32 +0000158}
159
160TEST_P(GraphicsComposerAidlTest, CreateClientSingleton) {
161 std::shared_ptr<IComposerClient> composerClient;
ramindani431aad42022-02-01 21:44:29 +0000162 const auto& status = mComposerClient->createClient();
ramindani2740bac2021-11-24 22:58:32 +0000163
ramindani431aad42022-02-01 21:44:29 +0000164 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000165 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_NO_RESOURCES));
ramindani2740bac2021-11-24 22:58:32 +0000166}
167
ramindani592b6512021-10-08 21:15:19 +0000168TEST_P(GraphicsComposerAidlTest, GetDisplayIdentificationData) {
ramindani431aad42022-02-01 21:44:29 +0000169 const auto& [status0, displayIdentification0] =
170 mComposerClient->getDisplayIdentificationData(getPrimaryDisplayId());
ramindanid5751092022-04-22 22:30:20 +0000171 if (!status0.isOk() && status0.getExceptionCode() == EX_SERVICE_SPECIFIC &&
172 status0.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindani431aad42022-02-01 21:44:29 +0000173 GTEST_SUCCEED() << "Display identification data not supported, skipping test";
ramindani592b6512021-10-08 21:15:19 +0000174 return;
175 }
ramindani431aad42022-02-01 21:44:29 +0000176 ASSERT_TRUE(status0.isOk()) << "failed to get display identification data";
ramindani592b6512021-10-08 21:15:19 +0000177 ASSERT_FALSE(displayIdentification0.data.empty());
178
179 constexpr size_t kEdidBlockSize = 128;
180 ASSERT_TRUE(displayIdentification0.data.size() % kEdidBlockSize == 0)
181 << "EDID blob length is not a multiple of " << kEdidBlockSize;
182
183 const uint8_t kEdidHeader[] = {0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00};
184 ASSERT_TRUE(std::equal(std::begin(kEdidHeader), std::end(kEdidHeader),
185 displayIdentification0.data.begin()))
186 << "EDID blob doesn't start with the fixed EDID header";
187 ASSERT_EQ(0, std::accumulate(displayIdentification0.data.begin(),
188 displayIdentification0.data.begin() + kEdidBlockSize,
189 static_cast<uint8_t>(0)))
190 << "EDID base block doesn't checksum";
191
ramindani431aad42022-02-01 21:44:29 +0000192 const auto& [status1, displayIdentification1] =
193 mComposerClient->getDisplayIdentificationData(getPrimaryDisplayId());
194 ASSERT_TRUE(status1.isOk());
ramindani592b6512021-10-08 21:15:19 +0000195
196 ASSERT_EQ(displayIdentification0.port, displayIdentification1.port) << "ports are not stable";
197 ASSERT_TRUE(displayIdentification0.data.size() == displayIdentification1.data.size() &&
198 std::equal(displayIdentification0.data.begin(), displayIdentification0.data.end(),
199 displayIdentification1.data.begin()))
200 << "data is not stable";
201}
202
203TEST_P(GraphicsComposerAidlTest, GetHdrCapabilities) {
ramindani431aad42022-02-01 21:44:29 +0000204 const auto& [status, hdrCapabilities] =
205 mComposerClient->getHdrCapabilities(getPrimaryDisplayId());
ramindani592b6512021-10-08 21:15:19 +0000206
ramindani431aad42022-02-01 21:44:29 +0000207 ASSERT_TRUE(status.isOk());
208 EXPECT_TRUE(hdrCapabilities.maxLuminance >= hdrCapabilities.minLuminance);
ramindani592b6512021-10-08 21:15:19 +0000209}
210
211TEST_P(GraphicsComposerAidlTest, GetPerFrameMetadataKeys) {
ramindani431aad42022-02-01 21:44:29 +0000212 const auto& [status, keys] = mComposerClient->getPerFrameMetadataKeys(getPrimaryDisplayId());
ramindanid5751092022-04-22 22:30:20 +0000213 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
214 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindanic2b8d082021-11-06 02:03:50 +0000215 GTEST_SUCCEED() << "getPerFrameMetadataKeys is not supported";
216 return;
ramindani592b6512021-10-08 21:15:19 +0000217 }
ramindani431aad42022-02-01 21:44:29 +0000218
219 ASSERT_TRUE(status.isOk());
220 EXPECT_TRUE(keys.size() >= 0);
ramindani592b6512021-10-08 21:15:19 +0000221}
222
223TEST_P(GraphicsComposerAidlTest, GetReadbackBufferAttributes) {
ramindani431aad42022-02-01 21:44:29 +0000224 const auto& [status, _] = mComposerClient->getReadbackBufferAttributes(getPrimaryDisplayId());
ramindanid5751092022-04-22 22:30:20 +0000225 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
226 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindani431aad42022-02-01 21:44:29 +0000227 GTEST_SUCCEED() << "getReadbackBufferAttributes is not supported";
228 return;
ramindani592b6512021-10-08 21:15:19 +0000229 }
ramindani431aad42022-02-01 21:44:29 +0000230
231 ASSERT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000232}
233
234TEST_P(GraphicsComposerAidlTest, GetRenderIntents) {
ramindani431aad42022-02-01 21:44:29 +0000235 const auto& [status, modes] = mComposerClient->getColorModes(getPrimaryDisplayId());
236 EXPECT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000237
ramindani431aad42022-02-01 21:44:29 +0000238 for (auto mode : modes) {
239 const auto& [intentStatus, intents] =
240 mComposerClient->getRenderIntents(getPrimaryDisplayId(), mode);
241 EXPECT_TRUE(intentStatus.isOk());
ramindani592b6512021-10-08 21:15:19 +0000242 bool isHdr;
243 switch (mode) {
244 case ColorMode::BT2100_PQ:
245 case ColorMode::BT2100_HLG:
246 isHdr = true;
247 break;
248 default:
249 isHdr = false;
250 break;
251 }
252 RenderIntent requiredIntent =
253 isHdr ? RenderIntent::TONE_MAP_COLORIMETRIC : RenderIntent::COLORIMETRIC;
254
ramindani431aad42022-02-01 21:44:29 +0000255 const auto iter = std::find(intents.cbegin(), intents.cend(), requiredIntent);
ramindani592b6512021-10-08 21:15:19 +0000256 EXPECT_NE(intents.cend(), iter);
257 }
258}
259
ramindani431aad42022-02-01 21:44:29 +0000260TEST_P(GraphicsComposerAidlTest, GetRenderIntents_BadDisplay) {
261 const auto& [status, modes] = mComposerClient->getColorModes(getPrimaryDisplayId());
262 ASSERT_TRUE(status.isOk());
263
ramindani592b6512021-10-08 21:15:19 +0000264 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +0000265 const auto& [intentStatus, _] =
266 mComposerClient->getRenderIntents(getInvalidDisplayId(), mode);
267
268 EXPECT_FALSE(intentStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000269 EXPECT_NO_FATAL_FAILURE(
270 assertServiceSpecificError(intentStatus, IComposerClient::EX_BAD_DISPLAY));
ramindani592b6512021-10-08 21:15:19 +0000271 }
272}
273
ramindani431aad42022-02-01 21:44:29 +0000274TEST_P(GraphicsComposerAidlTest, GetRenderIntents_BadParameter) {
275 const auto& [status, _] =
276 mComposerClient->getRenderIntents(getPrimaryDisplayId(), static_cast<ColorMode>(-1));
277
278 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000279 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
ramindani592b6512021-10-08 21:15:19 +0000280}
281
282TEST_P(GraphicsComposerAidlTest, GetColorModes) {
ramindani431aad42022-02-01 21:44:29 +0000283 const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
284 ASSERT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000285
ramindani431aad42022-02-01 21:44:29 +0000286 const auto native = std::find(colorModes.cbegin(), colorModes.cend(), ColorMode::NATIVE);
287 EXPECT_NE(colorModes.cend(), native);
ramindani592b6512021-10-08 21:15:19 +0000288}
289
ramindani431aad42022-02-01 21:44:29 +0000290TEST_P(GraphicsComposerAidlTest, GetColorMode_BadDisplay) {
291 const auto& [status, _] = mComposerClient->getColorModes(getInvalidDisplayId());
ramindani592b6512021-10-08 21:15:19 +0000292
ramindani431aad42022-02-01 21:44:29 +0000293 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000294 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani592b6512021-10-08 21:15:19 +0000295}
296
297TEST_P(GraphicsComposerAidlTest, SetColorMode) {
ramindani431aad42022-02-01 21:44:29 +0000298 const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
299 EXPECT_TRUE(status.isOk());
300
ramindani592b6512021-10-08 21:15:19 +0000301 for (auto mode : colorModes) {
ramindani431aad42022-02-01 21:44:29 +0000302 const auto& [intentStatus, intents] =
303 mComposerClient->getRenderIntents(getPrimaryDisplayId(), mode);
304 EXPECT_TRUE(intentStatus.isOk()) << "failed to get render intents";
305
ramindani592b6512021-10-08 21:15:19 +0000306 for (auto intent : intents) {
ramindani431aad42022-02-01 21:44:29 +0000307 const auto modeStatus =
308 mComposerClient->setColorMode(getPrimaryDisplayId(), mode, intent);
309 EXPECT_TRUE(modeStatus.isOk() ||
ramindanid5751092022-04-22 22:30:20 +0000310 (modeStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
311 IComposerClient::EX_UNSUPPORTED == modeStatus.getServiceSpecificError()))
ramindani592b6512021-10-08 21:15:19 +0000312 << "failed to set color mode";
313 }
314 }
315
ramindani431aad42022-02-01 21:44:29 +0000316 const auto modeStatus = mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE,
317 RenderIntent::COLORIMETRIC);
318 EXPECT_TRUE(modeStatus.isOk() ||
ramindanid5751092022-04-22 22:30:20 +0000319 (modeStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
320 IComposerClient::EX_UNSUPPORTED == modeStatus.getServiceSpecificError()))
ramindani592b6512021-10-08 21:15:19 +0000321 << "failed to set color mode";
322}
323
ramindani431aad42022-02-01 21:44:29 +0000324TEST_P(GraphicsComposerAidlTest, SetColorMode_BadDisplay) {
325 const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
326 ASSERT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000327
ramindani431aad42022-02-01 21:44:29 +0000328 for (auto mode : colorModes) {
329 const auto& [intentStatus, intents] =
330 mComposerClient->getRenderIntents(getPrimaryDisplayId(), mode);
331 ASSERT_TRUE(intentStatus.isOk()) << "failed to get render intents";
332
333 for (auto intent : intents) {
334 auto const modeStatus =
335 mComposerClient->setColorMode(getInvalidDisplayId(), mode, intent);
336
337 EXPECT_FALSE(modeStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000338 EXPECT_NO_FATAL_FAILURE(
339 assertServiceSpecificError(modeStatus, IComposerClient::EX_BAD_DISPLAY));
ramindani770d7082021-11-30 00:36:42 +0000340 }
341 }
ramindani592b6512021-10-08 21:15:19 +0000342}
343
ramindani431aad42022-02-01 21:44:29 +0000344TEST_P(GraphicsComposerAidlTest, SetColorMode_BadParameter) {
345 auto status = mComposerClient->setColorMode(getPrimaryDisplayId(), static_cast<ColorMode>(-1),
346 RenderIntent::COLORIMETRIC);
ramindani592b6512021-10-08 21:15:19 +0000347
ramindani431aad42022-02-01 21:44:29 +0000348 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000349 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
ramindani592b6512021-10-08 21:15:19 +0000350
ramindani431aad42022-02-01 21:44:29 +0000351 status = mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE,
352 static_cast<RenderIntent>(-1));
ramindani592b6512021-10-08 21:15:19 +0000353
ramindani431aad42022-02-01 21:44:29 +0000354 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000355 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
ramindani592b6512021-10-08 21:15:19 +0000356}
357
358TEST_P(GraphicsComposerAidlTest, GetDisplayedContentSamplingAttributes) {
ramindani431aad42022-02-01 21:44:29 +0000359 int constexpr kInvalid = -1;
360 const auto& [status, format] =
361 mComposerClient->getDisplayedContentSamplingAttributes(getPrimaryDisplayId());
ramindani592b6512021-10-08 21:15:19 +0000362
ramindanid5751092022-04-22 22:30:20 +0000363 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
364 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindani592b6512021-10-08 21:15:19 +0000365 SUCCEED() << "Device does not support optional extension. Test skipped";
366 return;
367 }
368
ramindani431aad42022-02-01 21:44:29 +0000369 ASSERT_TRUE(status.isOk());
370 EXPECT_NE(kInvalid, static_cast<int>(format.format));
371 EXPECT_NE(kInvalid, static_cast<int>(format.dataspace));
372 EXPECT_NE(kInvalid, static_cast<int>(format.componentMask));
ramindani592b6512021-10-08 21:15:19 +0000373};
374
375TEST_P(GraphicsComposerAidlTest, SetDisplayedContentSamplingEnabled) {
ramindani431aad42022-02-01 21:44:29 +0000376 int constexpr kMaxFrames = 10;
ramindani592b6512021-10-08 21:15:19 +0000377 FormatColorComponent enableAllComponents = FormatColorComponent::FORMAT_COMPONENT_0;
ramindani431aad42022-02-01 21:44:29 +0000378 auto status = mComposerClient->setDisplayedContentSamplingEnabled(
379 getPrimaryDisplayId(), /*isEnabled*/ true, enableAllComponents, kMaxFrames);
ramindanid5751092022-04-22 22:30:20 +0000380 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
381 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindani592b6512021-10-08 21:15:19 +0000382 SUCCEED() << "Device does not support optional extension. Test skipped";
383 return;
384 }
ramindani431aad42022-02-01 21:44:29 +0000385 EXPECT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000386
ramindani431aad42022-02-01 21:44:29 +0000387 status = mComposerClient->setDisplayedContentSamplingEnabled(
388 getPrimaryDisplayId(), /*isEnabled*/ false, enableAllComponents, kMaxFrames);
389 EXPECT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000390}
391
392TEST_P(GraphicsComposerAidlTest, GetDisplayedContentSample) {
ramindani431aad42022-02-01 21:44:29 +0000393 const auto& [status, displayContentSamplingAttributes] =
394 mComposerClient->getDisplayedContentSamplingAttributes(getPrimaryDisplayId());
ramindanid5751092022-04-22 22:30:20 +0000395 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
396 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindanideb059e2021-11-18 01:57:25 +0000397 SUCCEED() << "Sampling attributes aren't supported on this device, test skipped";
398 return;
399 }
ramindani592b6512021-10-08 21:15:19 +0000400
ramindani431aad42022-02-01 21:44:29 +0000401 int64_t constexpr kMaxFrames = 10;
402 int64_t constexpr kTimestamp = 0;
403 const auto& [sampleStatus, displayContentSample] = mComposerClient->getDisplayedContentSample(
404 getPrimaryDisplayId(), kMaxFrames, kTimestamp);
ramindanid5751092022-04-22 22:30:20 +0000405 if (!sampleStatus.isOk() && sampleStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
ramindani431aad42022-02-01 21:44:29 +0000406 sampleStatus.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindani592b6512021-10-08 21:15:19 +0000407 SUCCEED() << "Device does not support optional extension. Test skipped";
408 return;
409 }
410
ramindani431aad42022-02-01 21:44:29 +0000411 EXPECT_TRUE(sampleStatus.isOk());
412 const std::vector<std::vector<int64_t>> histogram = {
ramindani592b6512021-10-08 21:15:19 +0000413 displayContentSample.sampleComponent0, displayContentSample.sampleComponent1,
414 displayContentSample.sampleComponent2, displayContentSample.sampleComponent3};
415
ramindani3335f7a2021-10-25 17:22:35 +0000416 for (size_t i = 0; i < histogram.size(); i++) {
417 const bool shouldHaveHistogram =
418 static_cast<int>(displayContentSamplingAttributes.componentMask) & (1 << i);
419 EXPECT_EQ(shouldHaveHistogram, !histogram[i].empty());
ramindani592b6512021-10-08 21:15:19 +0000420 }
421}
422
ramindani431aad42022-02-01 21:44:29 +0000423TEST_P(GraphicsComposerAidlTest, GetDisplayConnectionType) {
424 const auto& [status, type] = mComposerClient->getDisplayConnectionType(getInvalidDisplayId());
425
426 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000427 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani431aad42022-02-01 21:44:29 +0000428
ramindani0291f112021-11-04 03:45:46 +0000429 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000430 const auto& [connectionTypeStatus, _] =
431 mComposerClient->getDisplayConnectionType(display.getDisplayId());
432 EXPECT_TRUE(connectionTypeStatus.isOk());
ramindani0291f112021-11-04 03:45:46 +0000433 }
434}
435
ramindani431aad42022-02-01 21:44:29 +0000436TEST_P(GraphicsComposerAidlTest, GetDisplayAttribute) {
ramindani0291f112021-11-04 03:45:46 +0000437 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000438 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
439 EXPECT_TRUE(status.isOk());
440
ramindani0291f112021-11-04 03:45:46 +0000441 for (const auto& config : configs) {
442 const std::array<DisplayAttribute, 4> requiredAttributes = {{
443 DisplayAttribute::WIDTH,
444 DisplayAttribute::HEIGHT,
445 DisplayAttribute::VSYNC_PERIOD,
446 DisplayAttribute::CONFIG_GROUP,
447 }};
ramindani0291f112021-11-04 03:45:46 +0000448 for (const auto& attribute : requiredAttributes) {
ramindani431aad42022-02-01 21:44:29 +0000449 const auto& [attribStatus, value] = mComposerClient->getDisplayAttribute(
450 display.getDisplayId(), config, attribute);
451 EXPECT_TRUE(attribStatus.isOk());
ramindani0291f112021-11-04 03:45:46 +0000452 EXPECT_NE(-1, value);
453 }
454
455 const std::array<DisplayAttribute, 2> optionalAttributes = {{
456 DisplayAttribute::DPI_X,
457 DisplayAttribute::DPI_Y,
458 }};
459 for (const auto& attribute : optionalAttributes) {
ramindani431aad42022-02-01 21:44:29 +0000460 const auto& [attribStatus, value] = mComposerClient->getDisplayAttribute(
461 display.getDisplayId(), config, attribute);
ramindanid5751092022-04-22 22:30:20 +0000462 EXPECT_TRUE(attribStatus.isOk() ||
463 (attribStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
464 IComposerClient::EX_UNSUPPORTED ==
465 attribStatus.getServiceSpecificError()));
ramindani0291f112021-11-04 03:45:46 +0000466 }
467 }
468 }
469}
470
ramindani431aad42022-02-01 21:44:29 +0000471TEST_P(GraphicsComposerAidlTest, CheckConfigsAreValid) {
ramindani0291f112021-11-04 03:45:46 +0000472 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000473 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
474 EXPECT_TRUE(status.isOk());
ramindani0291f112021-11-04 03:45:46 +0000475
476 EXPECT_FALSE(std::any_of(configs.begin(), configs.end(), [](auto config) {
477 return config == IComposerClient::INVALID_CONFIGURATION;
478 }));
479 }
480}
481
ramindani431aad42022-02-01 21:44:29 +0000482TEST_P(GraphicsComposerAidlTest, GetDisplayVsyncPeriod_BadDisplay) {
483 const auto& [status, vsyncPeriodNanos] =
484 mComposerClient->getDisplayVsyncPeriod(getInvalidDisplayId());
485
486 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000487 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani0291f112021-11-04 03:45:46 +0000488}
489
ramindani431aad42022-02-01 21:44:29 +0000490TEST_P(GraphicsComposerAidlTest, SetActiveConfigWithConstraints_BadDisplay) {
ramindani0291f112021-11-04 03:45:46 +0000491 VsyncPeriodChangeConstraints constraints;
ramindani0291f112021-11-04 03:45:46 +0000492 constraints.seamlessRequired = false;
493 constraints.desiredTimeNanos = systemTime();
ramindani431aad42022-02-01 21:44:29 +0000494 auto invalidDisplay = VtsDisplay(getInvalidDisplayId());
ramindani0291f112021-11-04 03:45:46 +0000495
ramindani431aad42022-02-01 21:44:29 +0000496 const auto& [status, timeline] = mComposerClient->setActiveConfigWithConstraints(
497 &invalidDisplay, /*config*/ 0, constraints);
498
499 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000500 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani0291f112021-11-04 03:45:46 +0000501}
502
ramindani431aad42022-02-01 21:44:29 +0000503TEST_P(GraphicsComposerAidlTest, SetActiveConfigWithConstraints_BadConfig) {
ramindani0291f112021-11-04 03:45:46 +0000504 VsyncPeriodChangeConstraints constraints;
ramindani0291f112021-11-04 03:45:46 +0000505 constraints.seamlessRequired = false;
506 constraints.desiredTimeNanos = systemTime();
507
508 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000509 int32_t constexpr kInvalidConfigId = IComposerClient::INVALID_CONFIGURATION;
510 const auto& [status, _] = mComposerClient->setActiveConfigWithConstraints(
511 &display, kInvalidConfigId, constraints);
512
513 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000514 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_CONFIG));
ramindani0291f112021-11-04 03:45:46 +0000515 }
516}
517
ramindani431aad42022-02-01 21:44:29 +0000518TEST_P(GraphicsComposerAidlTest, SetBootDisplayConfig_BadDisplay) {
ramindani476314c2022-03-16 00:17:08 +0000519 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
520 GTEST_SUCCEED() << "Boot Display Config not supported";
521 return;
522 }
ramindani431aad42022-02-01 21:44:29 +0000523 const auto& status = mComposerClient->setBootDisplayConfig(getInvalidDisplayId(), /*config*/ 0);
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100524
ramindani431aad42022-02-01 21:44:29 +0000525 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000526 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100527}
528
ramindani431aad42022-02-01 21:44:29 +0000529TEST_P(GraphicsComposerAidlTest, SetBootDisplayConfig_BadConfig) {
ramindani476314c2022-03-16 00:17:08 +0000530 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
531 GTEST_SUCCEED() << "Boot Display Config not supported";
532 return;
533 }
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100534 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000535 int32_t constexpr kInvalidConfigId = IComposerClient::INVALID_CONFIGURATION;
536 const auto& status =
537 mComposerClient->setBootDisplayConfig(display.getDisplayId(), kInvalidConfigId);
538
539 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000540 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_CONFIG));
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100541 }
542}
543
ramindani431aad42022-02-01 21:44:29 +0000544TEST_P(GraphicsComposerAidlTest, SetBootDisplayConfig) {
ramindani476314c2022-03-16 00:17:08 +0000545 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
546 GTEST_SUCCEED() << "Boot Display Config not supported";
547 return;
548 }
ramindani431aad42022-02-01 21:44:29 +0000549 const auto& [status, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
550 EXPECT_TRUE(status.isOk());
551 for (const auto& config : configs) {
552 EXPECT_TRUE(mComposerClient->setBootDisplayConfig(getPrimaryDisplayId(), config).isOk());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100553 }
554}
555
ramindani431aad42022-02-01 21:44:29 +0000556TEST_P(GraphicsComposerAidlTest, ClearBootDisplayConfig_BadDisplay) {
ramindani476314c2022-03-16 00:17:08 +0000557 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
558 GTEST_SUCCEED() << "Boot Display Config not supported";
559 return;
560 }
ramindani431aad42022-02-01 21:44:29 +0000561 const auto& status = mComposerClient->clearBootDisplayConfig(getInvalidDisplayId());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100562
ramindani431aad42022-02-01 21:44:29 +0000563 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000564 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100565}
566
ramindani431aad42022-02-01 21:44:29 +0000567TEST_P(GraphicsComposerAidlTest, ClearBootDisplayConfig) {
ramindani476314c2022-03-16 00:17:08 +0000568 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
569 GTEST_SUCCEED() << "Boot Display Config not supported";
570 return;
571 }
ramindani431aad42022-02-01 21:44:29 +0000572 EXPECT_TRUE(mComposerClient->clearBootDisplayConfig(getPrimaryDisplayId()).isOk());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100573}
574
ramindani431aad42022-02-01 21:44:29 +0000575TEST_P(GraphicsComposerAidlTest, GetPreferredBootDisplayConfig_BadDisplay) {
ramindani476314c2022-03-16 00:17:08 +0000576 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
577 GTEST_SUCCEED() << "Boot Display Config not supported";
578 return;
579 }
ramindani431aad42022-02-01 21:44:29 +0000580 const auto& [status, _] = mComposerClient->getPreferredBootDisplayConfig(getInvalidDisplayId());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100581
ramindani431aad42022-02-01 21:44:29 +0000582 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000583 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100584}
585
ramindani431aad42022-02-01 21:44:29 +0000586TEST_P(GraphicsComposerAidlTest, GetPreferredBootDisplayConfig) {
ramindani476314c2022-03-16 00:17:08 +0000587 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
588 GTEST_SUCCEED() << "Boot Display Config not supported";
589 return;
590 }
ramindani431aad42022-02-01 21:44:29 +0000591 const auto& [status, preferredDisplayConfig] =
592 mComposerClient->getPreferredBootDisplayConfig(getPrimaryDisplayId());
593 EXPECT_TRUE(status.isOk());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100594
ramindani431aad42022-02-01 21:44:29 +0000595 const auto& [configStatus, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
596
597 EXPECT_TRUE(configStatus.isOk());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100598 EXPECT_NE(configs.end(), std::find(configs.begin(), configs.end(), preferredDisplayConfig));
599}
600
ramindani476314c2022-03-16 00:17:08 +0000601TEST_P(GraphicsComposerAidlTest, BootDisplayConfig_Unsupported) {
602 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
603 const auto& [configStatus, config] =
604 mComposerClient->getActiveConfig(getPrimaryDisplayId());
605 EXPECT_TRUE(configStatus.isOk());
606
607 auto status = mComposerClient->setBootDisplayConfig(getPrimaryDisplayId(), config);
608 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000609 EXPECT_NO_FATAL_FAILURE(
610 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
ramindani476314c2022-03-16 00:17:08 +0000611
612 status = mComposerClient->getPreferredBootDisplayConfig(getPrimaryDisplayId()).first;
613 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000614 EXPECT_NO_FATAL_FAILURE(
615 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
ramindani476314c2022-03-16 00:17:08 +0000616
617 status = mComposerClient->clearBootDisplayConfig(getPrimaryDisplayId());
618 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000619 EXPECT_NO_FATAL_FAILURE(
620 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
ramindani476314c2022-03-16 00:17:08 +0000621 }
622}
623
ramindani431aad42022-02-01 21:44:29 +0000624TEST_P(GraphicsComposerAidlTest, SetAutoLowLatencyMode_BadDisplay) {
625 auto status = mComposerClient->setAutoLowLatencyMode(getInvalidDisplayId(), /*isEnabled*/ true);
626 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000627 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani431aad42022-02-01 21:44:29 +0000628
629 status = mComposerClient->setAutoLowLatencyMode(getInvalidDisplayId(), /*isEnabled*/ false);
630 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000631 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani0291f112021-11-04 03:45:46 +0000632}
633
ramindani431aad42022-02-01 21:44:29 +0000634TEST_P(GraphicsComposerAidlTest, SetAutoLowLatencyMode) {
ramindani0291f112021-11-04 03:45:46 +0000635 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000636 const auto& [status, capabilities] =
637 mComposerClient->getDisplayCapabilities(display.getDisplayId());
638 ASSERT_TRUE(status.isOk());
ramindani0291f112021-11-04 03:45:46 +0000639
640 const bool allmSupport =
641 std::find(capabilities.begin(), capabilities.end(),
642 DisplayCapability::AUTO_LOW_LATENCY_MODE) != capabilities.end();
643
644 if (!allmSupport) {
ramindani431aad42022-02-01 21:44:29 +0000645 const auto& statusIsOn = mComposerClient->setAutoLowLatencyMode(display.getDisplayId(),
646 /*isEnabled*/ true);
647 EXPECT_FALSE(statusIsOn.isOk());
ramindanid5751092022-04-22 22:30:20 +0000648 EXPECT_NO_FATAL_FAILURE(
649 assertServiceSpecificError(statusIsOn, IComposerClient::EX_UNSUPPORTED));
ramindani431aad42022-02-01 21:44:29 +0000650 const auto& statusIsOff = mComposerClient->setAutoLowLatencyMode(display.getDisplayId(),
651 /*isEnabled*/ false);
652 EXPECT_FALSE(statusIsOff.isOk());
ramindanid5751092022-04-22 22:30:20 +0000653 EXPECT_NO_FATAL_FAILURE(
654 assertServiceSpecificError(statusIsOff, IComposerClient::EX_UNSUPPORTED));
ramindani0291f112021-11-04 03:45:46 +0000655 GTEST_SUCCEED() << "Auto Low Latency Mode is not supported on display "
ramindani431aad42022-02-01 21:44:29 +0000656 << std::to_string(display.getDisplayId()) << ", skipping test";
ramindani0291f112021-11-04 03:45:46 +0000657 return;
658 }
659
ramindani431aad42022-02-01 21:44:29 +0000660 EXPECT_TRUE(mComposerClient->setAutoLowLatencyMode(display.getDisplayId(), true).isOk());
661 EXPECT_TRUE(mComposerClient->setAutoLowLatencyMode(display.getDisplayId(), false).isOk());
ramindani0291f112021-11-04 03:45:46 +0000662 }
663}
664
ramindani431aad42022-02-01 21:44:29 +0000665TEST_P(GraphicsComposerAidlTest, GetSupportedContentTypes_BadDisplay) {
666 const auto& [status, _] = mComposerClient->getSupportedContentTypes(getInvalidDisplayId());
667
668 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000669 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani0291f112021-11-04 03:45:46 +0000670}
671
ramindani431aad42022-02-01 21:44:29 +0000672TEST_P(GraphicsComposerAidlTest, GetSupportedContentTypes) {
ramindani0291f112021-11-04 03:45:46 +0000673 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000674 const auto& [status, supportedContentTypes] =
675 mComposerClient->getSupportedContentTypes(display.getDisplayId());
676 ASSERT_TRUE(status.isOk());
ramindani0291f112021-11-04 03:45:46 +0000677
678 const bool noneSupported =
679 std::find(supportedContentTypes.begin(), supportedContentTypes.end(),
680 ContentType::NONE) != supportedContentTypes.end();
ramindani431aad42022-02-01 21:44:29 +0000681
ramindani0291f112021-11-04 03:45:46 +0000682 EXPECT_FALSE(noneSupported);
683 }
684}
685
ramindani431aad42022-02-01 21:44:29 +0000686TEST_P(GraphicsComposerAidlTest, SetContentTypeNoneAlwaysAccepted) {
ramindani0291f112021-11-04 03:45:46 +0000687 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000688 EXPECT_TRUE(
689 mComposerClient->setContentType(display.getDisplayId(), ContentType::NONE).isOk());
ramindani0291f112021-11-04 03:45:46 +0000690 }
691}
692
ramindani431aad42022-02-01 21:44:29 +0000693TEST_P(GraphicsComposerAidlTest, SetContentType_BadDisplay) {
ramindani0291f112021-11-04 03:45:46 +0000694 constexpr ContentType types[] = {ContentType::NONE, ContentType::GRAPHICS, ContentType::PHOTO,
695 ContentType::CINEMA, ContentType::GAME};
696 for (const auto& type : types) {
ramindani431aad42022-02-01 21:44:29 +0000697 const auto& status = mComposerClient->setContentType(getInvalidDisplayId(), type);
ramindani0291f112021-11-04 03:45:46 +0000698
ramindani431aad42022-02-01 21:44:29 +0000699 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000700 EXPECT_NO_FATAL_FAILURE(
701 assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani0291f112021-11-04 03:45:46 +0000702 }
703}
704
ramindani431aad42022-02-01 21:44:29 +0000705TEST_P(GraphicsComposerAidlTest, SetGraphicsContentType) {
ramindani0291f112021-11-04 03:45:46 +0000706 Test_setContentType(ContentType::GRAPHICS, "GRAPHICS");
707}
708
ramindani431aad42022-02-01 21:44:29 +0000709TEST_P(GraphicsComposerAidlTest, SetPhotoContentType) {
ramindani0291f112021-11-04 03:45:46 +0000710 Test_setContentType(ContentType::PHOTO, "PHOTO");
711}
712
ramindani431aad42022-02-01 21:44:29 +0000713TEST_P(GraphicsComposerAidlTest, SetCinemaContentType) {
ramindani0291f112021-11-04 03:45:46 +0000714 Test_setContentType(ContentType::CINEMA, "CINEMA");
715}
716
ramindani431aad42022-02-01 21:44:29 +0000717TEST_P(GraphicsComposerAidlTest, SetGameContentType) {
ramindani0291f112021-11-04 03:45:46 +0000718 Test_setContentType(ContentType::GAME, "GAME");
719}
720
ramindanic2b8d082021-11-06 02:03:50 +0000721TEST_P(GraphicsComposerAidlTest, CreateVirtualDisplay) {
ramindani431aad42022-02-01 21:44:29 +0000722 const auto& [status, maxVirtualDisplayCount] = mComposerClient->getMaxVirtualDisplayCount();
723 EXPECT_TRUE(status.isOk());
724
ramindanic2b8d082021-11-06 02:03:50 +0000725 if (maxVirtualDisplayCount == 0) {
726 GTEST_SUCCEED() << "no virtual display support";
727 return;
728 }
729
ramindani431aad42022-02-01 21:44:29 +0000730 const auto& [virtualDisplayStatus, virtualDisplay] = mComposerClient->createVirtualDisplay(
731 /*width*/ 64, /*height*/ 64, common::PixelFormat::IMPLEMENTATION_DEFINED,
732 kBufferSlotCount);
ramindanic2b8d082021-11-06 02:03:50 +0000733
ramindani431aad42022-02-01 21:44:29 +0000734 ASSERT_TRUE(virtualDisplayStatus.isOk());
ramindanic2b8d082021-11-06 02:03:50 +0000735 EXPECT_TRUE(mComposerClient->destroyVirtualDisplay(virtualDisplay.display).isOk());
736}
737
ramindani431aad42022-02-01 21:44:29 +0000738TEST_P(GraphicsComposerAidlTest, DestroyVirtualDisplay_BadDisplay) {
739 const auto& [status, maxDisplayCount] = mComposerClient->getMaxVirtualDisplayCount();
740 EXPECT_TRUE(status.isOk());
741
ramindani2740bac2021-11-24 22:58:32 +0000742 if (maxDisplayCount == 0) {
743 GTEST_SUCCEED() << "no virtual display support";
744 return;
745 }
ramindani2740bac2021-11-24 22:58:32 +0000746
ramindani431aad42022-02-01 21:44:29 +0000747 const auto& destroyStatus = mComposerClient->destroyVirtualDisplay(getInvalidDisplayId());
748
749 EXPECT_FALSE(destroyStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000750 EXPECT_NO_FATAL_FAILURE(
751 assertServiceSpecificError(destroyStatus, IComposerClient::EX_BAD_DISPLAY));
ramindani2740bac2021-11-24 22:58:32 +0000752}
753
754TEST_P(GraphicsComposerAidlTest, CreateLayer) {
ramindani431aad42022-02-01 21:44:29 +0000755 const auto& [status, layer] =
756 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
ramindani2740bac2021-11-24 22:58:32 +0000757
ramindani431aad42022-02-01 21:44:29 +0000758 EXPECT_TRUE(status.isOk());
759 EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
ramindani2740bac2021-11-24 22:58:32 +0000760}
761
ramindani431aad42022-02-01 21:44:29 +0000762TEST_P(GraphicsComposerAidlTest, CreateLayer_BadDisplay) {
763 const auto& [status, _] = mComposerClient->createLayer(getInvalidDisplayId(), kBufferSlotCount);
ramindani2740bac2021-11-24 22:58:32 +0000764
ramindani431aad42022-02-01 21:44:29 +0000765 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000766 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani2740bac2021-11-24 22:58:32 +0000767}
768
ramindani431aad42022-02-01 21:44:29 +0000769TEST_P(GraphicsComposerAidlTest, DestroyLayer_BadDisplay) {
770 const auto& [status, layer] =
771 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
772 EXPECT_TRUE(status.isOk());
ramindani2740bac2021-11-24 22:58:32 +0000773
ramindani431aad42022-02-01 21:44:29 +0000774 const auto& destroyStatus = mComposerClient->destroyLayer(getInvalidDisplayId(), layer);
ramindani2740bac2021-11-24 22:58:32 +0000775
ramindani431aad42022-02-01 21:44:29 +0000776 EXPECT_FALSE(destroyStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000777 EXPECT_NO_FATAL_FAILURE(
778 assertServiceSpecificError(destroyStatus, IComposerClient::EX_BAD_DISPLAY));
ramindani431aad42022-02-01 21:44:29 +0000779 ASSERT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
ramindani2740bac2021-11-24 22:58:32 +0000780}
781
ramindani431aad42022-02-01 21:44:29 +0000782TEST_P(GraphicsComposerAidlTest, DestroyLayer_BadLayerError) {
ramindani2740bac2021-11-24 22:58:32 +0000783 // We haven't created any layers yet, so any id should be invalid
ramindani431aad42022-02-01 21:44:29 +0000784 const auto& status = mComposerClient->destroyLayer(getPrimaryDisplayId(), /*layer*/ 1);
ramindani2740bac2021-11-24 22:58:32 +0000785
ramindani431aad42022-02-01 21:44:29 +0000786 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000787 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_LAYER));
ramindani2740bac2021-11-24 22:58:32 +0000788}
789
ramindani431aad42022-02-01 21:44:29 +0000790TEST_P(GraphicsComposerAidlTest, GetActiveConfig_BadDisplay) {
791 const auto& [status, _] = mComposerClient->getActiveConfig(getInvalidDisplayId());
ramindani2740bac2021-11-24 22:58:32 +0000792
ramindani431aad42022-02-01 21:44:29 +0000793 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000794 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani2740bac2021-11-24 22:58:32 +0000795}
796
797TEST_P(GraphicsComposerAidlTest, GetDisplayConfig) {
ramindani431aad42022-02-01 21:44:29 +0000798 const auto& [status, _] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
799 EXPECT_TRUE(status.isOk());
ramindani2740bac2021-11-24 22:58:32 +0000800}
801
ramindani431aad42022-02-01 21:44:29 +0000802TEST_P(GraphicsComposerAidlTest, GetDisplayConfig_BadDisplay) {
803 const auto& [status, _] = mComposerClient->getDisplayConfigs(getInvalidDisplayId());
ramindani2740bac2021-11-24 22:58:32 +0000804
ramindani431aad42022-02-01 21:44:29 +0000805 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000806 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani2740bac2021-11-24 22:58:32 +0000807}
808
809TEST_P(GraphicsComposerAidlTest, GetDisplayName) {
ramindani431aad42022-02-01 21:44:29 +0000810 const auto& [status, _] = mComposerClient->getDisplayName(getPrimaryDisplayId());
811 EXPECT_TRUE(status.isOk());
ramindani2740bac2021-11-24 22:58:32 +0000812}
813
Sally Qi2600d342022-08-16 12:46:17 -0700814// TODO(b/250036572): disable this due to no implementation and revup on cuttlefish
815TEST_P(GraphicsComposerAidlTest, DISABLED_GetOverlaySupport) {
816 const auto& [status, _] = mComposerClient->getOverlaySupport();
817 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
818 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
819 GTEST_SUCCEED() << "getOverlaySupport is not supported";
820 return;
821 }
822
823 ASSERT_TRUE(status.isOk());
824}
825
ramindani431aad42022-02-01 21:44:29 +0000826TEST_P(GraphicsComposerAidlTest, GetDisplayPhysicalOrientation_BadDisplay) {
827 const auto& [status, _] = mComposerClient->getDisplayPhysicalOrientation(getInvalidDisplayId());
Ady Abrahamae12e382022-01-13 18:06:21 -0800828
ramindani431aad42022-02-01 21:44:29 +0000829 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000830 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
Ady Abrahamae12e382022-01-13 18:06:21 -0800831}
832
833TEST_P(GraphicsComposerAidlTest, GetDisplayPhysicalOrientation) {
834 const auto allowedDisplayOrientations = std::array<Transform, 4>{
835 Transform::NONE,
836 Transform::ROT_90,
837 Transform::ROT_180,
838 Transform::ROT_270,
839 };
840
ramindani431aad42022-02-01 21:44:29 +0000841 const auto& [status, displayOrientation] =
842 mComposerClient->getDisplayPhysicalOrientation(getPrimaryDisplayId());
Ady Abrahamae12e382022-01-13 18:06:21 -0800843
ramindani431aad42022-02-01 21:44:29 +0000844 EXPECT_TRUE(status.isOk());
Ady Abrahamae12e382022-01-13 18:06:21 -0800845 EXPECT_NE(std::find(allowedDisplayOrientations.begin(), allowedDisplayOrientations.end(),
846 displayOrientation),
847 allowedDisplayOrientations.end());
848}
849
ramindani2740bac2021-11-24 22:58:32 +0000850TEST_P(GraphicsComposerAidlTest, SetClientTargetSlotCount) {
ramindani431aad42022-02-01 21:44:29 +0000851 EXPECT_TRUE(mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kBufferSlotCount)
852 .isOk());
ramindani2740bac2021-11-24 22:58:32 +0000853}
854
855TEST_P(GraphicsComposerAidlTest, SetActiveConfig) {
ramindani431aad42022-02-01 21:44:29 +0000856 const auto& [status, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
857 EXPECT_TRUE(status.isOk());
858
859 for (const auto& config : configs) {
860 auto display = getEditablePrimaryDisplay();
861 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config).isOk());
862 const auto& [configStatus, config1] =
863 mComposerClient->getActiveConfig(getPrimaryDisplayId());
864 EXPECT_TRUE(configStatus.isOk());
ramindani2740bac2021-11-24 22:58:32 +0000865 EXPECT_EQ(config, config1);
866 }
867}
868
869TEST_P(GraphicsComposerAidlTest, SetActiveConfigPowerCycle) {
ramindani431aad42022-02-01 21:44:29 +0000870 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
871 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
ramindani2740bac2021-11-24 22:58:32 +0000872
ramindani431aad42022-02-01 21:44:29 +0000873 const auto& [status, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
874 EXPECT_TRUE(status.isOk());
875
876 for (const auto& config : configs) {
877 auto display = getEditablePrimaryDisplay();
878 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config).isOk());
879 const auto& [config1Status, config1] =
880 mComposerClient->getActiveConfig(getPrimaryDisplayId());
881 EXPECT_TRUE(config1Status.isOk());
ramindani2740bac2021-11-24 22:58:32 +0000882 EXPECT_EQ(config, config1);
883
ramindani431aad42022-02-01 21:44:29 +0000884 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
885 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
886 const auto& [config2Status, config2] =
887 mComposerClient->getActiveConfig(getPrimaryDisplayId());
888 EXPECT_TRUE(config2Status.isOk());
889 EXPECT_EQ(config, config2);
ramindani2740bac2021-11-24 22:58:32 +0000890 }
891}
892
ramindani2740bac2021-11-24 22:58:32 +0000893TEST_P(GraphicsComposerAidlTest, SetPowerModeUnsupported) {
ramindani431aad42022-02-01 21:44:29 +0000894 const auto& [status, capabilities] =
895 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
896 ASSERT_TRUE(status.isOk());
897
Ady Abraham6679baf2021-12-08 18:28:27 -0800898 const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
899 DisplayCapability::DOZE) != capabilities.end();
900 const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
901 DisplayCapability::SUSPEND) != capabilities.end();
ramindani2740bac2021-11-24 22:58:32 +0000902
ramindani431aad42022-02-01 21:44:29 +0000903 if (!isDozeSupported) {
904 const auto& powerModeDozeStatus =
905 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE);
906 EXPECT_FALSE(powerModeDozeStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000907 EXPECT_NO_FATAL_FAILURE(
908 assertServiceSpecificError(powerModeDozeStatus, IComposerClient::EX_UNSUPPORTED));
ramindani431aad42022-02-01 21:44:29 +0000909
910 const auto& powerModeDozeSuspendStatus =
911 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE_SUSPEND);
912 EXPECT_FALSE(powerModeDozeSuspendStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000913 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeDozeSuspendStatus,
914 IComposerClient::EX_UNSUPPORTED));
ramindani2740bac2021-11-24 22:58:32 +0000915 }
Ady Abraham6679baf2021-12-08 18:28:27 -0800916
917 if (!isSuspendSupported) {
ramindani431aad42022-02-01 21:44:29 +0000918 const auto& powerModeSuspendStatus =
919 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON_SUSPEND);
920 EXPECT_FALSE(powerModeSuspendStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000921 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeSuspendStatus,
922 IComposerClient::EX_UNSUPPORTED));
Ady Abraham6679baf2021-12-08 18:28:27 -0800923
ramindani431aad42022-02-01 21:44:29 +0000924 const auto& powerModeDozeSuspendStatus =
925 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE_SUSPEND);
926 EXPECT_FALSE(powerModeDozeSuspendStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000927 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeDozeSuspendStatus,
928 IComposerClient::EX_UNSUPPORTED));
Ady Abraham6679baf2021-12-08 18:28:27 -0800929 }
ramindani2740bac2021-11-24 22:58:32 +0000930}
931
932TEST_P(GraphicsComposerAidlTest, SetVsyncEnabled) {
ramindani431aad42022-02-01 21:44:29 +0000933 mComposerClient->setVsyncAllowed(true);
ramindani2740bac2021-11-24 22:58:32 +0000934
ramindani431aad42022-02-01 21:44:29 +0000935 EXPECT_TRUE(mComposerClient->setVsync(getPrimaryDisplayId(), true).isOk());
ramindani2740bac2021-11-24 22:58:32 +0000936 usleep(60 * 1000);
ramindani431aad42022-02-01 21:44:29 +0000937 EXPECT_TRUE(mComposerClient->setVsync(getPrimaryDisplayId(), false).isOk());
ramindani2740bac2021-11-24 22:58:32 +0000938
ramindani431aad42022-02-01 21:44:29 +0000939 mComposerClient->setVsyncAllowed(false);
ramindani2740bac2021-11-24 22:58:32 +0000940}
941
ramindanic2b8d082021-11-06 02:03:50 +0000942TEST_P(GraphicsComposerAidlTest, SetPowerMode) {
ramindani431aad42022-02-01 21:44:29 +0000943 const auto& [status, capabilities] =
944 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
945 ASSERT_TRUE(status.isOk());
946
Ady Abraham6679baf2021-12-08 18:28:27 -0800947 const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
948 DisplayCapability::DOZE) != capabilities.end();
949 const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
950 DisplayCapability::SUSPEND) != capabilities.end();
951
ramindanic2b8d082021-11-06 02:03:50 +0000952 std::vector<PowerMode> modes;
953 modes.push_back(PowerMode::OFF);
ramindanic2b8d082021-11-06 02:03:50 +0000954 modes.push_back(PowerMode::ON);
955
Ady Abraham6679baf2021-12-08 18:28:27 -0800956 if (isSuspendSupported) {
957 modes.push_back(PowerMode::ON_SUSPEND);
958 }
959
ramindani770d7082021-11-30 00:36:42 +0000960 if (isDozeSupported) {
961 modes.push_back(PowerMode::DOZE);
Ady Abraham6679baf2021-12-08 18:28:27 -0800962 }
963
964 if (isSuspendSupported && isDozeSupported) {
ramindani770d7082021-11-30 00:36:42 +0000965 modes.push_back(PowerMode::DOZE_SUSPEND);
966 }
967
ramindanic2b8d082021-11-06 02:03:50 +0000968 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +0000969 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindanic2b8d082021-11-06 02:03:50 +0000970 }
971}
972
973TEST_P(GraphicsComposerAidlTest, SetPowerModeVariations) {
ramindani431aad42022-02-01 21:44:29 +0000974 const auto& [status, capabilities] =
975 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
976 ASSERT_TRUE(status.isOk());
977
Ady Abraham6679baf2021-12-08 18:28:27 -0800978 const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
979 DisplayCapability::DOZE) != capabilities.end();
980 const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
981 DisplayCapability::SUSPEND) != capabilities.end();
982
ramindanic2b8d082021-11-06 02:03:50 +0000983 std::vector<PowerMode> modes;
984
985 modes.push_back(PowerMode::OFF);
ramindani770d7082021-11-30 00:36:42 +0000986 modes.push_back(PowerMode::ON);
ramindanic2b8d082021-11-06 02:03:50 +0000987 modes.push_back(PowerMode::OFF);
ramindanic2b8d082021-11-06 02:03:50 +0000988 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +0000989 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindanic2b8d082021-11-06 02:03:50 +0000990 }
ramindani770d7082021-11-30 00:36:42 +0000991 modes.clear();
ramindanic2b8d082021-11-06 02:03:50 +0000992
ramindani770d7082021-11-30 00:36:42 +0000993 modes.push_back(PowerMode::OFF);
994 modes.push_back(PowerMode::OFF);
995 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +0000996 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindani770d7082021-11-30 00:36:42 +0000997 }
ramindanic2b8d082021-11-06 02:03:50 +0000998 modes.clear();
999
1000 modes.push_back(PowerMode::ON);
1001 modes.push_back(PowerMode::ON);
ramindanic2b8d082021-11-06 02:03:50 +00001002 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001003 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindanic2b8d082021-11-06 02:03:50 +00001004 }
ramindanic2b8d082021-11-06 02:03:50 +00001005 modes.clear();
1006
Ady Abraham6679baf2021-12-08 18:28:27 -08001007 if (isSuspendSupported) {
1008 modes.push_back(PowerMode::ON_SUSPEND);
1009 modes.push_back(PowerMode::ON_SUSPEND);
1010 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001011 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
Ady Abraham6679baf2021-12-08 18:28:27 -08001012 }
1013 modes.clear();
ramindanic2b8d082021-11-06 02:03:50 +00001014 }
1015
ramindanic2b8d082021-11-06 02:03:50 +00001016 if (isDozeSupported) {
ramindanic2b8d082021-11-06 02:03:50 +00001017 modes.push_back(PowerMode::DOZE);
1018 modes.push_back(PowerMode::DOZE);
ramindanic2b8d082021-11-06 02:03:50 +00001019 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001020 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindanic2b8d082021-11-06 02:03:50 +00001021 }
ramindanic2b8d082021-11-06 02:03:50 +00001022 modes.clear();
Ady Abraham6679baf2021-12-08 18:28:27 -08001023 }
ramindanic2b8d082021-11-06 02:03:50 +00001024
Ady Abraham6679baf2021-12-08 18:28:27 -08001025 if (isSuspendSupported && isDozeSupported) {
ramindanic2b8d082021-11-06 02:03:50 +00001026 modes.push_back(PowerMode::DOZE_SUSPEND);
1027 modes.push_back(PowerMode::DOZE_SUSPEND);
ramindanic2b8d082021-11-06 02:03:50 +00001028 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001029 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindanic2b8d082021-11-06 02:03:50 +00001030 }
Ady Abraham6679baf2021-12-08 18:28:27 -08001031 modes.clear();
ramindanic2b8d082021-11-06 02:03:50 +00001032 }
1033}
1034
ramindani431aad42022-02-01 21:44:29 +00001035TEST_P(GraphicsComposerAidlTest, SetPowerMode_BadDisplay) {
1036 const auto& status = mComposerClient->setPowerMode(getInvalidDisplayId(), PowerMode::ON);
ramindanic2b8d082021-11-06 02:03:50 +00001037
ramindani431aad42022-02-01 21:44:29 +00001038 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00001039 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindanic2b8d082021-11-06 02:03:50 +00001040}
1041
ramindani431aad42022-02-01 21:44:29 +00001042TEST_P(GraphicsComposerAidlTest, SetPowerMode_BadParameter) {
1043 const auto& status =
1044 mComposerClient->setPowerMode(getPrimaryDisplayId(), static_cast<PowerMode>(-1));
ramindanic2b8d082021-11-06 02:03:50 +00001045
ramindani431aad42022-02-01 21:44:29 +00001046 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00001047 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
ramindanic2b8d082021-11-06 02:03:50 +00001048}
1049
ramindanic2b8d082021-11-06 02:03:50 +00001050TEST_P(GraphicsComposerAidlTest, GetDataspaceSaturationMatrix) {
ramindani431aad42022-02-01 21:44:29 +00001051 const auto& [status, matrix] =
1052 mComposerClient->getDataspaceSaturationMatrix(common::Dataspace::SRGB_LINEAR);
1053 ASSERT_TRUE(status.isOk());
1054 ASSERT_EQ(16, matrix.size()); // matrix should not be empty if call succeeded.
ramindanideb059e2021-11-18 01:57:25 +00001055
ramindanic2b8d082021-11-06 02:03:50 +00001056 // the last row is known
ramindani431aad42022-02-01 21:44:29 +00001057 EXPECT_EQ(0.0f, matrix[12]);
1058 EXPECT_EQ(0.0f, matrix[13]);
1059 EXPECT_EQ(0.0f, matrix[14]);
1060 EXPECT_EQ(1.0f, matrix[15]);
ramindanic2b8d082021-11-06 02:03:50 +00001061}
1062
ramindani431aad42022-02-01 21:44:29 +00001063TEST_P(GraphicsComposerAidlTest, GetDataspaceSaturationMatrix_BadParameter) {
1064 const auto& [status, matrix] =
1065 mComposerClient->getDataspaceSaturationMatrix(common::Dataspace::UNKNOWN);
ramindanic2b8d082021-11-06 02:03:50 +00001066
ramindani431aad42022-02-01 21:44:29 +00001067 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00001068 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
ramindanic2b8d082021-11-06 02:03:50 +00001069}
1070
ramindanidcfe3a82021-11-29 17:00:31 +00001071// Tests for Command.
1072class GraphicsComposerAidlCommandTest : public GraphicsComposerAidlTest {
1073 protected:
ramindanidcfe3a82021-11-29 17:00:31 +00001074 void TearDown() override {
Ady Abraham3192f3d2021-12-03 16:08:56 -08001075 const auto errors = mReader.takeErrors();
1076 ASSERT_TRUE(mReader.takeErrors().empty());
ramindani431aad42022-02-01 21:44:29 +00001077 ASSERT_TRUE(mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty());
Ady Abraham3192f3d2021-12-03 16:08:56 -08001078
ramindanidcfe3a82021-11-29 17:00:31 +00001079 ASSERT_NO_FATAL_FAILURE(GraphicsComposerAidlTest::TearDown());
1080 }
1081
1082 void execute() {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001083 std::vector<CommandResultPayload> payloads;
1084 for (auto& [_, writer] : mWriters) {
1085 const auto& commands = writer.getPendingCommands();
1086 if (commands.empty()) {
1087 writer.reset();
1088 continue;
1089 }
1090
1091 auto [status, results] = mComposerClient->executeCommands(commands);
1092 ASSERT_TRUE(status.isOk()) << "executeCommands failed " << status.getDescription();
1093 writer.reset();
1094
1095 payloads.reserve(payloads.size() + results.size());
1096 payloads.insert(payloads.end(), std::make_move_iterator(results.begin()),
1097 std::make_move_iterator(results.end()));
ramindanidcfe3a82021-11-29 17:00:31 +00001098 }
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001099 mReader.parse(std::move(payloads));
ramindanidcfe3a82021-11-29 17:00:31 +00001100 }
1101
1102 static inline auto toTimePoint(nsecs_t time) {
1103 return std::chrono::time_point<std::chrono::steady_clock>(std::chrono::nanoseconds(time));
1104 }
1105
ramindanidcfe3a82021-11-29 17:00:31 +00001106 void forEachTwoConfigs(int64_t display, std::function<void(int32_t, int32_t)> func) {
ramindani431aad42022-02-01 21:44:29 +00001107 const auto& [status, displayConfigs] = mComposerClient->getDisplayConfigs(display);
1108 ASSERT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001109 for (const int32_t config1 : displayConfigs) {
1110 for (const int32_t config2 : displayConfigs) {
1111 if (config1 != config2) {
1112 func(config1, config2);
1113 }
1114 }
1115 }
1116 }
1117
1118 void waitForVsyncPeriodChange(int64_t display, const VsyncPeriodChangeTimeline& timeline,
1119 int64_t desiredTimeNanos, int64_t oldPeriodNanos,
1120 int64_t newPeriodNanos) {
1121 const auto kChangeDeadline = toTimePoint(timeline.newVsyncAppliedTimeNanos) + 100ms;
1122 while (std::chrono::steady_clock::now() <= kChangeDeadline) {
ramindani431aad42022-02-01 21:44:29 +00001123 const auto& [status, vsyncPeriodNanos] =
1124 mComposerClient->getDisplayVsyncPeriod(display);
1125 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001126 if (systemTime() <= desiredTimeNanos) {
1127 EXPECT_EQ(vsyncPeriodNanos, oldPeriodNanos);
1128 } else if (vsyncPeriodNanos == newPeriodNanos) {
1129 break;
1130 }
1131 std::this_thread::sleep_for(std::chrono::nanoseconds(oldPeriodNanos));
1132 }
1133 }
1134
Brian Lindahlca3eef22022-12-09 00:32:11 -07001135 sp<GraphicBuffer> allocate(uint32_t width, uint32_t height,
1136 ::android::PixelFormat pixelFormat) {
ramindanidcfe3a82021-11-29 17:00:31 +00001137 return sp<GraphicBuffer>::make(
Brian Lindahlca3eef22022-12-09 00:32:11 -07001138 width, height, pixelFormat, /*layerCount*/ 1U,
1139 static_cast<uint64_t>(common::BufferUsage::CPU_WRITE_OFTEN) |
1140 static_cast<uint64_t>(common::BufferUsage::CPU_READ_OFTEN) |
1141 static_cast<uint64_t>(common::BufferUsage::COMPOSER_OVERLAY),
ramindanidcfe3a82021-11-29 17:00:31 +00001142 "VtsHalGraphicsComposer3_TargetTest");
1143 }
1144
Brian Lindahlca3eef22022-12-09 00:32:11 -07001145 sp<GraphicBuffer> allocate(::android::PixelFormat pixelFormat) {
1146 return allocate(static_cast<uint32_t>(getPrimaryDisplay().getDisplayWidth()),
1147 static_cast<uint32_t>(getPrimaryDisplay().getDisplayHeight()), pixelFormat);
1148 }
1149
ramindanidcfe3a82021-11-29 17:00:31 +00001150 void sendRefreshFrame(const VtsDisplay& display, const VsyncPeriodChangeTimeline* timeline) {
1151 if (timeline != nullptr) {
1152 // Refresh time should be before newVsyncAppliedTimeNanos
1153 EXPECT_LT(timeline->refreshTimeNanos, timeline->newVsyncAppliedTimeNanos);
1154
1155 std::this_thread::sleep_until(toTimePoint(timeline->refreshTimeNanos));
1156 }
1157
ramindani431aad42022-02-01 21:44:29 +00001158 EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::ON).isOk());
1159 EXPECT_TRUE(mComposerClient
1160 ->setColorMode(display.getDisplayId(), ColorMode::NATIVE,
1161 RenderIntent::COLORIMETRIC)
1162 .isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001163
ramindani431aad42022-02-01 21:44:29 +00001164 const auto& [status, layer] =
1165 mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount);
1166 EXPECT_TRUE(status.isOk());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001167 auto& writer = getWriter(display.getDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001168 {
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001169 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindanidcfe3a82021-11-29 17:00:31 +00001170 ASSERT_NE(nullptr, buffer);
1171 ASSERT_EQ(::android::OK, buffer->initCheck());
1172 ASSERT_NE(nullptr, buffer->handle);
1173
ramindani431aad42022-02-01 21:44:29 +00001174 configureLayer(display, layer, Composition::DEVICE, display.getFrameRect(),
1175 display.getCrop());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001176 writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, buffer->handle,
1177 /*acquireFence*/ -1);
1178 writer.setLayerDataspace(display.getDisplayId(), layer, common::Dataspace::UNKNOWN);
ramindanidcfe3a82021-11-29 17:00:31 +00001179
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001180 writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp);
ramindanidcfe3a82021-11-29 17:00:31 +00001181 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001182 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001183
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001184 writer.presentDisplay(display.getDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001185 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001186 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001187 }
1188
1189 {
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001190 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindanidcfe3a82021-11-29 17:00:31 +00001191 ASSERT_NE(nullptr, buffer->handle);
1192
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001193 writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, buffer->handle,
1194 /*acquireFence*/ -1);
1195 writer.setLayerSurfaceDamage(display.getDisplayId(), layer,
1196 std::vector<Rect>(1, {0, 0, 10, 10}));
1197 writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp);
ramindanidcfe3a82021-11-29 17:00:31 +00001198 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001199 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001200
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001201 writer.presentDisplay(display.getDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001202 execute();
1203 }
1204
ramindani431aad42022-02-01 21:44:29 +00001205 EXPECT_TRUE(mComposerClient->destroyLayer(display.getDisplayId(), layer).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001206 }
1207
Ady Abraham72c5b502021-12-10 17:23:39 -08001208 sp<::android::Fence> presentAndGetFence(
1209 std::optional<ClockMonotonicTimestamp> expectedPresentTime) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001210 auto& writer = getWriter(getPrimaryDisplayId());
1211 writer.validateDisplay(getPrimaryDisplayId(), expectedPresentTime);
Ady Abraham72c5b502021-12-10 17:23:39 -08001212 execute();
1213 EXPECT_TRUE(mReader.takeErrors().empty());
1214
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001215 writer.presentDisplay(getPrimaryDisplayId());
Ady Abraham72c5b502021-12-10 17:23:39 -08001216 execute();
1217 EXPECT_TRUE(mReader.takeErrors().empty());
1218
ramindani431aad42022-02-01 21:44:29 +00001219 auto presentFence = mReader.takePresentFence(getPrimaryDisplayId());
Ady Abraham46219f52021-12-20 09:44:31 -08001220 // take ownership
1221 const int fenceOwner = presentFence.get();
1222 *presentFence.getR() = -1;
1223 EXPECT_NE(-1, fenceOwner);
1224 return sp<::android::Fence>::make(fenceOwner);
Ady Abraham72c5b502021-12-10 17:23:39 -08001225 }
1226
1227 int32_t getVsyncPeriod() {
ramindani431aad42022-02-01 21:44:29 +00001228 const auto& [status, activeConfig] =
1229 mComposerClient->getActiveConfig(getPrimaryDisplayId());
1230 EXPECT_TRUE(status.isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001231
ramindani431aad42022-02-01 21:44:29 +00001232 const auto& [vsyncPeriodStatus, vsyncPeriod] = mComposerClient->getDisplayAttribute(
1233 getPrimaryDisplayId(), activeConfig, DisplayAttribute::VSYNC_PERIOD);
1234 EXPECT_TRUE(vsyncPeriodStatus.isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001235 return vsyncPeriod;
1236 }
1237
1238 int64_t createOnScreenLayer() {
ramindani431aad42022-02-01 21:44:29 +00001239 const auto& [status, layer] =
1240 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1241 EXPECT_TRUE(status.isOk());
1242 Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
1243 getPrimaryDisplay().getDisplayHeight()};
1244 FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
1245 (float)getPrimaryDisplay().getDisplayHeight()};
1246 configureLayer(getPrimaryDisplay(), layer, Composition::DEVICE, displayFrame, cropRect);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001247 auto& writer = getWriter(getPrimaryDisplayId());
1248 writer.setLayerDataspace(getPrimaryDisplayId(), layer, common::Dataspace::UNKNOWN);
Ady Abraham72c5b502021-12-10 17:23:39 -08001249 return layer;
1250 }
1251
Midas Chiena0b56bd2022-01-13 23:27:33 +08001252 bool hasDisplayCapability(int64_t display, DisplayCapability cap) {
ramindani431aad42022-02-01 21:44:29 +00001253 const auto& [status, capabilities] = mComposerClient->getDisplayCapabilities(display);
1254 EXPECT_TRUE(status.isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08001255
1256 return std::find(capabilities.begin(), capabilities.end(), cap) != capabilities.end();
1257 }
1258
ramindanidcfe3a82021-11-29 17:00:31 +00001259 void Test_setActiveConfigWithConstraints(const TestParameters& params) {
1260 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +00001261 forEachTwoConfigs(display.getDisplayId(), [&](int32_t config1, int32_t config2) {
1262 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001263 sendRefreshFrame(display, nullptr);
1264
ramindani431aad42022-02-01 21:44:29 +00001265 const auto displayConfigGroup1 = display.getDisplayConfig(config1);
1266 int32_t vsyncPeriod1 = displayConfigGroup1.vsyncPeriod;
1267 int32_t configGroup1 = displayConfigGroup1.configGroup;
1268
1269 const auto displayConfigGroup2 = display.getDisplayConfig(config2);
1270 int32_t vsyncPeriod2 = displayConfigGroup2.vsyncPeriod;
1271 int32_t configGroup2 = displayConfigGroup2.configGroup;
ramindanidcfe3a82021-11-29 17:00:31 +00001272
1273 if (vsyncPeriod1 == vsyncPeriod2) {
1274 return; // continue
1275 }
1276
1277 // We don't allow delayed change when changing config groups
1278 if (params.delayForChange > 0 && configGroup1 != configGroup2) {
1279 return; // continue
1280 }
1281
ramindanidcfe3a82021-11-29 17:00:31 +00001282 VsyncPeriodChangeConstraints constraints = {
1283 .desiredTimeNanos = systemTime() + params.delayForChange,
1284 .seamlessRequired = false};
ramindani431aad42022-02-01 21:44:29 +00001285 const auto& [status, timeline] = mComposerClient->setActiveConfigWithConstraints(
1286 &display, config2, constraints);
1287 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001288
1289 EXPECT_TRUE(timeline.newVsyncAppliedTimeNanos >= constraints.desiredTimeNanos);
1290 // Refresh rate should change within a reasonable time
1291 constexpr std::chrono::nanoseconds kReasonableTimeForChange = 1s; // 1 second
1292 EXPECT_TRUE(timeline.newVsyncAppliedTimeNanos - constraints.desiredTimeNanos <=
1293 kReasonableTimeForChange.count());
1294
1295 if (timeline.refreshRequired) {
1296 if (params.refreshMiss) {
1297 // Miss the refresh frame on purpose to make sure the implementation sends a
1298 // callback
1299 std::this_thread::sleep_until(toTimePoint(timeline.refreshTimeNanos) +
1300 100ms);
1301 }
1302 sendRefreshFrame(display, &timeline);
1303 }
ramindani431aad42022-02-01 21:44:29 +00001304 waitForVsyncPeriodChange(display.getDisplayId(), timeline,
1305 constraints.desiredTimeNanos, vsyncPeriod1, vsyncPeriod2);
ramindanidcfe3a82021-11-29 17:00:31 +00001306
1307 // At this point the refresh rate should have changed already, however in rare
1308 // cases the implementation might have missed the deadline. In this case a new
1309 // timeline should have been provided.
ramindani431aad42022-02-01 21:44:29 +00001310 auto newTimeline = mComposerClient->takeLastVsyncPeriodChangeTimeline();
ramindanidcfe3a82021-11-29 17:00:31 +00001311 if (timeline.refreshRequired && params.refreshMiss) {
1312 EXPECT_TRUE(newTimeline.has_value());
1313 }
1314
1315 if (newTimeline.has_value()) {
1316 if (newTimeline->refreshRequired) {
1317 sendRefreshFrame(display, &newTimeline.value());
1318 }
ramindani431aad42022-02-01 21:44:29 +00001319 waitForVsyncPeriodChange(display.getDisplayId(), newTimeline.value(),
ramindanidcfe3a82021-11-29 17:00:31 +00001320 constraints.desiredTimeNanos, vsyncPeriod1,
1321 vsyncPeriod2);
1322 }
1323
ramindani431aad42022-02-01 21:44:29 +00001324 const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanos] =
1325 mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
1326 EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001327 EXPECT_EQ(vsyncPeriodNanos, vsyncPeriod2);
1328 });
1329 }
1330 }
1331
Ady Abraham72c5b502021-12-10 17:23:39 -08001332 void Test_expectedPresentTime(std::optional<int> framesDelay) {
Jason Macnak325e8232022-01-24 14:48:55 -08001333 if (hasCapability(Capability::PRESENT_FENCE_IS_NOT_RELIABLE)) {
1334 GTEST_SUCCEED() << "Device has unreliable present fences capability, skipping";
1335 return;
1336 }
1337
ramindani431aad42022-02-01 21:44:29 +00001338 ASSERT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001339
1340 const auto vsyncPeriod = getVsyncPeriod();
1341
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001342 const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1343 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
Ady Abraham72c5b502021-12-10 17:23:39 -08001344 ASSERT_NE(nullptr, buffer1);
1345 ASSERT_NE(nullptr, buffer2);
1346
1347 const auto layer = createOnScreenLayer();
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001348 auto& writer = getWriter(getPrimaryDisplayId());
1349 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer1->handle,
1350 /*acquireFence*/ -1);
Ady Abraham72c5b502021-12-10 17:23:39 -08001351 const sp<::android::Fence> presentFence1 =
1352 presentAndGetFence(ComposerClientWriter::kNoTimestamp);
1353 presentFence1->waitForever(LOG_TAG);
1354
1355 auto expectedPresentTime = presentFence1->getSignalTime() + vsyncPeriod;
1356 if (framesDelay.has_value()) {
1357 expectedPresentTime += *framesDelay * vsyncPeriod;
1358 }
1359
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001360 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer2->handle,
1361 /*acquireFence*/ -1);
Ady Abraham72c5b502021-12-10 17:23:39 -08001362 const auto setExpectedPresentTime = [&]() -> std::optional<ClockMonotonicTimestamp> {
1363 if (!framesDelay.has_value()) {
1364 return ComposerClientWriter::kNoTimestamp;
1365 } else if (*framesDelay == 0) {
1366 return ClockMonotonicTimestamp{0};
1367 }
1368 return ClockMonotonicTimestamp{expectedPresentTime};
1369 }();
1370
1371 const sp<::android::Fence> presentFence2 = presentAndGetFence(setExpectedPresentTime);
1372 presentFence2->waitForever(LOG_TAG);
1373
1374 const auto actualPresentTime = presentFence2->getSignalTime();
Ady Abrahamdf084f32022-01-10 14:10:23 -08001375 EXPECT_GE(actualPresentTime, expectedPresentTime - vsyncPeriod / 2);
Ady Abraham72c5b502021-12-10 17:23:39 -08001376
ramindani431aad42022-02-01 21:44:29 +00001377 ASSERT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001378 }
1379
ramindani431aad42022-02-01 21:44:29 +00001380 void configureLayer(const VtsDisplay& display, int64_t layer, Composition composition,
1381 const Rect& displayFrame, const FRect& cropRect) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001382 auto& writer = getWriter(display.getDisplayId());
1383 writer.setLayerCompositionType(display.getDisplayId(), layer, composition);
1384 writer.setLayerDisplayFrame(display.getDisplayId(), layer, displayFrame);
1385 writer.setLayerPlaneAlpha(display.getDisplayId(), layer, /*alpha*/ 1);
1386 writer.setLayerSourceCrop(display.getDisplayId(), layer, cropRect);
1387 writer.setLayerTransform(display.getDisplayId(), layer, static_cast<Transform>(0));
1388 writer.setLayerVisibleRegion(display.getDisplayId(), layer,
1389 std::vector<Rect>(1, displayFrame));
1390 writer.setLayerZOrder(display.getDisplayId(), layer, /*z*/ 10);
1391 writer.setLayerBlendMode(display.getDisplayId(), layer, BlendMode::NONE);
1392 writer.setLayerSurfaceDamage(display.getDisplayId(), layer,
1393 std::vector<Rect>(1, displayFrame));
ramindani431aad42022-02-01 21:44:29 +00001394 }
ramindanidcfe3a82021-11-29 17:00:31 +00001395 // clang-format off
1396 const std::array<float, 16> kIdentity = {{
1397 1.0f, 0.0f, 0.0f, 0.0f,
1398 0.0f, 1.0f, 0.0f, 0.0f,
1399 0.0f, 0.0f, 1.0f, 0.0f,
1400 0.0f, 0.0f, 0.0f, 1.0f,
1401 }};
1402 // clang-format on
1403
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001404 ComposerClientWriter& getWriter(int64_t display) {
1405 auto [it, _] = mWriters.try_emplace(display, display);
1406 return it->second;
1407 }
1408
Ady Abraham91c9d1a2021-12-15 18:14:45 -08001409 ComposerClientReader mReader;
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001410
1411 private:
1412 std::unordered_map<int64_t, ComposerClientWriter> mWriters;
ramindanidcfe3a82021-11-29 17:00:31 +00001413};
1414
ramindani431aad42022-02-01 21:44:29 +00001415TEST_P(GraphicsComposerAidlCommandTest, SetColorTransform) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001416 auto& writer = getWriter(getPrimaryDisplayId());
1417 writer.setColorTransform(getPrimaryDisplayId(), kIdentity.data());
ramindanidcfe3a82021-11-29 17:00:31 +00001418 execute();
1419}
1420
1421TEST_P(GraphicsComposerAidlCommandTest, SetLayerColorTransform) {
ramindani431aad42022-02-01 21:44:29 +00001422 const auto& [status, layer] =
1423 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1424 EXPECT_TRUE(status.isOk());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001425 auto& writer = getWriter(getPrimaryDisplayId());
1426 writer.setLayerColorTransform(getPrimaryDisplayId(), layer, kIdentity.data());
ramindanidcfe3a82021-11-29 17:00:31 +00001427 execute();
1428
Ady Abraham3192f3d2021-12-03 16:08:56 -08001429 const auto errors = mReader.takeErrors();
Jason Macnak062bc9a2022-01-20 15:00:09 -08001430 if (errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_UNSUPPORTED) {
ramindanidcfe3a82021-11-29 17:00:31 +00001431 GTEST_SUCCEED() << "setLayerColorTransform is not supported";
1432 return;
1433 }
1434}
1435
Alec Mouri60564e12021-12-09 18:48:20 -08001436TEST_P(GraphicsComposerAidlCommandTest, SetDisplayBrightness) {
ramindani431aad42022-02-01 21:44:29 +00001437 const auto& [status, capabilities] =
1438 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
1439 ASSERT_TRUE(status.isOk());
Alec Mouri60564e12021-12-09 18:48:20 -08001440 bool brightnessSupport = std::find(capabilities.begin(), capabilities.end(),
1441 DisplayCapability::BRIGHTNESS) != capabilities.end();
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001442 auto& writer = getWriter(getPrimaryDisplayId());
Alec Mouri60564e12021-12-09 18:48:20 -08001443 if (!brightnessSupport) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001444 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.5f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001445 execute();
1446 const auto errors = mReader.takeErrors();
1447 EXPECT_EQ(1, errors.size());
Jason Macnak062bc9a2022-01-20 15:00:09 -08001448 EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, errors[0].errorCode);
Alec Mouri60564e12021-12-09 18:48:20 -08001449 GTEST_SUCCEED() << "SetDisplayBrightness is not supported";
1450 return;
1451 }
1452
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001453 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001454 execute();
1455 EXPECT_TRUE(mReader.takeErrors().empty());
1456
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001457 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.5f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001458 execute();
1459 EXPECT_TRUE(mReader.takeErrors().empty());
1460
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001461 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 1.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001462 execute();
1463 EXPECT_TRUE(mReader.takeErrors().empty());
1464
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001465 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ -1.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001466 execute();
1467 EXPECT_TRUE(mReader.takeErrors().empty());
1468
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001469 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 2.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001470 execute();
1471 {
1472 const auto errors = mReader.takeErrors();
ramindanib3bdf052022-01-12 18:27:05 +00001473 ASSERT_EQ(1, errors.size());
Alec Mouri60564e12021-12-09 18:48:20 -08001474 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
1475 }
1476
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001477 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ -2.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001478 execute();
1479 {
1480 const auto errors = mReader.takeErrors();
ramindanib3bdf052022-01-12 18:27:05 +00001481 ASSERT_EQ(1, errors.size());
Alec Mouri60564e12021-12-09 18:48:20 -08001482 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
1483 }
1484}
1485
ramindani431aad42022-02-01 21:44:29 +00001486TEST_P(GraphicsComposerAidlCommandTest, SetClientTarget) {
1487 EXPECT_TRUE(mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kBufferSlotCount)
1488 .isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001489
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001490 auto& writer = getWriter(getPrimaryDisplayId());
1491 writer.setClientTarget(getPrimaryDisplayId(), /*slot*/ 0, nullptr, /*acquireFence*/ -1,
1492 Dataspace::UNKNOWN, std::vector<Rect>());
ramindanidcfe3a82021-11-29 17:00:31 +00001493
1494 execute();
1495}
1496
ramindani431aad42022-02-01 21:44:29 +00001497TEST_P(GraphicsComposerAidlCommandTest, SetOutputBuffer) {
1498 const auto& [status, virtualDisplayCount] = mComposerClient->getMaxVirtualDisplayCount();
1499 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001500 if (virtualDisplayCount == 0) {
1501 GTEST_SUCCEED() << "no virtual display support";
1502 return;
1503 }
1504
ramindani431aad42022-02-01 21:44:29 +00001505 const auto& [displayStatus, display] = mComposerClient->createVirtualDisplay(
1506 /*width*/ 64, /*height*/ 64, common::PixelFormat::IMPLEMENTATION_DEFINED,
1507 kBufferSlotCount);
1508 EXPECT_TRUE(displayStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001509
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001510 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001511 const auto handle = buffer->handle;
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001512 auto& writer = getWriter(display.display);
1513 writer.setOutputBuffer(display.display, /*slot*/ 0, handle, /*releaseFence*/ -1);
ramindanidcfe3a82021-11-29 17:00:31 +00001514 execute();
1515}
1516
ramindani431aad42022-02-01 21:44:29 +00001517TEST_P(GraphicsComposerAidlCommandTest, ValidDisplay) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001518 auto& writer = getWriter(getPrimaryDisplayId());
1519 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
ramindanidcfe3a82021-11-29 17:00:31 +00001520 execute();
1521}
1522
ramindani431aad42022-02-01 21:44:29 +00001523TEST_P(GraphicsComposerAidlCommandTest, AcceptDisplayChanges) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001524 auto& writer = getWriter(getPrimaryDisplayId());
1525 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
1526 writer.acceptDisplayChanges(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001527 execute();
1528}
1529
ramindani431aad42022-02-01 21:44:29 +00001530TEST_P(GraphicsComposerAidlCommandTest, PresentDisplay) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001531 auto& writer = getWriter(getPrimaryDisplayId());
1532 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
1533 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001534 execute();
1535}
1536
1537/**
1538 * Test IComposerClient::Command::PRESENT_DISPLAY
1539 *
1540 * Test that IComposerClient::Command::PRESENT_DISPLAY works without
1541 * additional call to validateDisplay when only the layer buffer handle and
1542 * surface damage have been set
1543 */
ramindani431aad42022-02-01 21:44:29 +00001544TEST_P(GraphicsComposerAidlCommandTest, PresentDisplayNoLayerStateChanges) {
Jason Macnak325e8232022-01-24 14:48:55 -08001545 if (!hasCapability(Capability::SKIP_VALIDATE)) {
ramindanidcfe3a82021-11-29 17:00:31 +00001546 GTEST_SUCCEED() << "Device does not have skip validate capability, skipping";
1547 return;
1548 }
ramindani431aad42022-02-01 21:44:29 +00001549 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001550
ramindani431aad42022-02-01 21:44:29 +00001551 const auto& [renderIntentsStatus, renderIntents] =
1552 mComposerClient->getRenderIntents(getPrimaryDisplayId(), ColorMode::NATIVE);
1553 EXPECT_TRUE(renderIntentsStatus.isOk());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001554 auto& writer = getWriter(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001555 for (auto intent : renderIntents) {
ramindani431aad42022-02-01 21:44:29 +00001556 EXPECT_TRUE(mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE, intent)
1557 .isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001558
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001559 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001560 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001561 ASSERT_NE(nullptr, handle);
1562
ramindani431aad42022-02-01 21:44:29 +00001563 const auto& [layerStatus, layer] =
1564 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1565 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001566
ramindani431aad42022-02-01 21:44:29 +00001567 Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
1568 getPrimaryDisplay().getDisplayHeight()};
1569 FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
1570 (float)getPrimaryDisplay().getDisplayHeight()};
1571 configureLayer(getPrimaryDisplay(), layer, Composition::CURSOR, displayFrame, cropRect);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001572 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle,
1573 /*acquireFence*/ -1);
1574 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
1575 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
ramindanidcfe3a82021-11-29 17:00:31 +00001576 execute();
ramindani431aad42022-02-01 21:44:29 +00001577 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
ramindanidcfe3a82021-11-29 17:00:31 +00001578 GTEST_SUCCEED() << "Composition change requested, skipping test";
1579 return;
1580 }
1581
Ady Abraham3192f3d2021-12-03 16:08:56 -08001582 ASSERT_TRUE(mReader.takeErrors().empty());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001583 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001584 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001585 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001586
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001587 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001588 const auto handle2 = buffer2->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001589 ASSERT_NE(nullptr, handle2);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001590 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle2,
1591 /*acquireFence*/ -1);
1592 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer,
1593 std::vector<Rect>(1, {0, 0, 10, 10}));
1594 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001595 execute();
1596 }
1597}
1598
ramindani431aad42022-02-01 21:44:29 +00001599TEST_P(GraphicsComposerAidlCommandTest, SetLayerCursorPosition) {
1600 const auto& [layerStatus, layer] =
1601 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1602 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001603
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001604 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001605 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001606 ASSERT_NE(nullptr, handle);
ramindanidcfe3a82021-11-29 17:00:31 +00001607
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001608 auto& writer = getWriter(getPrimaryDisplayId());
1609 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle, /*acquireFence*/ -1);
ramindani431aad42022-02-01 21:44:29 +00001610
1611 Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
1612 getPrimaryDisplay().getDisplayHeight()};
1613 FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
1614 (float)getPrimaryDisplay().getDisplayHeight()};
1615 configureLayer(getPrimaryDisplay(), layer, Composition::CURSOR, displayFrame, cropRect);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001616 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
1617 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
ramindanidcfe3a82021-11-29 17:00:31 +00001618
1619 execute();
Ady Abraham46219f52021-12-20 09:44:31 -08001620
ramindani431aad42022-02-01 21:44:29 +00001621 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
ramindanidcfe3a82021-11-29 17:00:31 +00001622 GTEST_SUCCEED() << "Composition change requested, skipping test";
1623 return;
1624 }
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001625 writer.presentDisplay(getPrimaryDisplayId());
Ady Abraham3192f3d2021-12-03 16:08:56 -08001626 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001627
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001628 writer.setLayerCursorPosition(getPrimaryDisplayId(), layer, /*x*/ 1, /*y*/ 1);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001629 execute();
1630
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001631 writer.setLayerCursorPosition(getPrimaryDisplayId(), layer, /*x*/ 0, /*y*/ 0);
1632 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
1633 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001634 execute();
1635}
1636
ramindani431aad42022-02-01 21:44:29 +00001637TEST_P(GraphicsComposerAidlCommandTest, SetLayerBuffer) {
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001638 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001639 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001640 ASSERT_NE(nullptr, handle);
1641
ramindani431aad42022-02-01 21:44:29 +00001642 const auto& [layerStatus, layer] =
1643 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1644 EXPECT_TRUE(layerStatus.isOk());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001645 auto& writer = getWriter(getPrimaryDisplayId());
1646 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle, /*acquireFence*/ -1);
ramindanidcfe3a82021-11-29 17:00:31 +00001647 execute();
1648}
1649
Brian Lindahlca3eef22022-12-09 00:32:11 -07001650TEST_P(GraphicsComposerAidlCommandTest, SetLayerBufferWithSlotsToClear) {
1651 auto clearSlotBuffer = allocate(1u, 1u, ::android::PIXEL_FORMAT_RGB_888);
1652 ASSERT_NE(nullptr, clearSlotBuffer);
1653 auto clearSlotBufferHandle = clearSlotBuffer->handle;
1654
1655 const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1656 ASSERT_NE(nullptr, buffer1);
1657 const auto handle1 = buffer1->handle;
1658 const auto& [layerStatus, layer] =
1659 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1660 EXPECT_TRUE(layerStatus.isOk());
1661 auto& writer = getWriter(getPrimaryDisplayId());
1662 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle1, /*acquireFence*/ -1);
1663 execute();
1664 ASSERT_TRUE(mReader.takeErrors().empty());
1665
1666 // Ensure we can clear a buffer slot and then set that same slot with a new buffer
1667 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1668 ASSERT_NE(nullptr, buffer2);
1669 const auto handle2 = buffer2->handle;
1670 writer.setLayerBufferWithNewCommand(getPrimaryDisplayId(), layer, /* slot */ 0,
1671 clearSlotBufferHandle, /*acquireFence*/ -1);
1672 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle2, /*acquireFence*/ -1);
1673 execute();
1674 ASSERT_TRUE(mReader.takeErrors().empty());
1675}
1676
ramindani431aad42022-02-01 21:44:29 +00001677TEST_P(GraphicsComposerAidlCommandTest, SetLayerSurfaceDamage) {
1678 const auto& [layerStatus, layer] =
1679 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1680 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001681
1682 Rect empty{0, 0, 0, 0};
1683 Rect unit{0, 0, 1, 1};
1684
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001685 auto& writer = getWriter(getPrimaryDisplayId());
1686 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
ramindanidcfe3a82021-11-29 17:00:31 +00001687 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001688 ASSERT_TRUE(mReader.takeErrors().empty());
1689
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001690 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
Ady Abraham3192f3d2021-12-03 16:08:56 -08001691 execute();
1692 ASSERT_TRUE(mReader.takeErrors().empty());
1693
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001694 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>());
Ady Abraham3192f3d2021-12-03 16:08:56 -08001695 execute();
1696 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001697}
1698
ramindani431aad42022-02-01 21:44:29 +00001699TEST_P(GraphicsComposerAidlCommandTest, SetLayerBlockingRegion) {
1700 const auto& [layerStatus, layer] =
1701 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1702 EXPECT_TRUE(layerStatus.isOk());
Leon Scroggins III03318152022-01-13 12:24:19 -05001703
1704 Rect empty{0, 0, 0, 0};
1705 Rect unit{0, 0, 1, 1};
1706
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001707 auto& writer = getWriter(getPrimaryDisplayId());
1708 writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
Leon Scroggins III03318152022-01-13 12:24:19 -05001709 execute();
1710 ASSERT_TRUE(mReader.takeErrors().empty());
1711
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001712 writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
Leon Scroggins III03318152022-01-13 12:24:19 -05001713 execute();
1714 ASSERT_TRUE(mReader.takeErrors().empty());
1715
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001716 writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>());
Leon Scroggins III03318152022-01-13 12:24:19 -05001717 execute();
1718 ASSERT_TRUE(mReader.takeErrors().empty());
1719}
1720
ramindani431aad42022-02-01 21:44:29 +00001721TEST_P(GraphicsComposerAidlCommandTest, SetLayerBlendMode) {
1722 const auto& [layerStatus, layer] =
1723 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1724 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001725
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001726 auto& writer = getWriter(getPrimaryDisplayId());
1727 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::NONE);
ramindanidcfe3a82021-11-29 17:00:31 +00001728 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001729 ASSERT_TRUE(mReader.takeErrors().empty());
1730
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001731 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::PREMULTIPLIED);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001732 execute();
1733 ASSERT_TRUE(mReader.takeErrors().empty());
1734
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001735 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::COVERAGE);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001736 execute();
1737 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001738}
1739
ramindani431aad42022-02-01 21:44:29 +00001740TEST_P(GraphicsComposerAidlCommandTest, SetLayerColor) {
1741 const auto& [layerStatus, layer] =
1742 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1743 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001744
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001745 auto& writer = getWriter(getPrimaryDisplayId());
1746 writer.setLayerColor(getPrimaryDisplayId(), layer, Color{1.0f, 1.0f, 1.0f, 1.0f});
ramindanidcfe3a82021-11-29 17:00:31 +00001747 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001748 ASSERT_TRUE(mReader.takeErrors().empty());
1749
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001750 writer.setLayerColor(getPrimaryDisplayId(), layer, Color{0.0f, 0.0f, 0.0f, 0.0f});
Ady Abraham3192f3d2021-12-03 16:08:56 -08001751 execute();
1752 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001753}
1754
ramindani431aad42022-02-01 21:44:29 +00001755TEST_P(GraphicsComposerAidlCommandTest, SetLayerCompositionType) {
1756 const auto& [layerStatus, layer] =
1757 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1758 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001759
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001760 auto& writer = getWriter(getPrimaryDisplayId());
1761 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::CLIENT);
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.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::DEVICE);
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.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::SOLID_COLOR);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001770 execute();
1771 ASSERT_TRUE(mReader.takeErrors().empty());
1772
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001773 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::CURSOR);
ramindani431aad42022-02-01 21:44:29 +00001774 execute();
1775}
1776
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001777TEST_P(GraphicsComposerAidlCommandTest, DisplayDecoration) {
1778 for (VtsDisplay& display : mDisplays) {
1779 const auto [layerStatus, layer] =
1780 mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount);
1781 EXPECT_TRUE(layerStatus.isOk());
1782
1783 const auto [error, support] =
1784 mComposerClient->getDisplayDecorationSupport(display.getDisplayId());
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001785
Leon Scroggins III91590872022-02-23 09:51:21 -05001786 const auto format = (error.isOk() && support) ? support->format
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001787 : aidl::android::hardware::graphics::common::PixelFormat::RGBA_8888;
1788 const auto decorBuffer = allocate(static_cast<::android::PixelFormat>(format));
1789 ASSERT_NE(nullptr, decorBuffer);
1790 if (::android::OK != decorBuffer->initCheck()) {
1791 if (support) {
1792 FAIL() << "Device advertised display decoration support with format "
1793 << aidl::android::hardware::graphics::common::toString(format)
1794 << " but failed to allocate it!";
1795 } else {
1796 FAIL() << "Device advertised NO display decoration support, but it should "
1797 << "still be able to allocate "
1798 << aidl::android::hardware::graphics::common::toString(format);
1799 }
1800 }
1801
Midas Chien7d55d422022-06-07 02:32:28 +08001802 configureLayer(display, layer, Composition::DISPLAY_DECORATION, display.getFrameRect(),
1803 display.getCrop());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001804 auto& writer = getWriter(display.getDisplayId());
1805 writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, decorBuffer->handle,
1806 /*acquireFence*/ -1);
1807 writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp);
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001808 execute();
1809 if (support) {
1810 ASSERT_TRUE(mReader.takeErrors().empty());
1811 } else {
1812 const auto errors = mReader.takeErrors();
1813 ASSERT_EQ(1, errors.size());
Leon Scroggins III6455e792022-02-24 12:18:58 -05001814 EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, errors[0].errorCode);
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001815 }
1816 }
1817}
1818
ramindani431aad42022-02-01 21:44:29 +00001819TEST_P(GraphicsComposerAidlCommandTest, SetLayerDataspace) {
1820 const auto& [layerStatus, layer] =
1821 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1822 EXPECT_TRUE(layerStatus.isOk());
1823
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001824 auto& writer = getWriter(getPrimaryDisplayId());
1825 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
ramindani431aad42022-02-01 21:44:29 +00001826 execute();
1827}
1828
1829TEST_P(GraphicsComposerAidlCommandTest, SetLayerDisplayFrame) {
1830 const auto& [layerStatus, layer] =
1831 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1832 EXPECT_TRUE(layerStatus.isOk());
1833
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001834 auto& writer = getWriter(getPrimaryDisplayId());
1835 writer.setLayerDisplayFrame(getPrimaryDisplayId(), layer, Rect{0, 0, 1, 1});
ramindani431aad42022-02-01 21:44:29 +00001836 execute();
1837}
1838
1839TEST_P(GraphicsComposerAidlCommandTest, SetLayerPlaneAlpha) {
1840 const auto& [layerStatus, layer] =
1841 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1842 EXPECT_TRUE(layerStatus.isOk());
1843
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001844 auto& writer = getWriter(getPrimaryDisplayId());
1845 writer.setLayerPlaneAlpha(getPrimaryDisplayId(), layer, /*alpha*/ 0.0f);
ramindani431aad42022-02-01 21:44:29 +00001846 execute();
1847 ASSERT_TRUE(mReader.takeErrors().empty());
1848
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001849 writer.setLayerPlaneAlpha(getPrimaryDisplayId(), layer, /*alpha*/ 1.0f);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001850 execute();
1851 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001852}
1853
ramindani431aad42022-02-01 21:44:29 +00001854TEST_P(GraphicsComposerAidlCommandTest, SetLayerSidebandStream) {
Jason Macnak325e8232022-01-24 14:48:55 -08001855 if (!hasCapability(Capability::SIDEBAND_STREAM)) {
ramindanidcfe3a82021-11-29 17:00:31 +00001856 GTEST_SUCCEED() << "no sideband stream support";
1857 return;
1858 }
1859
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001860 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001861 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001862 ASSERT_NE(nullptr, handle);
1863
ramindani431aad42022-02-01 21:44:29 +00001864 const auto& [layerStatus, layer] =
1865 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1866 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001867
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001868 auto& writer = getWriter(getPrimaryDisplayId());
1869 writer.setLayerSidebandStream(getPrimaryDisplayId(), layer, handle);
ramindanidcfe3a82021-11-29 17:00:31 +00001870 execute();
1871}
1872
ramindani431aad42022-02-01 21:44:29 +00001873TEST_P(GraphicsComposerAidlCommandTest, SetLayerSourceCrop) {
1874 const auto& [layerStatus, layer] =
1875 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1876 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001877
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001878 auto& writer = getWriter(getPrimaryDisplayId());
1879 writer.setLayerSourceCrop(getPrimaryDisplayId(), layer, FRect{0.0f, 0.0f, 1.0f, 1.0f});
ramindanidcfe3a82021-11-29 17:00:31 +00001880 execute();
1881}
1882
ramindani431aad42022-02-01 21:44:29 +00001883TEST_P(GraphicsComposerAidlCommandTest, SetLayerTransform) {
1884 const auto& [layerStatus, layer] =
1885 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1886 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001887
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001888 auto& writer = getWriter(getPrimaryDisplayId());
1889 writer.setLayerTransform(getPrimaryDisplayId(), layer, static_cast<Transform>(0));
ramindanidcfe3a82021-11-29 17:00:31 +00001890 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001891 ASSERT_TRUE(mReader.takeErrors().empty());
1892
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001893 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::FLIP_H);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001894 execute();
1895 ASSERT_TRUE(mReader.takeErrors().empty());
1896
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001897 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::FLIP_V);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001898 execute();
1899 ASSERT_TRUE(mReader.takeErrors().empty());
1900
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001901 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_90);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001902 execute();
1903 ASSERT_TRUE(mReader.takeErrors().empty());
1904
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001905 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_180);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001906 execute();
1907 ASSERT_TRUE(mReader.takeErrors().empty());
1908
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001909 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_270);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001910 execute();
1911 ASSERT_TRUE(mReader.takeErrors().empty());
1912
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001913 writer.setLayerTransform(getPrimaryDisplayId(), layer,
1914 static_cast<Transform>(static_cast<int>(Transform::FLIP_H) |
1915 static_cast<int>(Transform::ROT_90)));
Ady Abraham3192f3d2021-12-03 16:08:56 -08001916 execute();
1917 ASSERT_TRUE(mReader.takeErrors().empty());
1918
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001919 writer.setLayerTransform(getPrimaryDisplayId(), layer,
1920 static_cast<Transform>(static_cast<int>(Transform::FLIP_V) |
1921 static_cast<int>(Transform::ROT_90)));
Ady Abraham3192f3d2021-12-03 16:08:56 -08001922 execute();
1923 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001924}
1925
ramindani431aad42022-02-01 21:44:29 +00001926TEST_P(GraphicsComposerAidlCommandTest, SetLayerVisibleRegion) {
1927 const auto& [layerStatus, layer] =
1928 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1929 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001930
1931 Rect empty{0, 0, 0, 0};
1932 Rect unit{0, 0, 1, 1};
1933
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001934 auto& writer = getWriter(getPrimaryDisplayId());
1935 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
ramindanidcfe3a82021-11-29 17:00:31 +00001936 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001937 ASSERT_TRUE(mReader.takeErrors().empty());
1938
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001939 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
Ady Abraham3192f3d2021-12-03 16:08:56 -08001940 execute();
1941 ASSERT_TRUE(mReader.takeErrors().empty());
1942
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001943 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>());
Ady Abraham3192f3d2021-12-03 16:08:56 -08001944 execute();
1945 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001946}
1947
ramindani431aad42022-02-01 21:44:29 +00001948TEST_P(GraphicsComposerAidlCommandTest, SetLayerZOrder) {
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.setLayerZOrder(getPrimaryDisplayId(), layer, /*z*/ 10);
ramindanidcfe3a82021-11-29 17:00:31 +00001955 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001956 ASSERT_TRUE(mReader.takeErrors().empty());
1957
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001958 writer.setLayerZOrder(getPrimaryDisplayId(), layer, /*z*/ 0);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001959 execute();
1960 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001961}
1962
ramindani431aad42022-02-01 21:44:29 +00001963TEST_P(GraphicsComposerAidlCommandTest, SetLayerPerFrameMetadata) {
1964 const auto& [layerStatus, layer] =
1965 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1966 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001967
ramindanidcfe3a82021-11-29 17:00:31 +00001968 /**
1969 * DISPLAY_P3 is a color space that uses the DCI_P3 primaries,
1970 * the D65 white point and the SRGB transfer functions.
1971 * Rendering Intent: Colorimetric
1972 * Primaries:
1973 * x y
1974 * green 0.265 0.690
1975 * blue 0.150 0.060
1976 * red 0.680 0.320
1977 * white (D65) 0.3127 0.3290
1978 */
1979
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001980 auto& writer = getWriter(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001981 std::vector<PerFrameMetadata> aidlMetadata;
1982 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X, 0.680f});
1983 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y, 0.320f});
1984 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X, 0.265f});
1985 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y, 0.690f});
1986 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X, 0.150f});
1987 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y, 0.060f});
1988 aidlMetadata.push_back({PerFrameMetadataKey::WHITE_POINT_X, 0.3127f});
1989 aidlMetadata.push_back({PerFrameMetadataKey::WHITE_POINT_Y, 0.3290f});
1990 aidlMetadata.push_back({PerFrameMetadataKey::MAX_LUMINANCE, 100.0f});
1991 aidlMetadata.push_back({PerFrameMetadataKey::MIN_LUMINANCE, 0.1f});
1992 aidlMetadata.push_back({PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL, 78.0});
1993 aidlMetadata.push_back({PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL, 62.0});
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001994 writer.setLayerPerFrameMetadata(getPrimaryDisplayId(), layer, aidlMetadata);
ramindanidcfe3a82021-11-29 17:00:31 +00001995 execute();
1996
Ady Abraham3192f3d2021-12-03 16:08:56 -08001997 const auto errors = mReader.takeErrors();
1998 if (errors.size() == 1 && errors[0].errorCode == EX_UNSUPPORTED_OPERATION) {
ramindanidcfe3a82021-11-29 17:00:31 +00001999 GTEST_SUCCEED() << "SetLayerPerFrameMetadata is not supported";
ramindani431aad42022-02-01 21:44:29 +00002000 EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002001 return;
2002 }
2003
ramindani431aad42022-02-01 21:44:29 +00002004 EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002005}
2006
Alec Mourib1f16722022-02-07 13:03:44 -08002007TEST_P(GraphicsComposerAidlCommandTest, setLayerBrightness) {
ramindani431aad42022-02-01 21:44:29 +00002008 const auto& [layerStatus, layer] =
2009 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
Alec Mouri95e490b2022-01-06 13:46:58 -08002010
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002011 auto& writer = getWriter(getPrimaryDisplayId());
2012 writer.setLayerBrightness(getPrimaryDisplayId(), layer, 0.2f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002013 execute();
2014 ASSERT_TRUE(mReader.takeErrors().empty());
2015
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002016 writer.setLayerBrightness(getPrimaryDisplayId(), layer, 1.f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002017 execute();
2018 ASSERT_TRUE(mReader.takeErrors().empty());
2019
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002020 writer.setLayerBrightness(getPrimaryDisplayId(), layer, 0.f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002021 execute();
2022 ASSERT_TRUE(mReader.takeErrors().empty());
2023
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002024 writer.setLayerBrightness(getPrimaryDisplayId(), layer, -1.f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002025 execute();
Alec Mourib1f16722022-02-07 13:03:44 -08002026 {
2027 const auto errors = mReader.takeErrors();
2028 ASSERT_EQ(1, errors.size());
2029 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
2030 }
2031
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002032 writer.setLayerBrightness(getPrimaryDisplayId(), layer, std::nanf(""));
Alec Mourib1f16722022-02-07 13:03:44 -08002033 execute();
2034 {
2035 const auto errors = mReader.takeErrors();
2036 ASSERT_EQ(1, errors.size());
2037 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
2038 }
Alec Mouri95e490b2022-01-06 13:46:58 -08002039}
2040
ramindani431aad42022-02-01 21:44:29 +00002041TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints) {
ramindanidcfe3a82021-11-29 17:00:31 +00002042 Test_setActiveConfigWithConstraints({.delayForChange = 0, .refreshMiss = false});
2043}
2044
ramindani431aad42022-02-01 21:44:29 +00002045TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_Delayed) {
ramindanidcfe3a82021-11-29 17:00:31 +00002046 Test_setActiveConfigWithConstraints({.delayForChange = 300'000'000, // 300ms
2047 .refreshMiss = false});
2048}
2049
ramindani431aad42022-02-01 21:44:29 +00002050TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_MissRefresh) {
ramindanidcfe3a82021-11-29 17:00:31 +00002051 Test_setActiveConfigWithConstraints({.delayForChange = 0, .refreshMiss = true});
2052}
2053
ramindani431aad42022-02-01 21:44:29 +00002054TEST_P(GraphicsComposerAidlCommandTest, GetDisplayVsyncPeriod) {
ramindanidcfe3a82021-11-29 17:00:31 +00002055 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +00002056 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
2057 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002058
ramindani431aad42022-02-01 21:44:29 +00002059 for (int32_t config : configs) {
2060 int32_t expectedVsyncPeriodNanos = display.getDisplayConfig(config).vsyncPeriod;
2061
ramindanidcfe3a82021-11-29 17:00:31 +00002062 VsyncPeriodChangeConstraints constraints;
2063
2064 constraints.desiredTimeNanos = systemTime();
2065 constraints.seamlessRequired = false;
ramindani431aad42022-02-01 21:44:29 +00002066
2067 const auto& [timelineStatus, timeline] =
2068 mComposerClient->setActiveConfigWithConstraints(&display, config, constraints);
2069 EXPECT_TRUE(timelineStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002070
2071 if (timeline.refreshRequired) {
2072 sendRefreshFrame(display, &timeline);
2073 }
ramindani431aad42022-02-01 21:44:29 +00002074 waitForVsyncPeriodChange(display.getDisplayId(), timeline, constraints.desiredTimeNanos,
2075 /*odPeriodNanos*/ 0, expectedVsyncPeriodNanos);
ramindanidcfe3a82021-11-29 17:00:31 +00002076
2077 int32_t vsyncPeriodNanos;
2078 int retryCount = 100;
2079 do {
2080 std::this_thread::sleep_for(10ms);
ramindani431aad42022-02-01 21:44:29 +00002081 const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanosValue] =
2082 mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
2083
2084 EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
2085 vsyncPeriodNanos = vsyncPeriodNanosValue;
ramindanidcfe3a82021-11-29 17:00:31 +00002086 --retryCount;
2087 } while (vsyncPeriodNanos != expectedVsyncPeriodNanos && retryCount > 0);
2088
2089 EXPECT_EQ(vsyncPeriodNanos, expectedVsyncPeriodNanos);
2090
2091 // Make sure that the vsync period stays the same if the active config is not
2092 // changed.
2093 auto timeout = 1ms;
2094 for (int i = 0; i < 10; i++) {
2095 std::this_thread::sleep_for(timeout);
2096 timeout *= 2;
2097 vsyncPeriodNanos = 0;
ramindani431aad42022-02-01 21:44:29 +00002098 const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanosValue] =
2099 mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
2100
2101 EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
2102 vsyncPeriodNanos = vsyncPeriodNanosValue;
ramindanidcfe3a82021-11-29 17:00:31 +00002103 EXPECT_EQ(vsyncPeriodNanos, expectedVsyncPeriodNanos);
2104 }
2105 }
2106 }
2107}
2108
ramindani431aad42022-02-01 21:44:29 +00002109TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_SeamlessNotAllowed) {
ramindanidcfe3a82021-11-29 17:00:31 +00002110 VsyncPeriodChangeConstraints constraints;
ramindanidcfe3a82021-11-29 17:00:31 +00002111 constraints.seamlessRequired = true;
2112 constraints.desiredTimeNanos = systemTime();
2113
2114 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +00002115 forEachTwoConfigs(display.getDisplayId(), [&](int32_t config1, int32_t config2) {
2116 int32_t configGroup1 = display.getDisplayConfig(config1).configGroup;
2117 int32_t configGroup2 = display.getDisplayConfig(config2).configGroup;
ramindanidcfe3a82021-11-29 17:00:31 +00002118 if (configGroup1 != configGroup2) {
ramindani431aad42022-02-01 21:44:29 +00002119 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002120 sendRefreshFrame(display, nullptr);
ramindani431aad42022-02-01 21:44:29 +00002121 const auto& [status, _] = mComposerClient->setActiveConfigWithConstraints(
2122 &display, config2, constraints);
2123 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00002124 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(
2125 status, IComposerClient::EX_SEAMLESS_NOT_ALLOWED));
ramindanidcfe3a82021-11-29 17:00:31 +00002126 }
2127 });
2128 }
2129}
2130
ramindani431aad42022-02-01 21:44:29 +00002131TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_NoTimestamp) {
2132 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ std::nullopt));
Ady Abraham72c5b502021-12-10 17:23:39 -08002133}
2134
ramindani431aad42022-02-01 21:44:29 +00002135TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_0) {
2136 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ 0));
Ady Abraham72c5b502021-12-10 17:23:39 -08002137}
2138
ramindani431aad42022-02-01 21:44:29 +00002139TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_5) {
2140 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ 5));
Ady Abraham72c5b502021-12-10 17:23:39 -08002141}
2142
ramindani431aad42022-02-01 21:44:29 +00002143TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Unsupported) {
2144 const bool hasDisplayIdleTimerSupport =
2145 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002146 if (!hasDisplayIdleTimerSupport) {
ramindani431aad42022-02-01 21:44:29 +00002147 const auto& status =
2148 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0);
2149 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00002150 EXPECT_NO_FATAL_FAILURE(
2151 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
Midas Chiena0b56bd2022-01-13 23:27:33 +08002152 }
2153}
2154
ramindani431aad42022-02-01 21:44:29 +00002155TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_BadParameter) {
2156 const bool hasDisplayIdleTimerSupport =
2157 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002158 if (!hasDisplayIdleTimerSupport) {
2159 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2160 return;
2161 }
2162
ramindani431aad42022-02-01 21:44:29 +00002163 const auto& status =
2164 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ -1);
2165 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00002166 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
Midas Chiena0b56bd2022-01-13 23:27:33 +08002167}
2168
ramindani431aad42022-02-01 21:44:29 +00002169TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Disable) {
2170 const bool hasDisplayIdleTimerSupport =
2171 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002172 if (!hasDisplayIdleTimerSupport) {
2173 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2174 return;
2175 }
2176
ramindani431aad42022-02-01 21:44:29 +00002177 EXPECT_TRUE(mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002178 std::this_thread::sleep_for(1s);
ramindani431aad42022-02-01 21:44:29 +00002179 EXPECT_EQ(0, mComposerClient->getVsyncIdleCount());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002180}
2181
ramindani431aad42022-02-01 21:44:29 +00002182TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Timeout_2) {
2183 const bool hasDisplayIdleTimerSupport =
2184 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002185 if (!hasDisplayIdleTimerSupport) {
2186 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2187 return;
2188 }
2189
ramindani431aad42022-02-01 21:44:29 +00002190 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
2191 EXPECT_TRUE(mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002192
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002193 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002194 ASSERT_NE(nullptr, buffer->handle);
2195
2196 const auto layer = createOnScreenLayer();
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002197 auto& writer = getWriter(getPrimaryDisplayId());
2198 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer->handle,
2199 /*acquireFence*/ -1);
ramindani431aad42022-02-01 21:44:29 +00002200 int32_t vsyncIdleCount = mComposerClient->getVsyncIdleCount();
Midas Chiena0b56bd2022-01-13 23:27:33 +08002201 auto earlyVsyncIdleTime = systemTime() + std::chrono::nanoseconds(2s).count();
ramindani431aad42022-02-01 21:44:29 +00002202 EXPECT_TRUE(
2203 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 2000).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002204
2205 const sp<::android::Fence> presentFence =
ramindani431aad42022-02-01 21:44:29 +00002206 presentAndGetFence(ComposerClientWriter::kNoTimestamp);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002207 presentFence->waitForever(LOG_TAG);
2208
2209 std::this_thread::sleep_for(3s);
ramindani431aad42022-02-01 21:44:29 +00002210 if (vsyncIdleCount < mComposerClient->getVsyncIdleCount()) {
2211 EXPECT_GE(mComposerClient->getVsyncIdleTime(), earlyVsyncIdleTime);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002212 }
2213
ramindani431aad42022-02-01 21:44:29 +00002214 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002215}
2216
Kriti Dang4efe8602022-05-03 16:55:59 +02002217/*
2218 * Test that no two display configs are exactly the same.
2219 */
2220TEST_P(GraphicsComposerAidlTest, GetDisplayConfigNoRepetitions) {
2221 for (const auto& display : mDisplays) {
2222 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
2223 for (std::vector<int>::size_type i = 0; i < configs.size(); i++) {
2224 for (std::vector<int>::size_type j = i + 1; j < configs.size(); j++) {
2225 const auto& [widthStatus1, width1] = mComposerClient->getDisplayAttribute(
2226 display.getDisplayId(), configs[i], DisplayAttribute::WIDTH);
2227 const auto& [heightStatus1, height1] = mComposerClient->getDisplayAttribute(
2228 display.getDisplayId(), configs[i], DisplayAttribute::HEIGHT);
2229 const auto& [vsyncPeriodStatus1, vsyncPeriod1] =
2230 mComposerClient->getDisplayAttribute(display.getDisplayId(), configs[i],
2231 DisplayAttribute::VSYNC_PERIOD);
2232 const auto& [groupStatus1, group1] = mComposerClient->getDisplayAttribute(
2233 display.getDisplayId(), configs[i], DisplayAttribute::CONFIG_GROUP);
2234
2235 const auto& [widthStatus2, width2] = mComposerClient->getDisplayAttribute(
2236 display.getDisplayId(), configs[j], DisplayAttribute::WIDTH);
2237 const auto& [heightStatus2, height2] = mComposerClient->getDisplayAttribute(
2238 display.getDisplayId(), configs[j], DisplayAttribute::HEIGHT);
2239 const auto& [vsyncPeriodStatus2, vsyncPeriod2] =
2240 mComposerClient->getDisplayAttribute(display.getDisplayId(), configs[j],
2241 DisplayAttribute::VSYNC_PERIOD);
2242 const auto& [groupStatus2, group2] = mComposerClient->getDisplayAttribute(
2243 display.getDisplayId(), configs[j], DisplayAttribute::CONFIG_GROUP);
2244
2245 ASSERT_FALSE(width1 == width2 && height1 == height2 &&
2246 vsyncPeriod1 == vsyncPeriod2 && group1 == group2);
2247 }
2248 }
2249 }
2250}
2251
Leon Scroggins IIIb3e336e2022-10-06 12:32:16 -04002252TEST_P(GraphicsComposerAidlCommandTest, MultiThreadedPresent) {
2253 std::vector<VtsDisplay*> displays;
2254 for (auto& display : mDisplays) {
2255 if (hasDisplayCapability(display.getDisplayId(),
2256 DisplayCapability::MULTI_THREADED_PRESENT)) {
2257 displays.push_back(&display);
2258 }
2259 }
2260 if (displays.size() <= 1u) {
2261 return;
2262 }
2263 // TODO(b/251842321): Try to present on multiple threads.
2264}
2265
ramindanidcfe3a82021-11-29 17:00:31 +00002266GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlCommandTest);
2267INSTANTIATE_TEST_SUITE_P(
2268 PerInstance, GraphicsComposerAidlCommandTest,
2269 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
2270 ::android::PrintInstanceNameToString);
2271
ramindanid32ae8e2021-10-01 18:48:39 +00002272GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlTest);
2273INSTANTIATE_TEST_SUITE_P(
2274 PerInstance, GraphicsComposerAidlTest,
2275 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
2276 ::android::PrintInstanceNameToString);
2277} // namespace
2278} // namespace aidl::android::hardware::graphics::composer3::vts
2279
2280int main(int argc, char** argv) {
2281 ::testing::InitGoogleTest(&argc, argv);
2282
2283 using namespace std::chrono_literals;
2284 if (!android::base::WaitForProperty("init.svc.surfaceflinger", "stopped", 10s)) {
2285 ALOGE("Failed to stop init.svc.surfaceflinger");
2286 return -1;
2287 }
ramindanibeea10e2021-12-07 21:02:49 +00002288
2289 android::ProcessState::self()->setThreadPoolMaxThreadCount(4);
2290
2291 // The binder threadpool we start will inherit sched policy and priority
2292 // of (this) creating thread. We want the binder thread pool to have
2293 // SCHED_FIFO policy and priority 1 (lowest RT priority)
2294 // Once the pool is created we reset this thread's priority back to
2295 // original.
2296 // This thread policy is based on what we do in the SurfaceFlinger while starting
2297 // the thread pool and we need to replicate that for the VTS tests.
2298 int newPriority = 0;
2299 int origPolicy = sched_getscheduler(0);
2300 struct sched_param origSchedParam;
2301
2302 int errorInPriorityModification = sched_getparam(0, &origSchedParam);
2303 if (errorInPriorityModification == 0) {
2304 int policy = SCHED_FIFO;
2305 newPriority = sched_get_priority_min(policy);
2306
2307 struct sched_param param;
2308 param.sched_priority = newPriority;
2309
2310 errorInPriorityModification = sched_setscheduler(0, policy, &param);
2311 }
2312
2313 // start the thread pool
2314 android::ProcessState::self()->startThreadPool();
2315
2316 // Reset current thread's policy and priority
2317 if (errorInPriorityModification == 0) {
2318 errorInPriorityModification = sched_setscheduler(0, origPolicy, &origSchedParam);
2319 } else {
2320 ALOGE("Failed to set VtsHalGraphicsComposer3_TargetTest binder threadpool priority to "
2321 "SCHED_FIFO");
2322 }
2323
ramindanid32ae8e2021-10-01 18:48:39 +00002324 return RUN_ALL_TESTS();
ramindania9780262021-10-01 18:48:39 +00002325}