blob: 800652357c59180abecc9179335cb44f230d8004 [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>
Sally Qi2d94f522024-10-15 12:53:51 -070031#include <cutils/ashmem.h>
ramindanid32ae8e2021-10-01 18:48:39 +000032#include <gtest/gtest.h>
Ady Abraham72c5b502021-12-10 17:23:39 -080033#include <ui/Fence.h>
ramindani3335f7a2021-10-25 17:22:35 +000034#include <ui/GraphicBuffer.h>
Brian Lindahl9f9d2f02024-10-24 16:23:57 -060035#include <ui/PictureProfileHandle.h>
ramindani3335f7a2021-10-25 17:22:35 +000036#include <ui/PixelFormat.h>
ramindani0291f112021-11-04 03:45:46 +000037#include <algorithm>
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -040038#include <iterator>
Joen Chene0a962c2023-08-28 09:49:11 +000039#include <mutex>
ramindani592b6512021-10-08 21:15:19 +000040#include <numeric>
ramindanid32ae8e2021-10-01 18:48:39 +000041#include <string>
ramindani1cb794e2021-10-13 20:45:23 +000042#include <thread>
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -040043#include <unordered_map>
ramindani458e53e2022-02-23 17:30:16 +000044#include "GraphicsComposerCallback.h"
45#include "VtsComposerClient.h"
ramindani3335f7a2021-10-25 17:22:35 +000046
ramindanid32ae8e2021-10-01 18:48:39 +000047#undef LOG_TAG
48#define LOG_TAG "VtsHalGraphicsComposer3_TargetTest"
49
50namespace aidl::android::hardware::graphics::composer3::vts {
ramindanid32ae8e2021-10-01 18:48:39 +000051
ramindani1cb794e2021-10-13 20:45:23 +000052using namespace std::chrono_literals;
53
ramindanidcfe3a82021-11-29 17:00:31 +000054using ::android::GraphicBuffer;
55using ::android::sp;
56
ramindanid32ae8e2021-10-01 18:48:39 +000057class GraphicsComposerAidlTest : public ::testing::TestWithParam<std::string> {
ramindania9780262021-10-01 18:48:39 +000058 protected:
59 void SetUp() override {
ramindani431aad42022-02-01 21:44:29 +000060 mComposerClient = std::make_unique<VtsComposerClient>(GetParam());
61 ASSERT_TRUE(mComposerClient->createClient().isOk());
Jason Macnake531a092022-01-20 08:49:09 -080062
ramindani431aad42022-02-01 21:44:29 +000063 const auto& [status, displays] = mComposerClient->getDisplays();
Jason Macnake531a092022-01-20 08:49:09 -080064 ASSERT_TRUE(status.isOk());
ramindani431aad42022-02-01 21:44:29 +000065 mDisplays = displays;
ramindanidcfe3a82021-11-29 17:00:31 +000066
ramindani3335f7a2021-10-25 17:22:35 +000067 // explicitly disable vsync
68 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +000069 EXPECT_TRUE(mComposerClient->setVsync(display.getDisplayId(), false).isOk());
ramindani3335f7a2021-10-25 17:22:35 +000070 }
ramindani431aad42022-02-01 21:44:29 +000071 mComposerClient->setVsyncAllowed(false);
ramindania9780262021-10-01 18:48:39 +000072 }
73
ramindani3335f7a2021-10-25 17:22:35 +000074 void TearDown() override {
Ady Abrahama00d2462023-12-26 14:21:20 -080075 ASSERT_TRUE(mComposerClient->tearDown(nullptr));
ramindani431aad42022-02-01 21:44:29 +000076 mComposerClient.reset();
ramindani3335f7a2021-10-25 17:22:35 +000077 }
ramindanic2b8d082021-11-06 02:03:50 +000078
ramindanid5751092022-04-22 22:30:20 +000079 void assertServiceSpecificError(const ScopedAStatus& status, int32_t serviceSpecificError) {
80 ASSERT_EQ(status.getExceptionCode(), EX_SERVICE_SPECIFIC);
81 ASSERT_EQ(status.getServiceSpecificError(), serviceSpecificError);
82 }
83
ramindani431aad42022-02-01 21:44:29 +000084 void Test_setContentTypeForDisplay(int64_t display,
85 const std::vector<ContentType>& supportedContentTypes,
86 ContentType contentType, const char* contentTypeStr) {
87 const bool contentTypeSupport =
88 std::find(supportedContentTypes.begin(), supportedContentTypes.end(),
89 contentType) != supportedContentTypes.end();
ramindanidcfe3a82021-11-29 17:00:31 +000090
91 if (!contentTypeSupport) {
ramindani431aad42022-02-01 21:44:29 +000092 const auto& status = mComposerClient->setContentType(display, contentType);
93 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +000094 EXPECT_NO_FATAL_FAILURE(
95 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
ramindanidcfe3a82021-11-29 17:00:31 +000096 GTEST_SUCCEED() << contentTypeStr << " content type is not supported on display "
97 << std::to_string(display) << ", skipping test";
98 return;
99 }
100
101 EXPECT_TRUE(mComposerClient->setContentType(display, contentType).isOk());
102 EXPECT_TRUE(mComposerClient->setContentType(display, ContentType::NONE).isOk());
103 }
104
ramindani431aad42022-02-01 21:44:29 +0000105 void Test_setContentType(ContentType contentType, const char* contentTypeStr) {
ramindanidcfe3a82021-11-29 17:00:31 +0000106 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000107 const auto& [status, supportedContentTypes] =
108 mComposerClient->getSupportedContentTypes(display.getDisplayId());
109 EXPECT_TRUE(status.isOk());
110 Test_setContentTypeForDisplay(display.getDisplayId(), supportedContentTypes,
111 contentType, contentTypeStr);
ramindanidcfe3a82021-11-29 17:00:31 +0000112 }
113 }
114
Jason Macnak325e8232022-01-24 14:48:55 -0800115 bool hasCapability(Capability capability) {
ramindani431aad42022-02-01 21:44:29 +0000116 const auto& [status, capabilities] = mComposerClient->getCapabilities();
117 EXPECT_TRUE(status.isOk());
Jason Macnak325e8232022-01-24 14:48:55 -0800118 return std::any_of(
119 capabilities.begin(), capabilities.end(),
120 [&](const Capability& activeCapability) { return activeCapability == capability; });
121 }
122
Brian Lindahl9f9d2f02024-10-24 16:23:57 -0600123 bool hasDisplayCapability(int64_t displayId, DisplayCapability capability) {
124 const auto& [status, capabilities] = mComposerClient->getDisplayCapabilities(displayId);
125 EXPECT_TRUE(status.isOk());
126 return std::any_of(capabilities.begin(), capabilities.end(),
127 [&](const DisplayCapability& activeCapability) {
128 return activeCapability == capability;
129 });
130 }
131
ramindani17c71102023-03-20 10:51:14 -0700132 int getInterfaceVersion() {
133 const auto& [versionStatus, version] = mComposerClient->getInterfaceVersion();
134 EXPECT_TRUE(versionStatus.isOk());
135 return version;
136 }
137
ramindani431aad42022-02-01 21:44:29 +0000138 const VtsDisplay& getPrimaryDisplay() const { return mDisplays[0]; }
ramindania9780262021-10-01 18:48:39 +0000139
ramindani431aad42022-02-01 21:44:29 +0000140 int64_t getPrimaryDisplayId() const { return getPrimaryDisplay().getDisplayId(); }
ramindania9780262021-10-01 18:48:39 +0000141
ramindani431aad42022-02-01 21:44:29 +0000142 int64_t getInvalidDisplayId() const { return mComposerClient->getInvalidDisplayId(); }
ramindani1cb794e2021-10-13 20:45:23 +0000143
ramindani431aad42022-02-01 21:44:29 +0000144 VtsDisplay& getEditablePrimaryDisplay() { return mDisplays[0]; }
ramindani0291f112021-11-04 03:45:46 +0000145
ramindani3335f7a2021-10-25 17:22:35 +0000146 struct TestParameters {
147 nsecs_t delayForChange;
148 bool refreshMiss;
149 };
150
ramindani431aad42022-02-01 21:44:29 +0000151 std::unique_ptr<VtsComposerClient> mComposerClient;
ramindani1cb794e2021-10-13 20:45:23 +0000152 std::vector<VtsDisplay> mDisplays;
ramindani3335f7a2021-10-25 17:22:35 +0000153 // use the slot count usually set by SF
154 static constexpr uint32_t kBufferSlotCount = 64;
ramindanid32ae8e2021-10-01 18:48:39 +0000155};
156
ramindani431aad42022-02-01 21:44:29 +0000157TEST_P(GraphicsComposerAidlTest, GetDisplayCapabilities_BadDisplay) {
158 const auto& [status, _] = mComposerClient->getDisplayCapabilities(getInvalidDisplayId());
ramindani5f696942021-10-14 16:24:18 +0000159
ramindani431aad42022-02-01 21:44:29 +0000160 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000161 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindania9780262021-10-01 18:48:39 +0000162}
163
ramindani431aad42022-02-01 21:44:29 +0000164TEST_P(GraphicsComposerAidlTest, GetDisplayCapabilities) {
ramindania9780262021-10-01 18:48:39 +0000165 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000166 const auto& [status, capabilities] =
167 mComposerClient->getDisplayCapabilities(display.getDisplayId());
ramindania9780262021-10-01 18:48:39 +0000168
ramindani431aad42022-02-01 21:44:29 +0000169 EXPECT_TRUE(status.isOk());
ramindania9780262021-10-01 18:48:39 +0000170 }
ramindanid32ae8e2021-10-01 18:48:39 +0000171}
172
ramindani2740bac2021-11-24 22:58:32 +0000173TEST_P(GraphicsComposerAidlTest, DumpDebugInfo) {
ramindani431aad42022-02-01 21:44:29 +0000174 ASSERT_TRUE(mComposerClient->dumpDebugInfo().isOk());
ramindani2740bac2021-11-24 22:58:32 +0000175}
176
177TEST_P(GraphicsComposerAidlTest, CreateClientSingleton) {
178 std::shared_ptr<IComposerClient> composerClient;
ramindani431aad42022-02-01 21:44:29 +0000179 const auto& status = mComposerClient->createClient();
ramindani2740bac2021-11-24 22:58:32 +0000180
ramindani431aad42022-02-01 21:44:29 +0000181 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000182 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_NO_RESOURCES));
ramindani2740bac2021-11-24 22:58:32 +0000183}
184
ramindani592b6512021-10-08 21:15:19 +0000185TEST_P(GraphicsComposerAidlTest, GetDisplayIdentificationData) {
ramindani431aad42022-02-01 21:44:29 +0000186 const auto& [status0, displayIdentification0] =
187 mComposerClient->getDisplayIdentificationData(getPrimaryDisplayId());
ramindanid5751092022-04-22 22:30:20 +0000188 if (!status0.isOk() && status0.getExceptionCode() == EX_SERVICE_SPECIFIC &&
189 status0.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindani431aad42022-02-01 21:44:29 +0000190 GTEST_SUCCEED() << "Display identification data not supported, skipping test";
ramindani592b6512021-10-08 21:15:19 +0000191 return;
192 }
ramindani431aad42022-02-01 21:44:29 +0000193 ASSERT_TRUE(status0.isOk()) << "failed to get display identification data";
ramindani592b6512021-10-08 21:15:19 +0000194 ASSERT_FALSE(displayIdentification0.data.empty());
195
196 constexpr size_t kEdidBlockSize = 128;
197 ASSERT_TRUE(displayIdentification0.data.size() % kEdidBlockSize == 0)
198 << "EDID blob length is not a multiple of " << kEdidBlockSize;
199
200 const uint8_t kEdidHeader[] = {0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00};
201 ASSERT_TRUE(std::equal(std::begin(kEdidHeader), std::end(kEdidHeader),
202 displayIdentification0.data.begin()))
203 << "EDID blob doesn't start with the fixed EDID header";
204 ASSERT_EQ(0, std::accumulate(displayIdentification0.data.begin(),
205 displayIdentification0.data.begin() + kEdidBlockSize,
206 static_cast<uint8_t>(0)))
207 << "EDID base block doesn't checksum";
208
ramindani431aad42022-02-01 21:44:29 +0000209 const auto& [status1, displayIdentification1] =
210 mComposerClient->getDisplayIdentificationData(getPrimaryDisplayId());
211 ASSERT_TRUE(status1.isOk());
ramindani592b6512021-10-08 21:15:19 +0000212
213 ASSERT_EQ(displayIdentification0.port, displayIdentification1.port) << "ports are not stable";
214 ASSERT_TRUE(displayIdentification0.data.size() == displayIdentification1.data.size() &&
215 std::equal(displayIdentification0.data.begin(), displayIdentification0.data.end(),
216 displayIdentification1.data.begin()))
217 << "data is not stable";
218}
219
220TEST_P(GraphicsComposerAidlTest, GetHdrCapabilities) {
ramindani431aad42022-02-01 21:44:29 +0000221 const auto& [status, hdrCapabilities] =
222 mComposerClient->getHdrCapabilities(getPrimaryDisplayId());
ramindani592b6512021-10-08 21:15:19 +0000223
ramindani431aad42022-02-01 21:44:29 +0000224 ASSERT_TRUE(status.isOk());
225 EXPECT_TRUE(hdrCapabilities.maxLuminance >= hdrCapabilities.minLuminance);
ramindani592b6512021-10-08 21:15:19 +0000226}
227
228TEST_P(GraphicsComposerAidlTest, GetPerFrameMetadataKeys) {
ramindani431aad42022-02-01 21:44:29 +0000229 const auto& [status, keys] = mComposerClient->getPerFrameMetadataKeys(getPrimaryDisplayId());
ramindanid5751092022-04-22 22:30:20 +0000230 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
231 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindanic2b8d082021-11-06 02:03:50 +0000232 GTEST_SUCCEED() << "getPerFrameMetadataKeys is not supported";
233 return;
ramindani592b6512021-10-08 21:15:19 +0000234 }
ramindani431aad42022-02-01 21:44:29 +0000235
236 ASSERT_TRUE(status.isOk());
237 EXPECT_TRUE(keys.size() >= 0);
ramindani592b6512021-10-08 21:15:19 +0000238}
239
240TEST_P(GraphicsComposerAidlTest, GetReadbackBufferAttributes) {
ramindani431aad42022-02-01 21:44:29 +0000241 const auto& [status, _] = mComposerClient->getReadbackBufferAttributes(getPrimaryDisplayId());
ramindanid5751092022-04-22 22:30:20 +0000242 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
243 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindani431aad42022-02-01 21:44:29 +0000244 GTEST_SUCCEED() << "getReadbackBufferAttributes is not supported";
245 return;
ramindani592b6512021-10-08 21:15:19 +0000246 }
ramindani431aad42022-02-01 21:44:29 +0000247
248 ASSERT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000249}
250
251TEST_P(GraphicsComposerAidlTest, GetRenderIntents) {
ramindani431aad42022-02-01 21:44:29 +0000252 const auto& [status, modes] = mComposerClient->getColorModes(getPrimaryDisplayId());
253 EXPECT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000254
ramindani431aad42022-02-01 21:44:29 +0000255 for (auto mode : modes) {
256 const auto& [intentStatus, intents] =
257 mComposerClient->getRenderIntents(getPrimaryDisplayId(), mode);
258 EXPECT_TRUE(intentStatus.isOk());
ramindani592b6512021-10-08 21:15:19 +0000259 bool isHdr;
260 switch (mode) {
261 case ColorMode::BT2100_PQ:
262 case ColorMode::BT2100_HLG:
263 isHdr = true;
264 break;
265 default:
266 isHdr = false;
267 break;
268 }
269 RenderIntent requiredIntent =
270 isHdr ? RenderIntent::TONE_MAP_COLORIMETRIC : RenderIntent::COLORIMETRIC;
271
ramindani431aad42022-02-01 21:44:29 +0000272 const auto iter = std::find(intents.cbegin(), intents.cend(), requiredIntent);
ramindani592b6512021-10-08 21:15:19 +0000273 EXPECT_NE(intents.cend(), iter);
274 }
275}
276
ramindani431aad42022-02-01 21:44:29 +0000277TEST_P(GraphicsComposerAidlTest, GetRenderIntents_BadDisplay) {
278 const auto& [status, modes] = mComposerClient->getColorModes(getPrimaryDisplayId());
279 ASSERT_TRUE(status.isOk());
280
ramindani592b6512021-10-08 21:15:19 +0000281 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +0000282 const auto& [intentStatus, _] =
283 mComposerClient->getRenderIntents(getInvalidDisplayId(), mode);
284
285 EXPECT_FALSE(intentStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000286 EXPECT_NO_FATAL_FAILURE(
287 assertServiceSpecificError(intentStatus, IComposerClient::EX_BAD_DISPLAY));
ramindani592b6512021-10-08 21:15:19 +0000288 }
289}
290
ramindani431aad42022-02-01 21:44:29 +0000291TEST_P(GraphicsComposerAidlTest, GetRenderIntents_BadParameter) {
292 const auto& [status, _] =
293 mComposerClient->getRenderIntents(getPrimaryDisplayId(), static_cast<ColorMode>(-1));
294
295 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000296 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
ramindani592b6512021-10-08 21:15:19 +0000297}
298
299TEST_P(GraphicsComposerAidlTest, GetColorModes) {
ramindani431aad42022-02-01 21:44:29 +0000300 const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
301 ASSERT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000302
ramindani431aad42022-02-01 21:44:29 +0000303 const auto native = std::find(colorModes.cbegin(), colorModes.cend(), ColorMode::NATIVE);
304 EXPECT_NE(colorModes.cend(), native);
ramindani592b6512021-10-08 21:15:19 +0000305}
306
ramindani431aad42022-02-01 21:44:29 +0000307TEST_P(GraphicsComposerAidlTest, GetColorMode_BadDisplay) {
308 const auto& [status, _] = mComposerClient->getColorModes(getInvalidDisplayId());
ramindani592b6512021-10-08 21:15:19 +0000309
ramindani431aad42022-02-01 21:44:29 +0000310 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000311 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani592b6512021-10-08 21:15:19 +0000312}
313
314TEST_P(GraphicsComposerAidlTest, SetColorMode) {
ramindani431aad42022-02-01 21:44:29 +0000315 const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
316 EXPECT_TRUE(status.isOk());
317
ramindani592b6512021-10-08 21:15:19 +0000318 for (auto mode : colorModes) {
ramindani431aad42022-02-01 21:44:29 +0000319 const auto& [intentStatus, intents] =
320 mComposerClient->getRenderIntents(getPrimaryDisplayId(), mode);
321 EXPECT_TRUE(intentStatus.isOk()) << "failed to get render intents";
322
ramindani592b6512021-10-08 21:15:19 +0000323 for (auto intent : intents) {
ramindani431aad42022-02-01 21:44:29 +0000324 const auto modeStatus =
325 mComposerClient->setColorMode(getPrimaryDisplayId(), mode, intent);
326 EXPECT_TRUE(modeStatus.isOk() ||
ramindanid5751092022-04-22 22:30:20 +0000327 (modeStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
328 IComposerClient::EX_UNSUPPORTED == modeStatus.getServiceSpecificError()))
ramindani592b6512021-10-08 21:15:19 +0000329 << "failed to set color mode";
330 }
331 }
332
ramindani431aad42022-02-01 21:44:29 +0000333 const auto modeStatus = mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE,
334 RenderIntent::COLORIMETRIC);
335 EXPECT_TRUE(modeStatus.isOk() ||
ramindanid5751092022-04-22 22:30:20 +0000336 (modeStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
337 IComposerClient::EX_UNSUPPORTED == modeStatus.getServiceSpecificError()))
ramindani592b6512021-10-08 21:15:19 +0000338 << "failed to set color mode";
339}
340
ramindani431aad42022-02-01 21:44:29 +0000341TEST_P(GraphicsComposerAidlTest, SetColorMode_BadDisplay) {
342 const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
343 ASSERT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000344
ramindani431aad42022-02-01 21:44:29 +0000345 for (auto mode : colorModes) {
346 const auto& [intentStatus, intents] =
347 mComposerClient->getRenderIntents(getPrimaryDisplayId(), mode);
348 ASSERT_TRUE(intentStatus.isOk()) << "failed to get render intents";
349
350 for (auto intent : intents) {
351 auto const modeStatus =
352 mComposerClient->setColorMode(getInvalidDisplayId(), mode, intent);
353
354 EXPECT_FALSE(modeStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000355 EXPECT_NO_FATAL_FAILURE(
356 assertServiceSpecificError(modeStatus, IComposerClient::EX_BAD_DISPLAY));
ramindani770d7082021-11-30 00:36:42 +0000357 }
358 }
ramindani592b6512021-10-08 21:15:19 +0000359}
360
ramindani431aad42022-02-01 21:44:29 +0000361TEST_P(GraphicsComposerAidlTest, SetColorMode_BadParameter) {
362 auto status = mComposerClient->setColorMode(getPrimaryDisplayId(), static_cast<ColorMode>(-1),
363 RenderIntent::COLORIMETRIC);
ramindani592b6512021-10-08 21:15:19 +0000364
ramindani431aad42022-02-01 21:44:29 +0000365 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000366 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
ramindani592b6512021-10-08 21:15:19 +0000367
ramindani431aad42022-02-01 21:44:29 +0000368 status = mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE,
369 static_cast<RenderIntent>(-1));
ramindani592b6512021-10-08 21:15:19 +0000370
ramindani431aad42022-02-01 21:44:29 +0000371 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000372 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
ramindani592b6512021-10-08 21:15:19 +0000373}
374
375TEST_P(GraphicsComposerAidlTest, GetDisplayedContentSamplingAttributes) {
ramindani431aad42022-02-01 21:44:29 +0000376 int constexpr kInvalid = -1;
377 const auto& [status, format] =
378 mComposerClient->getDisplayedContentSamplingAttributes(getPrimaryDisplayId());
ramindani592b6512021-10-08 21:15:19 +0000379
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 }
385
ramindani431aad42022-02-01 21:44:29 +0000386 ASSERT_TRUE(status.isOk());
387 EXPECT_NE(kInvalid, static_cast<int>(format.format));
388 EXPECT_NE(kInvalid, static_cast<int>(format.dataspace));
389 EXPECT_NE(kInvalid, static_cast<int>(format.componentMask));
ramindani592b6512021-10-08 21:15:19 +0000390};
391
392TEST_P(GraphicsComposerAidlTest, SetDisplayedContentSamplingEnabled) {
ramindani431aad42022-02-01 21:44:29 +0000393 int constexpr kMaxFrames = 10;
ramindani592b6512021-10-08 21:15:19 +0000394 FormatColorComponent enableAllComponents = FormatColorComponent::FORMAT_COMPONENT_0;
ramindani431aad42022-02-01 21:44:29 +0000395 auto status = mComposerClient->setDisplayedContentSamplingEnabled(
396 getPrimaryDisplayId(), /*isEnabled*/ true, enableAllComponents, kMaxFrames);
ramindanid5751092022-04-22 22:30:20 +0000397 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
398 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindani592b6512021-10-08 21:15:19 +0000399 SUCCEED() << "Device does not support optional extension. Test skipped";
400 return;
401 }
ramindani431aad42022-02-01 21:44:29 +0000402 EXPECT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000403
ramindani431aad42022-02-01 21:44:29 +0000404 status = mComposerClient->setDisplayedContentSamplingEnabled(
405 getPrimaryDisplayId(), /*isEnabled*/ false, enableAllComponents, kMaxFrames);
406 EXPECT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000407}
408
409TEST_P(GraphicsComposerAidlTest, GetDisplayedContentSample) {
ramindani431aad42022-02-01 21:44:29 +0000410 const auto& [status, displayContentSamplingAttributes] =
411 mComposerClient->getDisplayedContentSamplingAttributes(getPrimaryDisplayId());
ramindanid5751092022-04-22 22:30:20 +0000412 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
413 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindanideb059e2021-11-18 01:57:25 +0000414 SUCCEED() << "Sampling attributes aren't supported on this device, test skipped";
415 return;
416 }
ramindani592b6512021-10-08 21:15:19 +0000417
ramindani431aad42022-02-01 21:44:29 +0000418 int64_t constexpr kMaxFrames = 10;
419 int64_t constexpr kTimestamp = 0;
420 const auto& [sampleStatus, displayContentSample] = mComposerClient->getDisplayedContentSample(
421 getPrimaryDisplayId(), kMaxFrames, kTimestamp);
ramindanid5751092022-04-22 22:30:20 +0000422 if (!sampleStatus.isOk() && sampleStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
ramindani431aad42022-02-01 21:44:29 +0000423 sampleStatus.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindani592b6512021-10-08 21:15:19 +0000424 SUCCEED() << "Device does not support optional extension. Test skipped";
425 return;
426 }
427
ramindani431aad42022-02-01 21:44:29 +0000428 EXPECT_TRUE(sampleStatus.isOk());
429 const std::vector<std::vector<int64_t>> histogram = {
ramindani592b6512021-10-08 21:15:19 +0000430 displayContentSample.sampleComponent0, displayContentSample.sampleComponent1,
431 displayContentSample.sampleComponent2, displayContentSample.sampleComponent3};
432
ramindani3335f7a2021-10-25 17:22:35 +0000433 for (size_t i = 0; i < histogram.size(); i++) {
434 const bool shouldHaveHistogram =
435 static_cast<int>(displayContentSamplingAttributes.componentMask) & (1 << i);
436 EXPECT_EQ(shouldHaveHistogram, !histogram[i].empty());
ramindani592b6512021-10-08 21:15:19 +0000437 }
438}
439
ramindani431aad42022-02-01 21:44:29 +0000440TEST_P(GraphicsComposerAidlTest, GetDisplayConnectionType) {
441 const auto& [status, type] = mComposerClient->getDisplayConnectionType(getInvalidDisplayId());
442
443 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000444 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani431aad42022-02-01 21:44:29 +0000445
ramindani0291f112021-11-04 03:45:46 +0000446 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000447 const auto& [connectionTypeStatus, _] =
448 mComposerClient->getDisplayConnectionType(display.getDisplayId());
449 EXPECT_TRUE(connectionTypeStatus.isOk());
ramindani0291f112021-11-04 03:45:46 +0000450 }
451}
452
ramindani431aad42022-02-01 21:44:29 +0000453TEST_P(GraphicsComposerAidlTest, GetDisplayAttribute) {
ramindani0291f112021-11-04 03:45:46 +0000454 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000455 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
456 EXPECT_TRUE(status.isOk());
457
ramindani0291f112021-11-04 03:45:46 +0000458 for (const auto& config : configs) {
459 const std::array<DisplayAttribute, 4> requiredAttributes = {{
460 DisplayAttribute::WIDTH,
461 DisplayAttribute::HEIGHT,
462 DisplayAttribute::VSYNC_PERIOD,
463 DisplayAttribute::CONFIG_GROUP,
464 }};
ramindani0291f112021-11-04 03:45:46 +0000465 for (const auto& attribute : requiredAttributes) {
ramindani431aad42022-02-01 21:44:29 +0000466 const auto& [attribStatus, value] = mComposerClient->getDisplayAttribute(
467 display.getDisplayId(), config, attribute);
468 EXPECT_TRUE(attribStatus.isOk());
ramindani0291f112021-11-04 03:45:46 +0000469 EXPECT_NE(-1, value);
470 }
471
472 const std::array<DisplayAttribute, 2> optionalAttributes = {{
473 DisplayAttribute::DPI_X,
474 DisplayAttribute::DPI_Y,
475 }};
476 for (const auto& attribute : optionalAttributes) {
ramindani431aad42022-02-01 21:44:29 +0000477 const auto& [attribStatus, value] = mComposerClient->getDisplayAttribute(
478 display.getDisplayId(), config, attribute);
ramindanid5751092022-04-22 22:30:20 +0000479 EXPECT_TRUE(attribStatus.isOk() ||
480 (attribStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
481 IComposerClient::EX_UNSUPPORTED ==
482 attribStatus.getServiceSpecificError()));
ramindani0291f112021-11-04 03:45:46 +0000483 }
484 }
485 }
486}
487
ramindani431aad42022-02-01 21:44:29 +0000488TEST_P(GraphicsComposerAidlTest, CheckConfigsAreValid) {
ramindani0291f112021-11-04 03:45:46 +0000489 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000490 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
491 EXPECT_TRUE(status.isOk());
ramindani0291f112021-11-04 03:45:46 +0000492
493 EXPECT_FALSE(std::any_of(configs.begin(), configs.end(), [](auto config) {
494 return config == IComposerClient::INVALID_CONFIGURATION;
495 }));
496 }
497}
498
ramindani431aad42022-02-01 21:44:29 +0000499TEST_P(GraphicsComposerAidlTest, GetDisplayVsyncPeriod_BadDisplay) {
500 const auto& [status, vsyncPeriodNanos] =
501 mComposerClient->getDisplayVsyncPeriod(getInvalidDisplayId());
502
503 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000504 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani0291f112021-11-04 03:45:46 +0000505}
506
ramindani431aad42022-02-01 21:44:29 +0000507TEST_P(GraphicsComposerAidlTest, SetActiveConfigWithConstraints_BadDisplay) {
ramindani0291f112021-11-04 03:45:46 +0000508 VsyncPeriodChangeConstraints constraints;
ramindani0291f112021-11-04 03:45:46 +0000509 constraints.seamlessRequired = false;
510 constraints.desiredTimeNanos = systemTime();
ramindani431aad42022-02-01 21:44:29 +0000511 auto invalidDisplay = VtsDisplay(getInvalidDisplayId());
ramindani0291f112021-11-04 03:45:46 +0000512
ramindani431aad42022-02-01 21:44:29 +0000513 const auto& [status, timeline] = mComposerClient->setActiveConfigWithConstraints(
514 &invalidDisplay, /*config*/ 0, constraints);
515
516 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000517 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani0291f112021-11-04 03:45:46 +0000518}
519
ramindani431aad42022-02-01 21:44:29 +0000520TEST_P(GraphicsComposerAidlTest, SetActiveConfigWithConstraints_BadConfig) {
ramindani0291f112021-11-04 03:45:46 +0000521 VsyncPeriodChangeConstraints constraints;
ramindani0291f112021-11-04 03:45:46 +0000522 constraints.seamlessRequired = false;
523 constraints.desiredTimeNanos = systemTime();
524
525 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000526 int32_t constexpr kInvalidConfigId = IComposerClient::INVALID_CONFIGURATION;
527 const auto& [status, _] = mComposerClient->setActiveConfigWithConstraints(
528 &display, kInvalidConfigId, constraints);
529
530 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000531 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_CONFIG));
ramindani0291f112021-11-04 03:45:46 +0000532 }
533}
534
ramindani431aad42022-02-01 21:44:29 +0000535TEST_P(GraphicsComposerAidlTest, SetBootDisplayConfig_BadDisplay) {
ramindani476314c2022-03-16 00:17:08 +0000536 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
537 GTEST_SUCCEED() << "Boot Display Config not supported";
538 return;
539 }
ramindani431aad42022-02-01 21:44:29 +0000540 const auto& status = mComposerClient->setBootDisplayConfig(getInvalidDisplayId(), /*config*/ 0);
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100541
ramindani431aad42022-02-01 21:44:29 +0000542 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000543 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100544}
545
ramindani431aad42022-02-01 21:44:29 +0000546TEST_P(GraphicsComposerAidlTest, SetBootDisplayConfig_BadConfig) {
ramindani476314c2022-03-16 00:17:08 +0000547 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
548 GTEST_SUCCEED() << "Boot Display Config not supported";
549 return;
550 }
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100551 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000552 int32_t constexpr kInvalidConfigId = IComposerClient::INVALID_CONFIGURATION;
553 const auto& status =
554 mComposerClient->setBootDisplayConfig(display.getDisplayId(), kInvalidConfigId);
555
556 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000557 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_CONFIG));
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100558 }
559}
560
ramindani431aad42022-02-01 21:44:29 +0000561TEST_P(GraphicsComposerAidlTest, SetBootDisplayConfig) {
ramindani476314c2022-03-16 00:17:08 +0000562 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
563 GTEST_SUCCEED() << "Boot Display Config not supported";
564 return;
565 }
ramindani431aad42022-02-01 21:44:29 +0000566 const auto& [status, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
567 EXPECT_TRUE(status.isOk());
568 for (const auto& config : configs) {
569 EXPECT_TRUE(mComposerClient->setBootDisplayConfig(getPrimaryDisplayId(), config).isOk());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100570 }
571}
572
ramindani431aad42022-02-01 21:44:29 +0000573TEST_P(GraphicsComposerAidlTest, ClearBootDisplayConfig_BadDisplay) {
ramindani476314c2022-03-16 00:17:08 +0000574 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
575 GTEST_SUCCEED() << "Boot Display Config not supported";
576 return;
577 }
ramindani431aad42022-02-01 21:44:29 +0000578 const auto& status = mComposerClient->clearBootDisplayConfig(getInvalidDisplayId());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100579
ramindani431aad42022-02-01 21:44:29 +0000580 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000581 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100582}
583
ramindani431aad42022-02-01 21:44:29 +0000584TEST_P(GraphicsComposerAidlTest, ClearBootDisplayConfig) {
ramindani476314c2022-03-16 00:17:08 +0000585 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
586 GTEST_SUCCEED() << "Boot Display Config not supported";
587 return;
588 }
ramindani431aad42022-02-01 21:44:29 +0000589 EXPECT_TRUE(mComposerClient->clearBootDisplayConfig(getPrimaryDisplayId()).isOk());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100590}
591
ramindani431aad42022-02-01 21:44:29 +0000592TEST_P(GraphicsComposerAidlTest, GetPreferredBootDisplayConfig_BadDisplay) {
ramindani476314c2022-03-16 00:17:08 +0000593 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
594 GTEST_SUCCEED() << "Boot Display Config not supported";
595 return;
596 }
ramindani431aad42022-02-01 21:44:29 +0000597 const auto& [status, _] = mComposerClient->getPreferredBootDisplayConfig(getInvalidDisplayId());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100598
ramindani431aad42022-02-01 21:44:29 +0000599 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000600 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100601}
602
ramindani431aad42022-02-01 21:44:29 +0000603TEST_P(GraphicsComposerAidlTest, GetPreferredBootDisplayConfig) {
ramindani476314c2022-03-16 00:17:08 +0000604 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
605 GTEST_SUCCEED() << "Boot Display Config not supported";
606 return;
607 }
ramindani431aad42022-02-01 21:44:29 +0000608 const auto& [status, preferredDisplayConfig] =
609 mComposerClient->getPreferredBootDisplayConfig(getPrimaryDisplayId());
610 EXPECT_TRUE(status.isOk());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100611
ramindani431aad42022-02-01 21:44:29 +0000612 const auto& [configStatus, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
613
614 EXPECT_TRUE(configStatus.isOk());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100615 EXPECT_NE(configs.end(), std::find(configs.begin(), configs.end(), preferredDisplayConfig));
616}
617
ramindani476314c2022-03-16 00:17:08 +0000618TEST_P(GraphicsComposerAidlTest, BootDisplayConfig_Unsupported) {
619 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
620 const auto& [configStatus, config] =
621 mComposerClient->getActiveConfig(getPrimaryDisplayId());
622 EXPECT_TRUE(configStatus.isOk());
623
624 auto status = mComposerClient->setBootDisplayConfig(getPrimaryDisplayId(), config);
625 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000626 EXPECT_NO_FATAL_FAILURE(
627 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
ramindani476314c2022-03-16 00:17:08 +0000628
629 status = mComposerClient->getPreferredBootDisplayConfig(getPrimaryDisplayId()).first;
630 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000631 EXPECT_NO_FATAL_FAILURE(
632 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
ramindani476314c2022-03-16 00:17:08 +0000633
634 status = mComposerClient->clearBootDisplayConfig(getPrimaryDisplayId());
635 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000636 EXPECT_NO_FATAL_FAILURE(
637 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
ramindani476314c2022-03-16 00:17:08 +0000638 }
639}
640
Kriti Dang3793ebd2022-12-05 13:03:49 +0100641TEST_P(GraphicsComposerAidlTest, GetHdrConversionCapabilities) {
642 if (!hasCapability(Capability::HDR_OUTPUT_CONVERSION_CONFIG)) {
643 GTEST_SUCCEED() << "HDR output conversion not supported";
644 return;
645 }
646 const auto& [status, conversionCapabilities] = mComposerClient->getHdrConversionCapabilities();
647 EXPECT_TRUE(status.isOk());
648}
649
650TEST_P(GraphicsComposerAidlTest, SetHdrConversionStrategy_Passthrough) {
651 if (!hasCapability(Capability::HDR_OUTPUT_CONVERSION_CONFIG)) {
652 GTEST_SUCCEED() << "HDR output conversion not supported";
653 return;
654 }
655 common::HdrConversionStrategy hdrConversionStrategy;
656 hdrConversionStrategy.set<common::HdrConversionStrategy::Tag::passthrough>(true);
Kriti Dang37622762023-02-09 18:15:37 +0100657 const auto& [status, preferredHdrOutputType] =
658 mComposerClient->setHdrConversionStrategy(hdrConversionStrategy);
Kriti Dang3793ebd2022-12-05 13:03:49 +0100659 EXPECT_TRUE(status.isOk());
Kriti Dang37622762023-02-09 18:15:37 +0100660 EXPECT_EQ(common::Hdr::INVALID, preferredHdrOutputType);
Kriti Dang3793ebd2022-12-05 13:03:49 +0100661}
662
663TEST_P(GraphicsComposerAidlTest, SetHdrConversionStrategy_Force) {
664 if (!hasCapability(Capability::HDR_OUTPUT_CONVERSION_CONFIG)) {
665 GTEST_SUCCEED() << "HDR output conversion not supported";
666 return;
667 }
668 const auto& [status, conversionCapabilities] = mComposerClient->getHdrConversionCapabilities();
Kriti Dang79bbec92023-05-04 17:54:26 +0200669 const auto& [status2, hdrCapabilities] =
670 mComposerClient->getHdrCapabilities(getPrimaryDisplayId());
671 const auto& hdrTypes = hdrCapabilities.types;
Kriti Dang3793ebd2022-12-05 13:03:49 +0100672 for (auto conversionCapability : conversionCapabilities) {
Kriti Dang5fcddd72023-03-07 14:55:51 +0100673 if (conversionCapability.outputType != common::Hdr::INVALID) {
Kriti Dang79bbec92023-05-04 17:54:26 +0200674 if (std::find(hdrTypes.begin(), hdrTypes.end(), conversionCapability.outputType) ==
675 hdrTypes.end()) {
676 continue;
677 }
Kriti Dang3793ebd2022-12-05 13:03:49 +0100678 common::HdrConversionStrategy hdrConversionStrategy;
679 hdrConversionStrategy.set<common::HdrConversionStrategy::Tag::forceHdrConversion>(
Kriti Dang5fcddd72023-03-07 14:55:51 +0100680 conversionCapability.outputType);
Kriti Dang37622762023-02-09 18:15:37 +0100681 const auto& [statusSet, preferredHdrOutputType] =
Kriti Dang3793ebd2022-12-05 13:03:49 +0100682 mComposerClient->setHdrConversionStrategy(hdrConversionStrategy);
Kriti Dang37622762023-02-09 18:15:37 +0100683 EXPECT_TRUE(statusSet.isOk());
684 EXPECT_EQ(common::Hdr::INVALID, preferredHdrOutputType);
Kriti Dang3793ebd2022-12-05 13:03:49 +0100685 }
686 }
687}
688
689TEST_P(GraphicsComposerAidlTest, SetHdrConversionStrategy_Auto) {
690 if (!hasCapability(Capability::HDR_OUTPUT_CONVERSION_CONFIG)) {
691 GTEST_SUCCEED() << "HDR output conversion not supported";
692 return;
693 }
694 const auto& [status, conversionCapabilities] = mComposerClient->getHdrConversionCapabilities();
Kriti Dang79bbec92023-05-04 17:54:26 +0200695 const auto& [status2, hdrCapabilities] =
696 mComposerClient->getHdrCapabilities(getPrimaryDisplayId());
697 if (hdrCapabilities.types.size() <= 0) {
698 return;
699 }
Kriti Dang3793ebd2022-12-05 13:03:49 +0100700 std::vector<aidl::android::hardware::graphics::common::Hdr> autoHdrTypes;
701 for (auto conversionCapability : conversionCapabilities) {
Kriti Dang5fcddd72023-03-07 14:55:51 +0100702 if (conversionCapability.outputType != common::Hdr::INVALID) {
703 autoHdrTypes.push_back(conversionCapability.outputType);
Kriti Dang3793ebd2022-12-05 13:03:49 +0100704 }
705 }
706 common::HdrConversionStrategy hdrConversionStrategy;
707 hdrConversionStrategy.set<common::HdrConversionStrategy::Tag::autoAllowedHdrTypes>(
708 autoHdrTypes);
Kriti Dang37622762023-02-09 18:15:37 +0100709 const auto& [statusSet, preferredHdrOutputType] =
710 mComposerClient->setHdrConversionStrategy(hdrConversionStrategy);
711 EXPECT_TRUE(statusSet.isOk());
712 EXPECT_NE(common::Hdr::INVALID, preferredHdrOutputType);
Kriti Dang3793ebd2022-12-05 13:03:49 +0100713}
714
ramindani431aad42022-02-01 21:44:29 +0000715TEST_P(GraphicsComposerAidlTest, SetAutoLowLatencyMode_BadDisplay) {
716 auto status = mComposerClient->setAutoLowLatencyMode(getInvalidDisplayId(), /*isEnabled*/ true);
717 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000718 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani431aad42022-02-01 21:44:29 +0000719
720 status = mComposerClient->setAutoLowLatencyMode(getInvalidDisplayId(), /*isEnabled*/ false);
721 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000722 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani0291f112021-11-04 03:45:46 +0000723}
724
ramindani431aad42022-02-01 21:44:29 +0000725TEST_P(GraphicsComposerAidlTest, SetAutoLowLatencyMode) {
ramindani0291f112021-11-04 03:45:46 +0000726 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000727 const auto& [status, capabilities] =
728 mComposerClient->getDisplayCapabilities(display.getDisplayId());
729 ASSERT_TRUE(status.isOk());
ramindani0291f112021-11-04 03:45:46 +0000730
731 const bool allmSupport =
732 std::find(capabilities.begin(), capabilities.end(),
733 DisplayCapability::AUTO_LOW_LATENCY_MODE) != capabilities.end();
734
735 if (!allmSupport) {
ramindani431aad42022-02-01 21:44:29 +0000736 const auto& statusIsOn = mComposerClient->setAutoLowLatencyMode(display.getDisplayId(),
737 /*isEnabled*/ true);
738 EXPECT_FALSE(statusIsOn.isOk());
ramindanid5751092022-04-22 22:30:20 +0000739 EXPECT_NO_FATAL_FAILURE(
740 assertServiceSpecificError(statusIsOn, IComposerClient::EX_UNSUPPORTED));
ramindani431aad42022-02-01 21:44:29 +0000741 const auto& statusIsOff = mComposerClient->setAutoLowLatencyMode(display.getDisplayId(),
742 /*isEnabled*/ false);
743 EXPECT_FALSE(statusIsOff.isOk());
ramindanid5751092022-04-22 22:30:20 +0000744 EXPECT_NO_FATAL_FAILURE(
745 assertServiceSpecificError(statusIsOff, IComposerClient::EX_UNSUPPORTED));
ramindani0291f112021-11-04 03:45:46 +0000746 GTEST_SUCCEED() << "Auto Low Latency Mode is not supported on display "
ramindani431aad42022-02-01 21:44:29 +0000747 << std::to_string(display.getDisplayId()) << ", skipping test";
ramindani0291f112021-11-04 03:45:46 +0000748 return;
749 }
750
ramindani431aad42022-02-01 21:44:29 +0000751 EXPECT_TRUE(mComposerClient->setAutoLowLatencyMode(display.getDisplayId(), true).isOk());
752 EXPECT_TRUE(mComposerClient->setAutoLowLatencyMode(display.getDisplayId(), false).isOk());
ramindani0291f112021-11-04 03:45:46 +0000753 }
754}
755
ramindani431aad42022-02-01 21:44:29 +0000756TEST_P(GraphicsComposerAidlTest, GetSupportedContentTypes_BadDisplay) {
757 const auto& [status, _] = mComposerClient->getSupportedContentTypes(getInvalidDisplayId());
758
759 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000760 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani0291f112021-11-04 03:45:46 +0000761}
762
ramindani431aad42022-02-01 21:44:29 +0000763TEST_P(GraphicsComposerAidlTest, GetSupportedContentTypes) {
ramindani0291f112021-11-04 03:45:46 +0000764 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000765 const auto& [status, supportedContentTypes] =
766 mComposerClient->getSupportedContentTypes(display.getDisplayId());
767 ASSERT_TRUE(status.isOk());
ramindani0291f112021-11-04 03:45:46 +0000768
769 const bool noneSupported =
770 std::find(supportedContentTypes.begin(), supportedContentTypes.end(),
771 ContentType::NONE) != supportedContentTypes.end();
ramindani431aad42022-02-01 21:44:29 +0000772
ramindani0291f112021-11-04 03:45:46 +0000773 EXPECT_FALSE(noneSupported);
774 }
775}
776
ramindani431aad42022-02-01 21:44:29 +0000777TEST_P(GraphicsComposerAidlTest, SetContentTypeNoneAlwaysAccepted) {
ramindani0291f112021-11-04 03:45:46 +0000778 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000779 EXPECT_TRUE(
780 mComposerClient->setContentType(display.getDisplayId(), ContentType::NONE).isOk());
ramindani0291f112021-11-04 03:45:46 +0000781 }
782}
783
ramindani431aad42022-02-01 21:44:29 +0000784TEST_P(GraphicsComposerAidlTest, SetContentType_BadDisplay) {
ramindani0291f112021-11-04 03:45:46 +0000785 constexpr ContentType types[] = {ContentType::NONE, ContentType::GRAPHICS, ContentType::PHOTO,
786 ContentType::CINEMA, ContentType::GAME};
787 for (const auto& type : types) {
ramindani431aad42022-02-01 21:44:29 +0000788 const auto& status = mComposerClient->setContentType(getInvalidDisplayId(), type);
ramindani0291f112021-11-04 03:45:46 +0000789
ramindani431aad42022-02-01 21:44:29 +0000790 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000791 EXPECT_NO_FATAL_FAILURE(
792 assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani0291f112021-11-04 03:45:46 +0000793 }
794}
795
ramindani431aad42022-02-01 21:44:29 +0000796TEST_P(GraphicsComposerAidlTest, SetGraphicsContentType) {
ramindani0291f112021-11-04 03:45:46 +0000797 Test_setContentType(ContentType::GRAPHICS, "GRAPHICS");
798}
799
ramindani431aad42022-02-01 21:44:29 +0000800TEST_P(GraphicsComposerAidlTest, SetPhotoContentType) {
ramindani0291f112021-11-04 03:45:46 +0000801 Test_setContentType(ContentType::PHOTO, "PHOTO");
802}
803
ramindani431aad42022-02-01 21:44:29 +0000804TEST_P(GraphicsComposerAidlTest, SetCinemaContentType) {
ramindani0291f112021-11-04 03:45:46 +0000805 Test_setContentType(ContentType::CINEMA, "CINEMA");
806}
807
ramindani431aad42022-02-01 21:44:29 +0000808TEST_P(GraphicsComposerAidlTest, SetGameContentType) {
ramindani0291f112021-11-04 03:45:46 +0000809 Test_setContentType(ContentType::GAME, "GAME");
810}
811
ramindanic2b8d082021-11-06 02:03:50 +0000812TEST_P(GraphicsComposerAidlTest, CreateVirtualDisplay) {
ramindani431aad42022-02-01 21:44:29 +0000813 const auto& [status, maxVirtualDisplayCount] = mComposerClient->getMaxVirtualDisplayCount();
814 EXPECT_TRUE(status.isOk());
815
ramindanic2b8d082021-11-06 02:03:50 +0000816 if (maxVirtualDisplayCount == 0) {
817 GTEST_SUCCEED() << "no virtual display support";
818 return;
819 }
820
ramindani431aad42022-02-01 21:44:29 +0000821 const auto& [virtualDisplayStatus, virtualDisplay] = mComposerClient->createVirtualDisplay(
822 /*width*/ 64, /*height*/ 64, common::PixelFormat::IMPLEMENTATION_DEFINED,
823 kBufferSlotCount);
ramindanic2b8d082021-11-06 02:03:50 +0000824
ramindani431aad42022-02-01 21:44:29 +0000825 ASSERT_TRUE(virtualDisplayStatus.isOk());
ramindanic2b8d082021-11-06 02:03:50 +0000826 EXPECT_TRUE(mComposerClient->destroyVirtualDisplay(virtualDisplay.display).isOk());
827}
828
ramindani431aad42022-02-01 21:44:29 +0000829TEST_P(GraphicsComposerAidlTest, DestroyVirtualDisplay_BadDisplay) {
830 const auto& [status, maxDisplayCount] = mComposerClient->getMaxVirtualDisplayCount();
831 EXPECT_TRUE(status.isOk());
832
ramindani2740bac2021-11-24 22:58:32 +0000833 if (maxDisplayCount == 0) {
834 GTEST_SUCCEED() << "no virtual display support";
835 return;
836 }
ramindani2740bac2021-11-24 22:58:32 +0000837
ramindani431aad42022-02-01 21:44:29 +0000838 const auto& destroyStatus = mComposerClient->destroyVirtualDisplay(getInvalidDisplayId());
839
840 EXPECT_FALSE(destroyStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000841 EXPECT_NO_FATAL_FAILURE(
842 assertServiceSpecificError(destroyStatus, IComposerClient::EX_BAD_DISPLAY));
ramindani2740bac2021-11-24 22:58:32 +0000843}
844
845TEST_P(GraphicsComposerAidlTest, CreateLayer) {
Ady Abrahama00d2462023-12-26 14:21:20 -0800846 if (hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
847 GTEST_SKIP() << "Create layer will be tested in GraphicsComposerAidlBatchedCommandTest";
848 return;
849 }
850
ramindani431aad42022-02-01 21:44:29 +0000851 const auto& [status, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -0800852 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, nullptr);
ramindani2740bac2021-11-24 22:58:32 +0000853
ramindani431aad42022-02-01 21:44:29 +0000854 EXPECT_TRUE(status.isOk());
Ady Abrahama00d2462023-12-26 14:21:20 -0800855 EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer, nullptr).isOk());
ramindani2740bac2021-11-24 22:58:32 +0000856}
857
ramindani431aad42022-02-01 21:44:29 +0000858TEST_P(GraphicsComposerAidlTest, CreateLayer_BadDisplay) {
Ady Abrahama00d2462023-12-26 14:21:20 -0800859 if (hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
860 GTEST_SKIP() << "Create layer will be tested in GraphicsComposerAidlBatchedCommandTest";
861 return;
862 }
863
864 const auto& [status, _] =
865 mComposerClient->createLayer(getInvalidDisplayId(), kBufferSlotCount, nullptr);
ramindani2740bac2021-11-24 22:58:32 +0000866
ramindani431aad42022-02-01 21:44:29 +0000867 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000868 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani2740bac2021-11-24 22:58:32 +0000869}
870
ramindani431aad42022-02-01 21:44:29 +0000871TEST_P(GraphicsComposerAidlTest, DestroyLayer_BadDisplay) {
Ady Abrahama00d2462023-12-26 14:21:20 -0800872 if (hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
873 GTEST_SKIP() << "Destroy layer will be tested in GraphicsComposerAidlBatchedCommandTest";
874 return;
875 }
876
ramindani431aad42022-02-01 21:44:29 +0000877 const auto& [status, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -0800878 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, nullptr);
ramindani431aad42022-02-01 21:44:29 +0000879 EXPECT_TRUE(status.isOk());
ramindani2740bac2021-11-24 22:58:32 +0000880
Ady Abrahama00d2462023-12-26 14:21:20 -0800881 const auto& destroyStatus =
882 mComposerClient->destroyLayer(getInvalidDisplayId(), layer, nullptr);
ramindani2740bac2021-11-24 22:58:32 +0000883
ramindani431aad42022-02-01 21:44:29 +0000884 EXPECT_FALSE(destroyStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000885 EXPECT_NO_FATAL_FAILURE(
886 assertServiceSpecificError(destroyStatus, IComposerClient::EX_BAD_DISPLAY));
Ady Abrahama00d2462023-12-26 14:21:20 -0800887 ASSERT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer, nullptr).isOk());
ramindani2740bac2021-11-24 22:58:32 +0000888}
889
ramindani431aad42022-02-01 21:44:29 +0000890TEST_P(GraphicsComposerAidlTest, DestroyLayer_BadLayerError) {
Ady Abrahama00d2462023-12-26 14:21:20 -0800891 if (hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
892 GTEST_SKIP() << "Destroy layer will be tested in GraphicsComposerAidlBatchedCommandTest";
893 return;
894 }
895
ramindani2740bac2021-11-24 22:58:32 +0000896 // We haven't created any layers yet, so any id should be invalid
Ady Abrahama00d2462023-12-26 14:21:20 -0800897 const auto& status = mComposerClient->destroyLayer(getPrimaryDisplayId(), /*layer*/ 1, nullptr);
ramindani2740bac2021-11-24 22:58:32 +0000898
ramindani431aad42022-02-01 21:44:29 +0000899 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000900 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_LAYER));
ramindani2740bac2021-11-24 22:58:32 +0000901}
902
ramindani431aad42022-02-01 21:44:29 +0000903TEST_P(GraphicsComposerAidlTest, GetActiveConfig_BadDisplay) {
904 const auto& [status, _] = mComposerClient->getActiveConfig(getInvalidDisplayId());
ramindani2740bac2021-11-24 22:58:32 +0000905
ramindani431aad42022-02-01 21:44:29 +0000906 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000907 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani2740bac2021-11-24 22:58:32 +0000908}
909
910TEST_P(GraphicsComposerAidlTest, GetDisplayConfig) {
ramindani431aad42022-02-01 21:44:29 +0000911 const auto& [status, _] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
912 EXPECT_TRUE(status.isOk());
ramindani2740bac2021-11-24 22:58:32 +0000913}
914
ramindani431aad42022-02-01 21:44:29 +0000915TEST_P(GraphicsComposerAidlTest, GetDisplayConfig_BadDisplay) {
916 const auto& [status, _] = mComposerClient->getDisplayConfigs(getInvalidDisplayId());
ramindani2740bac2021-11-24 22:58:32 +0000917
ramindani431aad42022-02-01 21:44:29 +0000918 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000919 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani2740bac2021-11-24 22:58:32 +0000920}
921
922TEST_P(GraphicsComposerAidlTest, GetDisplayName) {
ramindani431aad42022-02-01 21:44:29 +0000923 const auto& [status, _] = mComposerClient->getDisplayName(getPrimaryDisplayId());
924 EXPECT_TRUE(status.isOk());
ramindani2740bac2021-11-24 22:58:32 +0000925}
926
ramindani431aad42022-02-01 21:44:29 +0000927TEST_P(GraphicsComposerAidlTest, GetDisplayPhysicalOrientation_BadDisplay) {
928 const auto& [status, _] = mComposerClient->getDisplayPhysicalOrientation(getInvalidDisplayId());
Ady Abrahamae12e382022-01-13 18:06:21 -0800929
ramindani431aad42022-02-01 21:44:29 +0000930 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000931 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
Ady Abrahamae12e382022-01-13 18:06:21 -0800932}
933
934TEST_P(GraphicsComposerAidlTest, GetDisplayPhysicalOrientation) {
935 const auto allowedDisplayOrientations = std::array<Transform, 4>{
936 Transform::NONE,
937 Transform::ROT_90,
938 Transform::ROT_180,
939 Transform::ROT_270,
940 };
941
ramindani431aad42022-02-01 21:44:29 +0000942 const auto& [status, displayOrientation] =
943 mComposerClient->getDisplayPhysicalOrientation(getPrimaryDisplayId());
Ady Abrahamae12e382022-01-13 18:06:21 -0800944
ramindani431aad42022-02-01 21:44:29 +0000945 EXPECT_TRUE(status.isOk());
Ady Abrahamae12e382022-01-13 18:06:21 -0800946 EXPECT_NE(std::find(allowedDisplayOrientations.begin(), allowedDisplayOrientations.end(),
947 displayOrientation),
948 allowedDisplayOrientations.end());
949}
950
ramindani2740bac2021-11-24 22:58:32 +0000951TEST_P(GraphicsComposerAidlTest, SetClientTargetSlotCount) {
ramindani431aad42022-02-01 21:44:29 +0000952 EXPECT_TRUE(mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kBufferSlotCount)
953 .isOk());
ramindani2740bac2021-11-24 22:58:32 +0000954}
955
956TEST_P(GraphicsComposerAidlTest, SetActiveConfig) {
ramindani431aad42022-02-01 21:44:29 +0000957 const auto& [status, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
958 EXPECT_TRUE(status.isOk());
959
960 for (const auto& config : configs) {
961 auto display = getEditablePrimaryDisplay();
962 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config).isOk());
963 const auto& [configStatus, config1] =
964 mComposerClient->getActiveConfig(getPrimaryDisplayId());
965 EXPECT_TRUE(configStatus.isOk());
ramindani2740bac2021-11-24 22:58:32 +0000966 EXPECT_EQ(config, config1);
967 }
968}
969
970TEST_P(GraphicsComposerAidlTest, SetActiveConfigPowerCycle) {
ramindani431aad42022-02-01 21:44:29 +0000971 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
972 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
ramindani2740bac2021-11-24 22:58:32 +0000973
ramindani431aad42022-02-01 21:44:29 +0000974 const auto& [status, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
975 EXPECT_TRUE(status.isOk());
976
977 for (const auto& config : configs) {
978 auto display = getEditablePrimaryDisplay();
979 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config).isOk());
980 const auto& [config1Status, config1] =
981 mComposerClient->getActiveConfig(getPrimaryDisplayId());
982 EXPECT_TRUE(config1Status.isOk());
ramindani2740bac2021-11-24 22:58:32 +0000983 EXPECT_EQ(config, config1);
984
ramindani431aad42022-02-01 21:44:29 +0000985 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
986 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
987 const auto& [config2Status, config2] =
988 mComposerClient->getActiveConfig(getPrimaryDisplayId());
989 EXPECT_TRUE(config2Status.isOk());
990 EXPECT_EQ(config, config2);
ramindani2740bac2021-11-24 22:58:32 +0000991 }
992}
993
ramindani2740bac2021-11-24 22:58:32 +0000994TEST_P(GraphicsComposerAidlTest, SetPowerModeUnsupported) {
ramindani431aad42022-02-01 21:44:29 +0000995 const auto& [status, capabilities] =
996 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
997 ASSERT_TRUE(status.isOk());
998
Ady Abraham6679baf2021-12-08 18:28:27 -0800999 const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
1000 DisplayCapability::DOZE) != capabilities.end();
1001 const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
1002 DisplayCapability::SUSPEND) != capabilities.end();
ramindani2740bac2021-11-24 22:58:32 +00001003
ramindani431aad42022-02-01 21:44:29 +00001004 if (!isDozeSupported) {
1005 const auto& powerModeDozeStatus =
1006 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE);
1007 EXPECT_FALSE(powerModeDozeStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +00001008 EXPECT_NO_FATAL_FAILURE(
1009 assertServiceSpecificError(powerModeDozeStatus, IComposerClient::EX_UNSUPPORTED));
ramindani431aad42022-02-01 21:44:29 +00001010
1011 const auto& powerModeDozeSuspendStatus =
1012 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE_SUSPEND);
1013 EXPECT_FALSE(powerModeDozeSuspendStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +00001014 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeDozeSuspendStatus,
1015 IComposerClient::EX_UNSUPPORTED));
ramindani2740bac2021-11-24 22:58:32 +00001016 }
Ady Abraham6679baf2021-12-08 18:28:27 -08001017
1018 if (!isSuspendSupported) {
ramindani431aad42022-02-01 21:44:29 +00001019 const auto& powerModeSuspendStatus =
1020 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON_SUSPEND);
1021 EXPECT_FALSE(powerModeSuspendStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +00001022 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeSuspendStatus,
1023 IComposerClient::EX_UNSUPPORTED));
Ady Abraham6679baf2021-12-08 18:28:27 -08001024
ramindani431aad42022-02-01 21:44:29 +00001025 const auto& powerModeDozeSuspendStatus =
1026 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE_SUSPEND);
1027 EXPECT_FALSE(powerModeDozeSuspendStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +00001028 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeDozeSuspendStatus,
1029 IComposerClient::EX_UNSUPPORTED));
Ady Abraham6679baf2021-12-08 18:28:27 -08001030 }
ramindani2740bac2021-11-24 22:58:32 +00001031}
1032
1033TEST_P(GraphicsComposerAidlTest, SetVsyncEnabled) {
ramindani431aad42022-02-01 21:44:29 +00001034 mComposerClient->setVsyncAllowed(true);
ramindani2740bac2021-11-24 22:58:32 +00001035
ramindani431aad42022-02-01 21:44:29 +00001036 EXPECT_TRUE(mComposerClient->setVsync(getPrimaryDisplayId(), true).isOk());
ramindani2740bac2021-11-24 22:58:32 +00001037 usleep(60 * 1000);
ramindani431aad42022-02-01 21:44:29 +00001038 EXPECT_TRUE(mComposerClient->setVsync(getPrimaryDisplayId(), false).isOk());
ramindani2740bac2021-11-24 22:58:32 +00001039
ramindani431aad42022-02-01 21:44:29 +00001040 mComposerClient->setVsyncAllowed(false);
ramindani2740bac2021-11-24 22:58:32 +00001041}
1042
ramindanic2b8d082021-11-06 02:03:50 +00001043TEST_P(GraphicsComposerAidlTest, SetPowerMode) {
ramindani431aad42022-02-01 21:44:29 +00001044 const auto& [status, capabilities] =
1045 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
1046 ASSERT_TRUE(status.isOk());
1047
Ady Abraham6679baf2021-12-08 18:28:27 -08001048 const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
1049 DisplayCapability::DOZE) != capabilities.end();
1050 const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
1051 DisplayCapability::SUSPEND) != capabilities.end();
1052
ramindanic2b8d082021-11-06 02:03:50 +00001053 std::vector<PowerMode> modes;
1054 modes.push_back(PowerMode::OFF);
ramindanic2b8d082021-11-06 02:03:50 +00001055 modes.push_back(PowerMode::ON);
1056
Ady Abraham6679baf2021-12-08 18:28:27 -08001057 if (isSuspendSupported) {
1058 modes.push_back(PowerMode::ON_SUSPEND);
1059 }
1060
ramindani770d7082021-11-30 00:36:42 +00001061 if (isDozeSupported) {
1062 modes.push_back(PowerMode::DOZE);
Ady Abraham6679baf2021-12-08 18:28:27 -08001063 }
1064
1065 if (isSuspendSupported && isDozeSupported) {
ramindani770d7082021-11-30 00:36:42 +00001066 modes.push_back(PowerMode::DOZE_SUSPEND);
1067 }
1068
ramindanic2b8d082021-11-06 02:03:50 +00001069 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001070 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindanic2b8d082021-11-06 02:03:50 +00001071 }
1072}
1073
1074TEST_P(GraphicsComposerAidlTest, SetPowerModeVariations) {
ramindani431aad42022-02-01 21:44:29 +00001075 const auto& [status, capabilities] =
1076 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
1077 ASSERT_TRUE(status.isOk());
1078
Ady Abraham6679baf2021-12-08 18:28:27 -08001079 const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
1080 DisplayCapability::DOZE) != capabilities.end();
1081 const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
1082 DisplayCapability::SUSPEND) != capabilities.end();
1083
ramindanic2b8d082021-11-06 02:03:50 +00001084 std::vector<PowerMode> modes;
1085
1086 modes.push_back(PowerMode::OFF);
ramindani770d7082021-11-30 00:36:42 +00001087 modes.push_back(PowerMode::ON);
ramindanic2b8d082021-11-06 02:03:50 +00001088 modes.push_back(PowerMode::OFF);
ramindanic2b8d082021-11-06 02:03:50 +00001089 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001090 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindanic2b8d082021-11-06 02:03:50 +00001091 }
ramindani770d7082021-11-30 00:36:42 +00001092 modes.clear();
ramindanic2b8d082021-11-06 02:03:50 +00001093
ramindani770d7082021-11-30 00:36:42 +00001094 modes.push_back(PowerMode::OFF);
1095 modes.push_back(PowerMode::OFF);
1096 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001097 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindani770d7082021-11-30 00:36:42 +00001098 }
ramindanic2b8d082021-11-06 02:03:50 +00001099 modes.clear();
1100
1101 modes.push_back(PowerMode::ON);
1102 modes.push_back(PowerMode::ON);
ramindanic2b8d082021-11-06 02:03:50 +00001103 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001104 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindanic2b8d082021-11-06 02:03:50 +00001105 }
ramindanic2b8d082021-11-06 02:03:50 +00001106 modes.clear();
1107
Ady Abraham6679baf2021-12-08 18:28:27 -08001108 if (isSuspendSupported) {
1109 modes.push_back(PowerMode::ON_SUSPEND);
1110 modes.push_back(PowerMode::ON_SUSPEND);
1111 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001112 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
Ady Abraham6679baf2021-12-08 18:28:27 -08001113 }
1114 modes.clear();
ramindanic2b8d082021-11-06 02:03:50 +00001115 }
1116
ramindanic2b8d082021-11-06 02:03:50 +00001117 if (isDozeSupported) {
ramindanic2b8d082021-11-06 02:03:50 +00001118 modes.push_back(PowerMode::DOZE);
1119 modes.push_back(PowerMode::DOZE);
ramindanic2b8d082021-11-06 02:03:50 +00001120 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001121 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindanic2b8d082021-11-06 02:03:50 +00001122 }
ramindanic2b8d082021-11-06 02:03:50 +00001123 modes.clear();
Ady Abraham6679baf2021-12-08 18:28:27 -08001124 }
ramindanic2b8d082021-11-06 02:03:50 +00001125
Ady Abraham6679baf2021-12-08 18:28:27 -08001126 if (isSuspendSupported && isDozeSupported) {
ramindanic2b8d082021-11-06 02:03:50 +00001127 modes.push_back(PowerMode::DOZE_SUSPEND);
1128 modes.push_back(PowerMode::DOZE_SUSPEND);
ramindanic2b8d082021-11-06 02:03:50 +00001129 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001130 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindanic2b8d082021-11-06 02:03:50 +00001131 }
Ady Abraham6679baf2021-12-08 18:28:27 -08001132 modes.clear();
ramindanic2b8d082021-11-06 02:03:50 +00001133 }
1134}
1135
ramindani431aad42022-02-01 21:44:29 +00001136TEST_P(GraphicsComposerAidlTest, SetPowerMode_BadDisplay) {
1137 const auto& status = mComposerClient->setPowerMode(getInvalidDisplayId(), PowerMode::ON);
ramindanic2b8d082021-11-06 02:03:50 +00001138
ramindani431aad42022-02-01 21:44:29 +00001139 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00001140 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindanic2b8d082021-11-06 02:03:50 +00001141}
1142
ramindani431aad42022-02-01 21:44:29 +00001143TEST_P(GraphicsComposerAidlTest, SetPowerMode_BadParameter) {
1144 const auto& status =
1145 mComposerClient->setPowerMode(getPrimaryDisplayId(), static_cast<PowerMode>(-1));
ramindanic2b8d082021-11-06 02:03:50 +00001146
ramindani431aad42022-02-01 21:44:29 +00001147 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00001148 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
ramindanic2b8d082021-11-06 02:03:50 +00001149}
1150
ramindanic2b8d082021-11-06 02:03:50 +00001151TEST_P(GraphicsComposerAidlTest, GetDataspaceSaturationMatrix) {
ramindani431aad42022-02-01 21:44:29 +00001152 const auto& [status, matrix] =
1153 mComposerClient->getDataspaceSaturationMatrix(common::Dataspace::SRGB_LINEAR);
1154 ASSERT_TRUE(status.isOk());
1155 ASSERT_EQ(16, matrix.size()); // matrix should not be empty if call succeeded.
ramindanideb059e2021-11-18 01:57:25 +00001156
ramindanic2b8d082021-11-06 02:03:50 +00001157 // the last row is known
ramindani431aad42022-02-01 21:44:29 +00001158 EXPECT_EQ(0.0f, matrix[12]);
1159 EXPECT_EQ(0.0f, matrix[13]);
1160 EXPECT_EQ(0.0f, matrix[14]);
1161 EXPECT_EQ(1.0f, matrix[15]);
ramindanic2b8d082021-11-06 02:03:50 +00001162}
1163
ramindani431aad42022-02-01 21:44:29 +00001164TEST_P(GraphicsComposerAidlTest, GetDataspaceSaturationMatrix_BadParameter) {
1165 const auto& [status, matrix] =
1166 mComposerClient->getDataspaceSaturationMatrix(common::Dataspace::UNKNOWN);
ramindanic2b8d082021-11-06 02:03:50 +00001167
ramindani431aad42022-02-01 21:44:29 +00001168 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00001169 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
ramindanic2b8d082021-11-06 02:03:50 +00001170}
1171
ramindani12423f52023-06-14 20:04:51 -07001172/*
1173 * Test that no two display configs are exactly the same.
1174 */
1175TEST_P(GraphicsComposerAidlTest, GetDisplayConfigNoRepetitions) {
1176 for (const auto& display : mDisplays) {
1177 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
1178 for (std::vector<int>::size_type i = 0; i < configs.size(); i++) {
1179 for (std::vector<int>::size_type j = i + 1; j < configs.size(); j++) {
1180 const auto& [widthStatus1, width1] = mComposerClient->getDisplayAttribute(
1181 display.getDisplayId(), configs[i], DisplayAttribute::WIDTH);
1182 const auto& [heightStatus1, height1] = mComposerClient->getDisplayAttribute(
1183 display.getDisplayId(), configs[i], DisplayAttribute::HEIGHT);
1184 const auto& [vsyncPeriodStatus1, vsyncPeriod1] =
1185 mComposerClient->getDisplayAttribute(display.getDisplayId(), configs[i],
1186 DisplayAttribute::VSYNC_PERIOD);
1187 const auto& [groupStatus1, group1] = mComposerClient->getDisplayAttribute(
1188 display.getDisplayId(), configs[i], DisplayAttribute::CONFIG_GROUP);
1189
1190 const auto& [widthStatus2, width2] = mComposerClient->getDisplayAttribute(
1191 display.getDisplayId(), configs[j], DisplayAttribute::WIDTH);
1192 const auto& [heightStatus2, height2] = mComposerClient->getDisplayAttribute(
1193 display.getDisplayId(), configs[j], DisplayAttribute::HEIGHT);
1194 const auto& [vsyncPeriodStatus2, vsyncPeriod2] =
1195 mComposerClient->getDisplayAttribute(display.getDisplayId(), configs[j],
1196 DisplayAttribute::VSYNC_PERIOD);
1197 const auto& [groupStatus2, group2] = mComposerClient->getDisplayAttribute(
1198 display.getDisplayId(), configs[j], DisplayAttribute::CONFIG_GROUP);
1199
1200 ASSERT_FALSE(width1 == width2 && height1 == height2 &&
1201 vsyncPeriod1 == vsyncPeriod2 && group1 == group2);
1202 }
1203 }
1204 }
1205}
1206
Ady Abrahama00d2462023-12-26 14:21:20 -08001207TEST_P(GraphicsComposerAidlTest, LayerLifecycleCapabilityNotSupportedOnOldVersions) {
1208 if (hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
1209 EXPECT_GE(getInterfaceVersion(), 3);
1210 }
1211}
1212
ramindani12423f52023-06-14 20:04:51 -07001213class GraphicsComposerAidlV2Test : public GraphicsComposerAidlTest {
1214 protected:
1215 void SetUp() override {
1216 GraphicsComposerAidlTest::SetUp();
1217 if (getInterfaceVersion() <= 1) {
1218 GTEST_SKIP() << "Device interface version is expected to be >= 2";
1219 }
1220 }
1221};
1222
1223TEST_P(GraphicsComposerAidlV2Test, GetOverlaySupport) {
1224 const auto& [status, properties] = mComposerClient->getOverlaySupport();
1225 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
1226 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
1227 GTEST_SUCCEED() << "getOverlaySupport is not supported";
1228 return;
1229 }
1230
1231 ASSERT_TRUE(status.isOk());
1232 for (const auto& i : properties.combinations) {
1233 for (const auto standard : i.standards) {
1234 const auto val = static_cast<int32_t>(standard) &
1235 static_cast<int32_t>(common::Dataspace::STANDARD_MASK);
1236 ASSERT_TRUE(val == static_cast<int32_t>(standard));
1237 }
1238 for (const auto transfer : i.transfers) {
1239 const auto val = static_cast<int32_t>(transfer) &
1240 static_cast<int32_t>(common::Dataspace::TRANSFER_MASK);
1241 ASSERT_TRUE(val == static_cast<int32_t>(transfer));
1242 }
1243 for (const auto range : i.ranges) {
1244 const auto val = static_cast<int32_t>(range) &
1245 static_cast<int32_t>(common::Dataspace::RANGE_MASK);
1246 ASSERT_TRUE(val == static_cast<int32_t>(range));
1247 }
1248 }
1249}
1250
ramindani02fe4772023-06-30 18:04:41 -07001251class GraphicsComposerAidlV3Test : public GraphicsComposerAidlTest {
1252 protected:
1253 void SetUp() override {
1254 GraphicsComposerAidlTest::SetUp();
1255 if (getInterfaceVersion() <= 2) {
1256 GTEST_SKIP() << "Device interface version is expected to be >= 3";
1257 }
1258 }
1259};
1260
1261TEST_P(GraphicsComposerAidlV3Test, GetDisplayConfigurations) {
1262 for (const auto& display : mDisplays) {
1263 const auto& [status, displayConfigurations] =
1264 mComposerClient->getDisplayConfigurations(display.getDisplayId());
1265 EXPECT_TRUE(status.isOk());
1266 EXPECT_FALSE(displayConfigurations.empty());
1267
1268 for (const auto& displayConfig : displayConfigurations) {
1269 EXPECT_NE(-1, displayConfig.width);
1270 EXPECT_NE(-1, displayConfig.height);
1271 EXPECT_NE(-1, displayConfig.vsyncPeriod);
1272 EXPECT_NE(-1, displayConfig.configGroup);
1273 if (displayConfig.dpi) {
ramindani2b2ec502023-08-25 18:47:38 -07001274 EXPECT_NE(-1.f, displayConfig.dpi->x);
1275 EXPECT_NE(-1.f, displayConfig.dpi->y);
ramindani02fe4772023-06-30 18:04:41 -07001276 }
ramindani2704c5f2023-07-18 20:53:24 -07001277 if (displayConfig.vrrConfig) {
1278 const auto& vrrConfig = *displayConfig.vrrConfig;
1279 EXPECT_GE(vrrConfig.minFrameIntervalNs, displayConfig.vsyncPeriod);
1280
ramindani2b2ec502023-08-25 18:47:38 -07001281 EXPECT_EQ(1, std::count_if(
1282 displayConfigurations.cbegin(), displayConfigurations.cend(),
1283 [displayConfig](const auto& config) {
1284 return config.configGroup == displayConfig.configGroup;
1285 }))
1286 << "There should be only one VRR mode in one ConfigGroup";
1287
ramindani2704c5f2023-07-18 20:53:24 -07001288 const auto verifyFrameIntervalIsDivisorOfVsync = [&](int32_t frameIntervalNs) {
1289 constexpr auto kThreshold = 0.05f; // 5%
1290 const auto ratio =
1291 static_cast<float>(frameIntervalNs) / displayConfig.vsyncPeriod;
1292 return ratio - std::round(ratio) <= kThreshold;
1293 };
1294
1295 EXPECT_TRUE(verifyFrameIntervalIsDivisorOfVsync(vrrConfig.minFrameIntervalNs));
1296
1297 if (vrrConfig.frameIntervalPowerHints) {
1298 const auto& frameIntervalPowerHints = *vrrConfig.frameIntervalPowerHints;
1299 EXPECT_FALSE(frameIntervalPowerHints.empty());
1300
1301 const auto minFrameInterval = *min_element(frameIntervalPowerHints.cbegin(),
1302 frameIntervalPowerHints.cend());
1303 EXPECT_LE(minFrameInterval->frameIntervalNs,
1304 VtsComposerClient::kMaxFrameIntervalNs);
ramindanifc93b732024-02-15 21:36:19 +00001305 const auto maxFrameInterval = *max_element(frameIntervalPowerHints.cbegin(),
1306 frameIntervalPowerHints.cend());
1307 EXPECT_GE(maxFrameInterval->frameIntervalNs, vrrConfig.minFrameIntervalNs);
ramindani2704c5f2023-07-18 20:53:24 -07001308
1309 EXPECT_TRUE(std::all_of(frameIntervalPowerHints.cbegin(),
1310 frameIntervalPowerHints.cend(),
1311 [&](const auto& frameIntervalPowerHint) {
1312 return verifyFrameIntervalIsDivisorOfVsync(
1313 frameIntervalPowerHint->frameIntervalNs);
1314 }));
1315 }
1316
1317 if (vrrConfig.notifyExpectedPresentConfig) {
1318 const auto& notifyExpectedPresentConfig =
1319 *vrrConfig.notifyExpectedPresentConfig;
ramindani52416e02023-12-19 16:03:14 -08001320 EXPECT_GE(notifyExpectedPresentConfig.headsUpNs, 0);
1321 EXPECT_GE(notifyExpectedPresentConfig.timeoutNs, 0);
ramindani2704c5f2023-07-18 20:53:24 -07001322 }
1323 }
ramindani02fe4772023-06-30 18:04:41 -07001324 }
1325 }
1326}
1327
1328TEST_P(GraphicsComposerAidlV3Test, GetDisplayConfigsIsSubsetOfGetDisplayConfigurations) {
1329 for (const auto& display : mDisplays) {
1330 const auto& [status, displayConfigurations] =
1331 mComposerClient->getDisplayConfigurations(display.getDisplayId());
1332 EXPECT_TRUE(status.isOk());
1333
1334 const auto& [legacyConfigStatus, legacyConfigs] =
1335 mComposerClient->getDisplayConfigs(display.getDisplayId());
1336 EXPECT_TRUE(legacyConfigStatus.isOk());
1337 EXPECT_FALSE(legacyConfigs.empty());
1338 EXPECT_TRUE(legacyConfigs.size() <= displayConfigurations.size());
1339
1340 for (const auto legacyConfigId : legacyConfigs) {
1341 const auto& legacyWidth = mComposerClient->getDisplayAttribute(
1342 display.getDisplayId(), legacyConfigId, DisplayAttribute::WIDTH);
1343 const auto& legacyHeight = mComposerClient->getDisplayAttribute(
1344 display.getDisplayId(), legacyConfigId, DisplayAttribute::HEIGHT);
1345 const auto& legacyVsyncPeriod = mComposerClient->getDisplayAttribute(
1346 display.getDisplayId(), legacyConfigId, DisplayAttribute::VSYNC_PERIOD);
1347 const auto& legacyConfigGroup = mComposerClient->getDisplayAttribute(
1348 display.getDisplayId(), legacyConfigId, DisplayAttribute::CONFIG_GROUP);
1349 const auto& legacyDpiX = mComposerClient->getDisplayAttribute(
1350 display.getDisplayId(), legacyConfigId, DisplayAttribute::DPI_X);
1351 const auto& legacyDpiY = mComposerClient->getDisplayAttribute(
1352 display.getDisplayId(), legacyConfigId, DisplayAttribute::DPI_Y);
1353
1354 EXPECT_TRUE(legacyWidth.first.isOk() && legacyHeight.first.isOk() &&
1355 legacyVsyncPeriod.first.isOk() && legacyConfigGroup.first.isOk());
1356
1357 EXPECT_TRUE(std::any_of(
1358 displayConfigurations.begin(), displayConfigurations.end(),
1359 [&](const auto& displayConfiguration) {
1360 const bool requiredAttributesPredicate =
1361 displayConfiguration.configId == legacyConfigId &&
1362 displayConfiguration.width == legacyWidth.second &&
1363 displayConfiguration.height == legacyHeight.second &&
1364 displayConfiguration.vsyncPeriod == legacyVsyncPeriod.second &&
1365 displayConfiguration.configGroup == legacyConfigGroup.second;
1366
1367 if (!requiredAttributesPredicate) {
1368 // Required attributes did not match
1369 return false;
1370 }
1371
1372 // Check optional attributes
1373 const auto& [legacyDpiXStatus, legacyDpiXValue] = legacyDpiX;
1374 const auto& [legacyDpiYStatus, legacyDpiYValue] = legacyDpiY;
1375 if (displayConfiguration.dpi) {
1376 if (!legacyDpiXStatus.isOk() || !legacyDpiYStatus.isOk()) {
1377 // getDisplayAttribute failed for optional attributes
1378 return false;
1379 }
1380
1381 // DPI values in DisplayConfigurations are not scaled (* 1000.f)
1382 // the way they are in the legacy DisplayConfigs.
1383 constexpr float kEpsilon = 0.001f;
1384 return std::abs(displayConfiguration.dpi->x -
1385 legacyDpiXValue / 1000.f) < kEpsilon &&
1386 std::abs(displayConfiguration.dpi->y -
1387 legacyDpiYValue / 1000.f) < kEpsilon;
1388 } else {
1389 return !legacyDpiXStatus.isOk() && !legacyDpiYStatus.isOk() &&
1390 EX_SERVICE_SPECIFIC == legacyDpiXStatus.getExceptionCode() &&
1391 EX_SERVICE_SPECIFIC == legacyDpiYStatus.getExceptionCode() &&
1392 IComposerClient::EX_UNSUPPORTED ==
1393 legacyDpiXStatus.getServiceSpecificError() &&
1394 IComposerClient::EX_UNSUPPORTED ==
1395 legacyDpiYStatus.getServiceSpecificError();
1396 }
1397 }));
1398 }
1399 }
1400}
1401
Brian Lindahl9f9d2f02024-10-24 16:23:57 -06001402TEST_P(GraphicsComposerAidlV3Test, GetMaxLayerPictureProfiles) {
1403 for (const auto& display : mDisplays) {
1404 const auto& [status, maxPorfiles] =
1405 mComposerClient->getMaxLayerPictureProfiles(display.getDisplayId());
1406 EXPECT_TRUE(status.isOk());
1407 }
1408}
1409
ramindanidcfe3a82021-11-29 17:00:31 +00001410// Tests for Command.
1411class GraphicsComposerAidlCommandTest : public GraphicsComposerAidlTest {
1412 protected:
ramindanidcfe3a82021-11-29 17:00:31 +00001413 void TearDown() override {
Leon Scroggins III94f4b202024-01-09 11:43:45 -05001414 ASSERT_FALSE(mDisplays.empty());
Ady Abraham3192f3d2021-12-03 16:08:56 -08001415 ASSERT_TRUE(mReader.takeErrors().empty());
ramindani431aad42022-02-01 21:44:29 +00001416 ASSERT_TRUE(mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty());
Ady Abraham3192f3d2021-12-03 16:08:56 -08001417
Ady Abrahama00d2462023-12-26 14:21:20 -08001418 ASSERT_TRUE(mComposerClient->tearDown(&getWriter(getPrimaryDisplayId())));
ramindanidcfe3a82021-11-29 17:00:31 +00001419 ASSERT_NO_FATAL_FAILURE(GraphicsComposerAidlTest::TearDown());
1420 }
1421
1422 void execute() {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001423 std::vector<CommandResultPayload> payloads;
1424 for (auto& [_, writer] : mWriters) {
Joen Chene0a962c2023-08-28 09:49:11 +00001425 executeInternal(writer, payloads);
ramindanidcfe3a82021-11-29 17:00:31 +00001426 }
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001427 mReader.parse(std::move(payloads));
ramindanidcfe3a82021-11-29 17:00:31 +00001428 }
1429
Joen Chene0a962c2023-08-28 09:49:11 +00001430 void execute(ComposerClientWriter& writer, ComposerClientReader& reader) {
1431 std::vector<CommandResultPayload> payloads;
1432 executeInternal(writer, payloads);
1433 reader.parse(std::move(payloads));
1434 }
1435
ramindanidcfe3a82021-11-29 17:00:31 +00001436 static inline auto toTimePoint(nsecs_t time) {
1437 return std::chrono::time_point<std::chrono::steady_clock>(std::chrono::nanoseconds(time));
1438 }
1439
ramindanidcfe3a82021-11-29 17:00:31 +00001440 void forEachTwoConfigs(int64_t display, std::function<void(int32_t, int32_t)> func) {
ramindani431aad42022-02-01 21:44:29 +00001441 const auto& [status, displayConfigs] = mComposerClient->getDisplayConfigs(display);
1442 ASSERT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001443 for (const int32_t config1 : displayConfigs) {
1444 for (const int32_t config2 : displayConfigs) {
1445 if (config1 != config2) {
1446 func(config1, config2);
1447 }
1448 }
1449 }
1450 }
1451
1452 void waitForVsyncPeriodChange(int64_t display, const VsyncPeriodChangeTimeline& timeline,
1453 int64_t desiredTimeNanos, int64_t oldPeriodNanos,
1454 int64_t newPeriodNanos) {
1455 const auto kChangeDeadline = toTimePoint(timeline.newVsyncAppliedTimeNanos) + 100ms;
1456 while (std::chrono::steady_clock::now() <= kChangeDeadline) {
ramindani431aad42022-02-01 21:44:29 +00001457 const auto& [status, vsyncPeriodNanos] =
1458 mComposerClient->getDisplayVsyncPeriod(display);
1459 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001460 if (systemTime() <= desiredTimeNanos) {
1461 EXPECT_EQ(vsyncPeriodNanos, oldPeriodNanos);
1462 } else if (vsyncPeriodNanos == newPeriodNanos) {
1463 break;
1464 }
1465 std::this_thread::sleep_for(std::chrono::nanoseconds(oldPeriodNanos));
1466 }
1467 }
1468
ramindani9dd8c482023-02-21 18:07:56 -08001469 bool checkIfCallbackRefreshRateChangedDebugEnabledReceived(
1470 std::function<bool(RefreshRateChangedDebugData)> filter) {
1471 const auto list = mComposerClient->takeListOfRefreshRateChangedDebugData();
1472 return std::any_of(list.begin(), list.end(), [&](auto refreshRateChangedDebugData) {
1473 return filter(refreshRateChangedDebugData);
1474 });
1475 }
1476
Brian Lindahl25e0d092022-12-09 00:32:11 -07001477 sp<GraphicBuffer> allocate(uint32_t width, uint32_t height,
1478 ::android::PixelFormat pixelFormat) {
Brian Lindahl14bd07b2023-01-17 14:54:39 -07001479 return sp<GraphicBuffer>::make(
Brian Lindahl25e0d092022-12-09 00:32:11 -07001480 width, height, pixelFormat, /*layerCount*/ 1U,
1481 static_cast<uint64_t>(common::BufferUsage::CPU_WRITE_OFTEN) |
1482 static_cast<uint64_t>(common::BufferUsage::CPU_READ_OFTEN) |
1483 static_cast<uint64_t>(common::BufferUsage::COMPOSER_OVERLAY),
Brian Lindahl14bd07b2023-01-17 14:54:39 -07001484 "VtsHalGraphicsComposer3_TargetTest");
Brian Lindahlca3eef22022-12-09 00:32:11 -07001485 }
1486
Brian Lindahl25e0d092022-12-09 00:32:11 -07001487 sp<GraphicBuffer> allocate(::android::PixelFormat pixelFormat) {
1488 return allocate(static_cast<uint32_t>(getPrimaryDisplay().getDisplayWidth()),
1489 static_cast<uint32_t>(getPrimaryDisplay().getDisplayHeight()), pixelFormat);
1490 }
1491
ramindanidcfe3a82021-11-29 17:00:31 +00001492 void sendRefreshFrame(const VtsDisplay& display, const VsyncPeriodChangeTimeline* timeline) {
1493 if (timeline != nullptr) {
1494 // Refresh time should be before newVsyncAppliedTimeNanos
1495 EXPECT_LT(timeline->refreshTimeNanos, timeline->newVsyncAppliedTimeNanos);
1496
1497 std::this_thread::sleep_until(toTimePoint(timeline->refreshTimeNanos));
1498 }
1499
ramindani431aad42022-02-01 21:44:29 +00001500 EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::ON).isOk());
1501 EXPECT_TRUE(mComposerClient
1502 ->setColorMode(display.getDisplayId(), ColorMode::NATIVE,
1503 RenderIntent::COLORIMETRIC)
1504 .isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001505
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001506 auto& writer = getWriter(display.getDisplayId());
Ady Abrahama00d2462023-12-26 14:21:20 -08001507 const auto& [status, layer] =
1508 mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
1509 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001510 {
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001511 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindanidcfe3a82021-11-29 17:00:31 +00001512 ASSERT_NE(nullptr, buffer);
1513 ASSERT_EQ(::android::OK, buffer->initCheck());
1514 ASSERT_NE(nullptr, buffer->handle);
1515
ramindani431aad42022-02-01 21:44:29 +00001516 configureLayer(display, layer, Composition::DEVICE, display.getFrameRect(),
1517 display.getCrop());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001518 writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, buffer->handle,
1519 /*acquireFence*/ -1);
1520 writer.setLayerDataspace(display.getDisplayId(), layer, common::Dataspace::UNKNOWN);
ramindanidcfe3a82021-11-29 17:00:31 +00001521
ramindanicdcfcaf2023-11-09 10:00:10 -08001522 writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp,
1523 VtsComposerClient::kNoFrameIntervalNs);
ramindanidcfe3a82021-11-29 17:00:31 +00001524 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001525 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001526
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001527 writer.presentDisplay(display.getDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001528 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001529 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001530 }
1531
1532 {
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001533 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindanidcfe3a82021-11-29 17:00:31 +00001534 ASSERT_NE(nullptr, buffer->handle);
1535
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001536 writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, buffer->handle,
1537 /*acquireFence*/ -1);
1538 writer.setLayerSurfaceDamage(display.getDisplayId(), layer,
1539 std::vector<Rect>(1, {0, 0, 10, 10}));
ramindanicdcfcaf2023-11-09 10:00:10 -08001540 writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp,
1541 VtsComposerClient::kNoFrameIntervalNs);
ramindanidcfe3a82021-11-29 17:00:31 +00001542 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001543 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001544
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001545 writer.presentDisplay(display.getDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001546 execute();
1547 }
1548
Ady Abrahama00d2462023-12-26 14:21:20 -08001549 EXPECT_TRUE(mComposerClient->destroyLayer(display.getDisplayId(), layer, &writer).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001550 }
1551
Ady Abraham72c5b502021-12-10 17:23:39 -08001552 sp<::android::Fence> presentAndGetFence(
ramindanifc93b732024-02-15 21:36:19 +00001553 std::optional<ClockMonotonicTimestamp> expectedPresentTime,
1554 std::optional<int64_t> displayIdOpt = {},
1555 int32_t frameIntervalNs = VtsComposerClient::kNoFrameIntervalNs) {
1556 const auto displayId = displayIdOpt.value_or(getPrimaryDisplayId());
1557 auto& writer = getWriter(displayId);
1558 writer.validateDisplay(displayId, expectedPresentTime, frameIntervalNs);
Ady Abraham72c5b502021-12-10 17:23:39 -08001559 execute();
1560 EXPECT_TRUE(mReader.takeErrors().empty());
1561
ramindanifc93b732024-02-15 21:36:19 +00001562 writer.presentDisplay(displayId);
Ady Abraham72c5b502021-12-10 17:23:39 -08001563 execute();
1564 EXPECT_TRUE(mReader.takeErrors().empty());
1565
ramindanifc93b732024-02-15 21:36:19 +00001566 auto presentFence = mReader.takePresentFence(displayId);
Ady Abraham46219f52021-12-20 09:44:31 -08001567 // take ownership
1568 const int fenceOwner = presentFence.get();
1569 *presentFence.getR() = -1;
1570 EXPECT_NE(-1, fenceOwner);
1571 return sp<::android::Fence>::make(fenceOwner);
Ady Abraham72c5b502021-12-10 17:23:39 -08001572 }
1573
1574 int32_t getVsyncPeriod() {
ramindani431aad42022-02-01 21:44:29 +00001575 const auto& [status, activeConfig] =
1576 mComposerClient->getActiveConfig(getPrimaryDisplayId());
1577 EXPECT_TRUE(status.isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001578
ramindani431aad42022-02-01 21:44:29 +00001579 const auto& [vsyncPeriodStatus, vsyncPeriod] = mComposerClient->getDisplayAttribute(
1580 getPrimaryDisplayId(), activeConfig, DisplayAttribute::VSYNC_PERIOD);
1581 EXPECT_TRUE(vsyncPeriodStatus.isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001582 return vsyncPeriod;
1583 }
1584
ramindanifc93b732024-02-15 21:36:19 +00001585 int64_t createOnScreenLayer(const VtsDisplay& display,
1586 Composition composition = Composition::DEVICE) {
1587 auto& writer = getWriter(display.getDisplayId());
ramindani431aad42022-02-01 21:44:29 +00001588 const auto& [status, layer] =
ramindanifc93b732024-02-15 21:36:19 +00001589 mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
ramindani431aad42022-02-01 21:44:29 +00001590 EXPECT_TRUE(status.isOk());
ramindanifc93b732024-02-15 21:36:19 +00001591 Rect displayFrame{0, 0, display.getDisplayWidth(), display.getDisplayHeight()};
1592 FRect cropRect{0, 0, (float)display.getDisplayWidth(), (float)display.getDisplayHeight()};
1593 configureLayer(display, layer, composition, displayFrame, cropRect);
Ady Abrahama00d2462023-12-26 14:21:20 -08001594
ramindanifc93b732024-02-15 21:36:19 +00001595 writer.setLayerDataspace(display.getDisplayId(), layer, common::Dataspace::UNKNOWN);
Ady Abraham72c5b502021-12-10 17:23:39 -08001596 return layer;
1597 }
1598
ramindani9dd8c482023-02-21 18:07:56 -08001599 void sendBufferUpdate(int64_t layer) {
1600 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1601 ASSERT_NE(nullptr, buffer->handle);
1602
1603 auto& writer = getWriter(getPrimaryDisplayId());
1604 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer->handle,
1605 /*acquireFence*/ -1);
1606
1607 const sp<::android::Fence> presentFence =
1608 presentAndGetFence(ComposerClientWriter::kNoTimestamp);
1609 presentFence->waitForever(LOG_TAG);
1610 }
1611
Midas Chiena0b56bd2022-01-13 23:27:33 +08001612 bool hasDisplayCapability(int64_t display, DisplayCapability cap) {
ramindani431aad42022-02-01 21:44:29 +00001613 const auto& [status, capabilities] = mComposerClient->getDisplayCapabilities(display);
1614 EXPECT_TRUE(status.isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08001615
1616 return std::find(capabilities.begin(), capabilities.end(), cap) != capabilities.end();
1617 }
1618
ramindanidcfe3a82021-11-29 17:00:31 +00001619 void Test_setActiveConfigWithConstraints(const TestParameters& params) {
1620 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +00001621 forEachTwoConfigs(display.getDisplayId(), [&](int32_t config1, int32_t config2) {
1622 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001623 sendRefreshFrame(display, nullptr);
1624
ramindani3ba73342024-04-01 11:42:33 -07001625 const auto displayConfig1 = display.getDisplayConfig(config1);
1626 int32_t vsyncPeriod1 = displayConfig1.vsyncPeriod;
1627 int32_t configGroup1 = displayConfig1.configGroup;
ramindani431aad42022-02-01 21:44:29 +00001628
ramindani3ba73342024-04-01 11:42:33 -07001629 const auto displayConfig2 = display.getDisplayConfig(config2);
1630 int32_t vsyncPeriod2 = displayConfig2.vsyncPeriod;
1631 int32_t configGroup2 = displayConfig2.configGroup;
ramindanidcfe3a82021-11-29 17:00:31 +00001632
1633 if (vsyncPeriod1 == vsyncPeriod2) {
1634 return; // continue
1635 }
1636
ramindani3ba73342024-04-01 11:42:33 -07001637 if ((!displayConfig1.vrrConfigOpt && displayConfig2.vrrConfigOpt) ||
1638 (displayConfig1.vrrConfigOpt && !displayConfig2.vrrConfigOpt)) {
1639 // switching between vrr to non-vrr modes
1640 return; // continue
1641 }
1642
ramindanidcfe3a82021-11-29 17:00:31 +00001643 // We don't allow delayed change when changing config groups
1644 if (params.delayForChange > 0 && configGroup1 != configGroup2) {
1645 return; // continue
1646 }
1647
ramindanidcfe3a82021-11-29 17:00:31 +00001648 VsyncPeriodChangeConstraints constraints = {
1649 .desiredTimeNanos = systemTime() + params.delayForChange,
1650 .seamlessRequired = false};
ramindani431aad42022-02-01 21:44:29 +00001651 const auto& [status, timeline] = mComposerClient->setActiveConfigWithConstraints(
1652 &display, config2, constraints);
1653 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001654
1655 EXPECT_TRUE(timeline.newVsyncAppliedTimeNanos >= constraints.desiredTimeNanos);
1656 // Refresh rate should change within a reasonable time
1657 constexpr std::chrono::nanoseconds kReasonableTimeForChange = 1s; // 1 second
1658 EXPECT_TRUE(timeline.newVsyncAppliedTimeNanos - constraints.desiredTimeNanos <=
1659 kReasonableTimeForChange.count());
1660
1661 if (timeline.refreshRequired) {
1662 if (params.refreshMiss) {
1663 // Miss the refresh frame on purpose to make sure the implementation sends a
1664 // callback
1665 std::this_thread::sleep_until(toTimePoint(timeline.refreshTimeNanos) +
1666 100ms);
1667 }
1668 sendRefreshFrame(display, &timeline);
1669 }
ramindani431aad42022-02-01 21:44:29 +00001670 waitForVsyncPeriodChange(display.getDisplayId(), timeline,
1671 constraints.desiredTimeNanos, vsyncPeriod1, vsyncPeriod2);
ramindanidcfe3a82021-11-29 17:00:31 +00001672
1673 // At this point the refresh rate should have changed already, however in rare
1674 // cases the implementation might have missed the deadline. In this case a new
1675 // timeline should have been provided.
ramindani431aad42022-02-01 21:44:29 +00001676 auto newTimeline = mComposerClient->takeLastVsyncPeriodChangeTimeline();
ramindanidcfe3a82021-11-29 17:00:31 +00001677 if (timeline.refreshRequired && params.refreshMiss) {
1678 EXPECT_TRUE(newTimeline.has_value());
1679 }
1680
1681 if (newTimeline.has_value()) {
1682 if (newTimeline->refreshRequired) {
1683 sendRefreshFrame(display, &newTimeline.value());
1684 }
ramindani431aad42022-02-01 21:44:29 +00001685 waitForVsyncPeriodChange(display.getDisplayId(), newTimeline.value(),
ramindanidcfe3a82021-11-29 17:00:31 +00001686 constraints.desiredTimeNanos, vsyncPeriod1,
1687 vsyncPeriod2);
1688 }
1689
ramindani431aad42022-02-01 21:44:29 +00001690 const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanos] =
1691 mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
1692 EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001693 EXPECT_EQ(vsyncPeriodNanos, vsyncPeriod2);
1694 });
1695 }
1696 }
1697
Ady Abraham72c5b502021-12-10 17:23:39 -08001698 void Test_expectedPresentTime(std::optional<int> framesDelay) {
Jason Macnak325e8232022-01-24 14:48:55 -08001699 if (hasCapability(Capability::PRESENT_FENCE_IS_NOT_RELIABLE)) {
1700 GTEST_SUCCEED() << "Device has unreliable present fences capability, skipping";
1701 return;
1702 }
1703
ramindani431aad42022-02-01 21:44:29 +00001704 ASSERT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001705
1706 const auto vsyncPeriod = getVsyncPeriod();
1707
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001708 const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1709 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
Ady Abraham72c5b502021-12-10 17:23:39 -08001710 ASSERT_NE(nullptr, buffer1);
1711 ASSERT_NE(nullptr, buffer2);
1712
ramindanifc93b732024-02-15 21:36:19 +00001713 const auto layer = createOnScreenLayer(getPrimaryDisplay());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001714 auto& writer = getWriter(getPrimaryDisplayId());
1715 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer1->handle,
1716 /*acquireFence*/ -1);
Ady Abraham72c5b502021-12-10 17:23:39 -08001717 const sp<::android::Fence> presentFence1 =
1718 presentAndGetFence(ComposerClientWriter::kNoTimestamp);
1719 presentFence1->waitForever(LOG_TAG);
1720
1721 auto expectedPresentTime = presentFence1->getSignalTime() + vsyncPeriod;
1722 if (framesDelay.has_value()) {
1723 expectedPresentTime += *framesDelay * vsyncPeriod;
1724 }
1725
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001726 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer2->handle,
1727 /*acquireFence*/ -1);
Ady Abraham72c5b502021-12-10 17:23:39 -08001728 const auto setExpectedPresentTime = [&]() -> std::optional<ClockMonotonicTimestamp> {
1729 if (!framesDelay.has_value()) {
1730 return ComposerClientWriter::kNoTimestamp;
1731 } else if (*framesDelay == 0) {
1732 return ClockMonotonicTimestamp{0};
1733 }
1734 return ClockMonotonicTimestamp{expectedPresentTime};
1735 }();
1736
1737 const sp<::android::Fence> presentFence2 = presentAndGetFence(setExpectedPresentTime);
1738 presentFence2->waitForever(LOG_TAG);
1739
1740 const auto actualPresentTime = presentFence2->getSignalTime();
Ady Abrahamdf084f32022-01-10 14:10:23 -08001741 EXPECT_GE(actualPresentTime, expectedPresentTime - vsyncPeriod / 2);
Ady Abraham72c5b502021-12-10 17:23:39 -08001742
ramindani431aad42022-02-01 21:44:29 +00001743 ASSERT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001744 }
1745
ramindanifc93b732024-02-15 21:36:19 +00001746 void forEachNotifyExpectedPresentConfig(
1747 std::function<void(VtsDisplay&, const DisplayConfiguration&)> func) {
1748 for (VtsDisplay& display : mDisplays) {
1749 const auto displayId = display.getDisplayId();
1750 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
1751 const auto& [status, displayConfigurations] =
1752 mComposerClient->getDisplayConfigurations(displayId);
1753 EXPECT_TRUE(status.isOk());
1754 EXPECT_FALSE(displayConfigurations.empty());
1755 for (const auto& config : displayConfigurations) {
1756 if (config.vrrConfig && config.vrrConfig->notifyExpectedPresentConfig) {
1757 const auto [vsyncPeriodStatus, oldVsyncPeriod] =
1758 mComposerClient->getDisplayVsyncPeriod(displayId);
1759 ASSERT_TRUE(vsyncPeriodStatus.isOk());
1760 const auto& [timelineStatus, timeline] =
1761 mComposerClient->setActiveConfigWithConstraints(
1762 &display, config.configId,
1763 VsyncPeriodChangeConstraints{.seamlessRequired = false});
1764 ASSERT_TRUE(timelineStatus.isOk());
1765 if (timeline.refreshRequired) {
1766 sendRefreshFrame(display, &timeline);
1767 }
1768 waitForVsyncPeriodChange(displayId, timeline, systemTime(), oldVsyncPeriod,
1769 config.vsyncPeriod);
1770 func(display, config);
1771 }
1772 }
1773 EXPECT_TRUE(
1774 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
1775 }
1776 }
1777
ramindani431aad42022-02-01 21:44:29 +00001778 void configureLayer(const VtsDisplay& display, int64_t layer, Composition composition,
1779 const Rect& displayFrame, const FRect& cropRect) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001780 auto& writer = getWriter(display.getDisplayId());
1781 writer.setLayerCompositionType(display.getDisplayId(), layer, composition);
1782 writer.setLayerDisplayFrame(display.getDisplayId(), layer, displayFrame);
1783 writer.setLayerPlaneAlpha(display.getDisplayId(), layer, /*alpha*/ 1);
1784 writer.setLayerSourceCrop(display.getDisplayId(), layer, cropRect);
1785 writer.setLayerTransform(display.getDisplayId(), layer, static_cast<Transform>(0));
1786 writer.setLayerVisibleRegion(display.getDisplayId(), layer,
1787 std::vector<Rect>(1, displayFrame));
1788 writer.setLayerZOrder(display.getDisplayId(), layer, /*z*/ 10);
1789 writer.setLayerBlendMode(display.getDisplayId(), layer, BlendMode::NONE);
1790 writer.setLayerSurfaceDamage(display.getDisplayId(), layer,
1791 std::vector<Rect>(1, displayFrame));
ramindani431aad42022-02-01 21:44:29 +00001792 }
ramindanidcfe3a82021-11-29 17:00:31 +00001793 // clang-format off
1794 const std::array<float, 16> kIdentity = {{
1795 1.0f, 0.0f, 0.0f, 0.0f,
1796 0.0f, 1.0f, 0.0f, 0.0f,
1797 0.0f, 0.0f, 1.0f, 0.0f,
1798 0.0f, 0.0f, 0.0f, 1.0f,
1799 }};
1800 // clang-format on
1801
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001802 ComposerClientWriter& getWriter(int64_t display) {
Joen Chene0a962c2023-08-28 09:49:11 +00001803 std::lock_guard guard{mWritersMutex};
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001804 auto [it, _] = mWriters.try_emplace(display, display);
1805 return it->second;
1806 }
1807
Ady Abraham91c9d1a2021-12-15 18:14:45 -08001808 ComposerClientReader mReader;
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001809
1810 private:
Joen Chene0a962c2023-08-28 09:49:11 +00001811 void executeInternal(ComposerClientWriter& writer,
1812 std::vector<CommandResultPayload>& payloads) {
1813 auto commands = writer.takePendingCommands();
1814 if (commands.empty()) {
1815 return;
1816 }
1817
1818 auto [status, results] = mComposerClient->executeCommands(commands);
1819 ASSERT_TRUE(status.isOk()) << "executeCommands failed " << status.getDescription();
1820
1821 payloads.reserve(payloads.size() + results.size());
1822 payloads.insert(payloads.end(), std::make_move_iterator(results.begin()),
1823 std::make_move_iterator(results.end()));
1824 }
1825
1826 // Guards access to the map itself. Callers must ensure not to attempt to
1827 // - modify the same writer from multiple threads
1828 // - insert a new writer into the map during concurrent access, which would invalidate
1829 // references from other threads
1830 std::mutex mWritersMutex;
1831 std::unordered_map<int64_t, ComposerClientWriter> mWriters GUARDED_BY(mWritersMutex);
ramindanidcfe3a82021-11-29 17:00:31 +00001832};
1833
ramindani431aad42022-02-01 21:44:29 +00001834TEST_P(GraphicsComposerAidlCommandTest, SetColorTransform) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001835 auto& writer = getWriter(getPrimaryDisplayId());
1836 writer.setColorTransform(getPrimaryDisplayId(), kIdentity.data());
ramindanidcfe3a82021-11-29 17:00:31 +00001837 execute();
1838}
1839
1840TEST_P(GraphicsComposerAidlCommandTest, SetLayerColorTransform) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001841 auto& writer = getWriter(getPrimaryDisplayId());
Ady Abrahama00d2462023-12-26 14:21:20 -08001842 const auto& [status, layer] =
1843 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
1844 EXPECT_TRUE(status.isOk());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001845 writer.setLayerColorTransform(getPrimaryDisplayId(), layer, kIdentity.data());
ramindanidcfe3a82021-11-29 17:00:31 +00001846 execute();
1847
Ady Abraham3192f3d2021-12-03 16:08:56 -08001848 const auto errors = mReader.takeErrors();
Jason Macnak062bc9a2022-01-20 15:00:09 -08001849 if (errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_UNSUPPORTED) {
ramindanidcfe3a82021-11-29 17:00:31 +00001850 GTEST_SUCCEED() << "setLayerColorTransform is not supported";
1851 return;
1852 }
1853}
1854
Alec Mouri60564e12021-12-09 18:48:20 -08001855TEST_P(GraphicsComposerAidlCommandTest, SetDisplayBrightness) {
Peter Linb9fbd4e2023-12-14 05:43:25 +00001856 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
ramindani431aad42022-02-01 21:44:29 +00001857 const auto& [status, capabilities] =
1858 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
1859 ASSERT_TRUE(status.isOk());
Alec Mouri60564e12021-12-09 18:48:20 -08001860 bool brightnessSupport = std::find(capabilities.begin(), capabilities.end(),
1861 DisplayCapability::BRIGHTNESS) != capabilities.end();
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001862 auto& writer = getWriter(getPrimaryDisplayId());
Alec Mouri60564e12021-12-09 18:48:20 -08001863 if (!brightnessSupport) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001864 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.5f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001865 execute();
1866 const auto errors = mReader.takeErrors();
Liu, Kai16adbf0c2024-05-15 14:58:43 +08001867 ASSERT_EQ(1, errors.size());
Jason Macnak062bc9a2022-01-20 15:00:09 -08001868 EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, errors[0].errorCode);
Alec Mouri60564e12021-12-09 18:48:20 -08001869 GTEST_SUCCEED() << "SetDisplayBrightness is not supported";
1870 return;
1871 }
1872
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001873 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001874 execute();
1875 EXPECT_TRUE(mReader.takeErrors().empty());
1876
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001877 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.5f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001878 execute();
1879 EXPECT_TRUE(mReader.takeErrors().empty());
1880
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001881 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 1.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001882 execute();
1883 EXPECT_TRUE(mReader.takeErrors().empty());
1884
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001885 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ -1.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001886 execute();
1887 EXPECT_TRUE(mReader.takeErrors().empty());
1888
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001889 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 2.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001890 execute();
1891 {
1892 const auto errors = mReader.takeErrors();
ramindanib3bdf052022-01-12 18:27:05 +00001893 ASSERT_EQ(1, errors.size());
Alec Mouri60564e12021-12-09 18:48:20 -08001894 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
1895 }
1896
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001897 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ -2.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001898 execute();
1899 {
1900 const auto errors = mReader.takeErrors();
ramindanib3bdf052022-01-12 18:27:05 +00001901 ASSERT_EQ(1, errors.size());
Alec Mouri60564e12021-12-09 18:48:20 -08001902 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
1903 }
1904}
1905
ramindani431aad42022-02-01 21:44:29 +00001906TEST_P(GraphicsComposerAidlCommandTest, SetClientTarget) {
1907 EXPECT_TRUE(mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kBufferSlotCount)
1908 .isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001909
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001910 auto& writer = getWriter(getPrimaryDisplayId());
1911 writer.setClientTarget(getPrimaryDisplayId(), /*slot*/ 0, nullptr, /*acquireFence*/ -1,
Alec Mouri8062f1f2023-09-06 02:14:47 +00001912 Dataspace::UNKNOWN, std::vector<Rect>(), 1.0f);
ramindanidcfe3a82021-11-29 17:00:31 +00001913
1914 execute();
1915}
1916
ramindani431aad42022-02-01 21:44:29 +00001917TEST_P(GraphicsComposerAidlCommandTest, SetOutputBuffer) {
1918 const auto& [status, virtualDisplayCount] = mComposerClient->getMaxVirtualDisplayCount();
1919 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001920 if (virtualDisplayCount == 0) {
1921 GTEST_SUCCEED() << "no virtual display support";
1922 return;
1923 }
1924
ramindani431aad42022-02-01 21:44:29 +00001925 const auto& [displayStatus, display] = mComposerClient->createVirtualDisplay(
1926 /*width*/ 64, /*height*/ 64, common::PixelFormat::IMPLEMENTATION_DEFINED,
1927 kBufferSlotCount);
1928 EXPECT_TRUE(displayStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001929
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001930 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001931 const auto handle = buffer->handle;
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001932 auto& writer = getWriter(display.display);
1933 writer.setOutputBuffer(display.display, /*slot*/ 0, handle, /*releaseFence*/ -1);
ramindanidcfe3a82021-11-29 17:00:31 +00001934 execute();
1935}
1936
ramindani431aad42022-02-01 21:44:29 +00001937TEST_P(GraphicsComposerAidlCommandTest, ValidDisplay) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001938 auto& writer = getWriter(getPrimaryDisplayId());
ramindanicdcfcaf2023-11-09 10:00:10 -08001939 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
1940 VtsComposerClient::kNoFrameIntervalNs);
ramindanidcfe3a82021-11-29 17:00:31 +00001941 execute();
1942}
1943
ramindani431aad42022-02-01 21:44:29 +00001944TEST_P(GraphicsComposerAidlCommandTest, AcceptDisplayChanges) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001945 auto& writer = getWriter(getPrimaryDisplayId());
ramindanicdcfcaf2023-11-09 10:00:10 -08001946 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
1947 VtsComposerClient::kNoFrameIntervalNs);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001948 writer.acceptDisplayChanges(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001949 execute();
1950}
1951
ramindani431aad42022-02-01 21:44:29 +00001952TEST_P(GraphicsComposerAidlCommandTest, PresentDisplay) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001953 auto& writer = getWriter(getPrimaryDisplayId());
ramindanicdcfcaf2023-11-09 10:00:10 -08001954 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
1955 VtsComposerClient::kNoFrameIntervalNs);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001956 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001957 execute();
1958}
1959
1960/**
1961 * Test IComposerClient::Command::PRESENT_DISPLAY
1962 *
1963 * Test that IComposerClient::Command::PRESENT_DISPLAY works without
1964 * additional call to validateDisplay when only the layer buffer handle and
1965 * surface damage have been set
1966 */
ramindani431aad42022-02-01 21:44:29 +00001967TEST_P(GraphicsComposerAidlCommandTest, PresentDisplayNoLayerStateChanges) {
ramindani431aad42022-02-01 21:44:29 +00001968 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001969
ramindani431aad42022-02-01 21:44:29 +00001970 const auto& [renderIntentsStatus, renderIntents] =
1971 mComposerClient->getRenderIntents(getPrimaryDisplayId(), ColorMode::NATIVE);
1972 EXPECT_TRUE(renderIntentsStatus.isOk());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001973 auto& writer = getWriter(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001974 for (auto intent : renderIntents) {
ramindani431aad42022-02-01 21:44:29 +00001975 EXPECT_TRUE(mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE, intent)
1976 .isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001977
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001978 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001979 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001980 ASSERT_NE(nullptr, handle);
1981
ramindani431aad42022-02-01 21:44:29 +00001982 const auto& [layerStatus, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08001983 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
ramindani431aad42022-02-01 21:44:29 +00001984 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001985
ramindani431aad42022-02-01 21:44:29 +00001986 Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
1987 getPrimaryDisplay().getDisplayHeight()};
1988 FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
1989 (float)getPrimaryDisplay().getDisplayHeight()};
1990 configureLayer(getPrimaryDisplay(), layer, Composition::CURSOR, displayFrame, cropRect);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001991 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle,
1992 /*acquireFence*/ -1);
1993 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
ramindanicdcfcaf2023-11-09 10:00:10 -08001994 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
1995 VtsComposerClient::kNoFrameIntervalNs);
ramindanidcfe3a82021-11-29 17:00:31 +00001996 execute();
ramindani431aad42022-02-01 21:44:29 +00001997 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
ramindanidcfe3a82021-11-29 17:00:31 +00001998 GTEST_SUCCEED() << "Composition change requested, skipping test";
1999 return;
2000 }
2001
Ady Abraham3192f3d2021-12-03 16:08:56 -08002002 ASSERT_TRUE(mReader.takeErrors().empty());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002003 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00002004 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002005 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002006
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002007 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00002008 const auto handle2 = buffer2->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00002009 ASSERT_NE(nullptr, handle2);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002010 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle2,
2011 /*acquireFence*/ -1);
2012 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer,
2013 std::vector<Rect>(1, {0, 0, 10, 10}));
2014 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00002015 execute();
2016 }
2017}
2018
ramindani431aad42022-02-01 21:44:29 +00002019TEST_P(GraphicsComposerAidlCommandTest, SetLayerCursorPosition) {
Ady Abrahama00d2462023-12-26 14:21:20 -08002020 auto& writer = getWriter(getPrimaryDisplayId());
ramindani431aad42022-02-01 21:44:29 +00002021 const auto& [layerStatus, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08002022 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
ramindani431aad42022-02-01 21:44:29 +00002023 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002024
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002025 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00002026 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00002027 ASSERT_NE(nullptr, handle);
ramindanidcfe3a82021-11-29 17:00:31 +00002028
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002029 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle, /*acquireFence*/ -1);
ramindani431aad42022-02-01 21:44:29 +00002030
2031 Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
2032 getPrimaryDisplay().getDisplayHeight()};
2033 FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
2034 (float)getPrimaryDisplay().getDisplayHeight()};
2035 configureLayer(getPrimaryDisplay(), layer, Composition::CURSOR, displayFrame, cropRect);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002036 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
ramindanicdcfcaf2023-11-09 10:00:10 -08002037 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
2038 VtsComposerClient::kNoFrameIntervalNs);
ramindanidcfe3a82021-11-29 17:00:31 +00002039
2040 execute();
Ady Abraham46219f52021-12-20 09:44:31 -08002041
ramindani431aad42022-02-01 21:44:29 +00002042 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
ramindanidcfe3a82021-11-29 17:00:31 +00002043 GTEST_SUCCEED() << "Composition change requested, skipping test";
2044 return;
2045 }
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002046 writer.presentDisplay(getPrimaryDisplayId());
Ady Abraham3192f3d2021-12-03 16:08:56 -08002047 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002048
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002049 writer.setLayerCursorPosition(getPrimaryDisplayId(), layer, /*x*/ 1, /*y*/ 1);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002050 execute();
2051
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002052 writer.setLayerCursorPosition(getPrimaryDisplayId(), layer, /*x*/ 0, /*y*/ 0);
ramindanicdcfcaf2023-11-09 10:00:10 -08002053 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
2054 VtsComposerClient::kNoFrameIntervalNs);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002055 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00002056 execute();
2057}
2058
ramindani431aad42022-02-01 21:44:29 +00002059TEST_P(GraphicsComposerAidlCommandTest, SetLayerBuffer) {
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002060 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00002061 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00002062 ASSERT_NE(nullptr, handle);
2063
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002064 auto& writer = getWriter(getPrimaryDisplayId());
Ady Abrahama00d2462023-12-26 14:21:20 -08002065 const auto& [layerStatus, layer] =
2066 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
2067 EXPECT_TRUE(layerStatus.isOk());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002068 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle, /*acquireFence*/ -1);
ramindanidcfe3a82021-11-29 17:00:31 +00002069 execute();
Brian Lindahl9f9d2f02024-10-24 16:23:57 -06002070 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002071}
2072
Brian Lindahl25e0d092022-12-09 00:32:11 -07002073TEST_P(GraphicsComposerAidlCommandTest, SetLayerBufferMultipleTimes) {
Brian Lindahl25e0d092022-12-09 00:32:11 -07002074 auto& writer = getWriter(getPrimaryDisplayId());
Ady Abrahama00d2462023-12-26 14:21:20 -08002075 const auto& [layerStatus, layer] =
2076 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
2077 EXPECT_TRUE(layerStatus.isOk());
Brian Lindahl25e0d092022-12-09 00:32:11 -07002078
2079 // Setup 3 buffers in the buffer cache, with the last buffer being active. Then, emulate the
2080 // Android platform code that clears all 3 buffer slots by setting all but the active buffer
2081 // slot to a placeholder buffer, and then restoring the active buffer.
2082
2083 // This is used on HALs that don't support setLayerBufferSlotsToClear (version <= 3.1).
2084
2085 const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2086 ASSERT_NE(nullptr, buffer1);
2087 const auto handle1 = buffer1->handle;
2088 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle1, /*acquireFence*/ -1);
2089 execute();
2090 ASSERT_TRUE(mReader.takeErrors().empty());
2091
2092 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2093 ASSERT_NE(nullptr, buffer2);
2094 const auto handle2 = buffer2->handle;
2095 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 1, handle2, /*acquireFence*/ -1);
2096 execute();
2097 ASSERT_TRUE(mReader.takeErrors().empty());
2098
2099 const auto buffer3 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2100 ASSERT_NE(nullptr, buffer3);
2101 const auto handle3 = buffer3->handle;
2102 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 2, handle3, /*acquireFence*/ -1);
2103 execute();
2104 ASSERT_TRUE(mReader.takeErrors().empty());
2105
2106 // Older versions of the HAL clear all but the active buffer slot with a placeholder buffer,
2107 // and then restoring the current active buffer at the end
2108 auto clearSlotBuffer = allocate(1u, 1u, ::android::PIXEL_FORMAT_RGB_888);
2109 ASSERT_NE(nullptr, clearSlotBuffer);
2110 auto clearSlotBufferHandle = clearSlotBuffer->handle;
2111
2112 // clear buffer slots 0 and 1 with new layer commands... and then...
2113 writer.setLayerBufferWithNewCommand(getPrimaryDisplayId(), layer, /* slot */ 0,
2114 clearSlotBufferHandle, /*acquireFence*/ -1);
2115 writer.setLayerBufferWithNewCommand(getPrimaryDisplayId(), layer, /* slot */ 1,
2116 clearSlotBufferHandle, /*acquireFence*/ -1);
2117 // ...reset the layer buffer to the current active buffer slot with a final new command
2118 writer.setLayerBufferWithNewCommand(getPrimaryDisplayId(), layer, /*slot*/ 2, nullptr,
2119 /*acquireFence*/ -1);
2120 execute();
2121 ASSERT_TRUE(mReader.takeErrors().empty());
2122}
2123
ramindani431aad42022-02-01 21:44:29 +00002124TEST_P(GraphicsComposerAidlCommandTest, SetLayerSurfaceDamage) {
Ady Abrahama00d2462023-12-26 14:21:20 -08002125 auto& writer = getWriter(getPrimaryDisplayId());
ramindani431aad42022-02-01 21:44:29 +00002126 const auto& [layerStatus, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08002127 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
ramindani431aad42022-02-01 21:44:29 +00002128 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002129
2130 Rect empty{0, 0, 0, 0};
2131 Rect unit{0, 0, 1, 1};
2132
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002133 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
ramindanidcfe3a82021-11-29 17:00:31 +00002134 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002135 ASSERT_TRUE(mReader.takeErrors().empty());
2136
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002137 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
Ady Abraham3192f3d2021-12-03 16:08:56 -08002138 execute();
2139 ASSERT_TRUE(mReader.takeErrors().empty());
2140
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002141 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>());
Ady Abraham3192f3d2021-12-03 16:08:56 -08002142 execute();
2143 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002144}
2145
ramindani431aad42022-02-01 21:44:29 +00002146TEST_P(GraphicsComposerAidlCommandTest, SetLayerBlockingRegion) {
Ady Abrahama00d2462023-12-26 14:21:20 -08002147 auto& writer = getWriter(getPrimaryDisplayId());
ramindani431aad42022-02-01 21:44:29 +00002148 const auto& [layerStatus, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08002149 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
ramindani431aad42022-02-01 21:44:29 +00002150 EXPECT_TRUE(layerStatus.isOk());
Leon Scroggins III03318152022-01-13 12:24:19 -05002151
2152 Rect empty{0, 0, 0, 0};
2153 Rect unit{0, 0, 1, 1};
2154
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002155 writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
Leon Scroggins III03318152022-01-13 12:24:19 -05002156 execute();
2157 ASSERT_TRUE(mReader.takeErrors().empty());
2158
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002159 writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
Leon Scroggins III03318152022-01-13 12:24:19 -05002160 execute();
2161 ASSERT_TRUE(mReader.takeErrors().empty());
2162
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002163 writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>());
Leon Scroggins III03318152022-01-13 12:24:19 -05002164 execute();
2165 ASSERT_TRUE(mReader.takeErrors().empty());
2166}
2167
ramindani431aad42022-02-01 21:44:29 +00002168TEST_P(GraphicsComposerAidlCommandTest, SetLayerBlendMode) {
Ady Abrahama00d2462023-12-26 14:21:20 -08002169 auto& writer = getWriter(getPrimaryDisplayId());
ramindani431aad42022-02-01 21:44:29 +00002170 const auto& [layerStatus, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08002171 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
ramindani431aad42022-02-01 21:44:29 +00002172 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002173
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002174 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::NONE);
ramindanidcfe3a82021-11-29 17:00:31 +00002175 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002176 ASSERT_TRUE(mReader.takeErrors().empty());
2177
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002178 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::PREMULTIPLIED);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002179 execute();
2180 ASSERT_TRUE(mReader.takeErrors().empty());
2181
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002182 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::COVERAGE);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002183 execute();
2184 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002185}
2186
ramindani431aad42022-02-01 21:44:29 +00002187TEST_P(GraphicsComposerAidlCommandTest, SetLayerColor) {
Ady Abrahama00d2462023-12-26 14:21:20 -08002188 auto& writer = getWriter(getPrimaryDisplayId());
ramindani431aad42022-02-01 21:44:29 +00002189 const auto& [layerStatus, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08002190 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
ramindani431aad42022-02-01 21:44:29 +00002191 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002192
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002193 writer.setLayerColor(getPrimaryDisplayId(), layer, Color{1.0f, 1.0f, 1.0f, 1.0f});
ramindanidcfe3a82021-11-29 17:00:31 +00002194 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002195 ASSERT_TRUE(mReader.takeErrors().empty());
2196
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002197 writer.setLayerColor(getPrimaryDisplayId(), layer, Color{0.0f, 0.0f, 0.0f, 0.0f});
Ady Abraham3192f3d2021-12-03 16:08:56 -08002198 execute();
2199 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002200}
2201
ramindani431aad42022-02-01 21:44:29 +00002202TEST_P(GraphicsComposerAidlCommandTest, SetLayerCompositionType) {
Ady Abrahama00d2462023-12-26 14:21:20 -08002203 auto& writer = getWriter(getPrimaryDisplayId());
ramindani431aad42022-02-01 21:44:29 +00002204 const auto& [layerStatus, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08002205 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
ramindani431aad42022-02-01 21:44:29 +00002206 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002207
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002208 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::CLIENT);
ramindanidcfe3a82021-11-29 17:00:31 +00002209 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002210 ASSERT_TRUE(mReader.takeErrors().empty());
2211
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002212 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::DEVICE);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002213 execute();
2214 ASSERT_TRUE(mReader.takeErrors().empty());
2215
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002216 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::SOLID_COLOR);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002217 execute();
2218 ASSERT_TRUE(mReader.takeErrors().empty());
2219
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002220 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::CURSOR);
ramindani431aad42022-02-01 21:44:29 +00002221 execute();
2222}
2223
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002224TEST_P(GraphicsComposerAidlCommandTest, DisplayDecoration) {
2225 for (VtsDisplay& display : mDisplays) {
Leon Scroggins IIIc2a83d42024-04-17 14:40:29 -04002226 const auto displayId = display.getDisplayId();
2227 auto& writer = getWriter(displayId);
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002228 const auto [layerStatus, layer] =
Leon Scroggins IIIc2a83d42024-04-17 14:40:29 -04002229 mComposerClient->createLayer(displayId, kBufferSlotCount, &writer);
2230 ASSERT_TRUE(layerStatus.isOk());
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002231
Leon Scroggins IIIc2a83d42024-04-17 14:40:29 -04002232 const auto [error, support] = mComposerClient->getDisplayDecorationSupport(displayId);
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002233
Leon Scroggins III91590872022-02-23 09:51:21 -05002234 const auto format = (error.isOk() && support) ? support->format
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002235 : aidl::android::hardware::graphics::common::PixelFormat::RGBA_8888;
2236 const auto decorBuffer = allocate(static_cast<::android::PixelFormat>(format));
2237 ASSERT_NE(nullptr, decorBuffer);
2238 if (::android::OK != decorBuffer->initCheck()) {
2239 if (support) {
2240 FAIL() << "Device advertised display decoration support with format "
2241 << aidl::android::hardware::graphics::common::toString(format)
2242 << " but failed to allocate it!";
2243 } else {
2244 FAIL() << "Device advertised NO display decoration support, but it should "
2245 << "still be able to allocate "
2246 << aidl::android::hardware::graphics::common::toString(format);
2247 }
2248 }
2249
Midas Chien7d55d422022-06-07 02:32:28 +08002250 configureLayer(display, layer, Composition::DISPLAY_DECORATION, display.getFrameRect(),
Ady Abrahama00d2462023-12-26 14:21:20 -08002251 display.getCrop());
Leon Scroggins IIIc2a83d42024-04-17 14:40:29 -04002252 writer.setLayerBuffer(displayId, layer, /*slot*/ 0, decorBuffer->handle,
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002253 /*acquireFence*/ -1);
Leon Scroggins IIIc2a83d42024-04-17 14:40:29 -04002254 writer.validateDisplay(displayId, ComposerClientWriter::kNoTimestamp,
ramindanicdcfcaf2023-11-09 10:00:10 -08002255 VtsComposerClient::kNoFrameIntervalNs);
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002256 execute();
2257 if (support) {
2258 ASSERT_TRUE(mReader.takeErrors().empty());
2259 } else {
2260 const auto errors = mReader.takeErrors();
2261 ASSERT_EQ(1, errors.size());
Leon Scroggins III6455e792022-02-24 12:18:58 -05002262 EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, errors[0].errorCode);
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002263 }
Leon Scroggins IIIc2a83d42024-04-17 14:40:29 -04002264 EXPECT_TRUE(mComposerClient->destroyLayer(displayId, layer, &writer).isOk());
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002265 }
2266}
2267
ramindani431aad42022-02-01 21:44:29 +00002268TEST_P(GraphicsComposerAidlCommandTest, SetLayerDataspace) {
Ady Abrahama00d2462023-12-26 14:21:20 -08002269 auto& writer = getWriter(getPrimaryDisplayId());
ramindani431aad42022-02-01 21:44:29 +00002270 const auto& [layerStatus, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08002271 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
ramindani431aad42022-02-01 21:44:29 +00002272 EXPECT_TRUE(layerStatus.isOk());
2273
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002274 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
ramindani431aad42022-02-01 21:44:29 +00002275 execute();
2276}
2277
2278TEST_P(GraphicsComposerAidlCommandTest, SetLayerDisplayFrame) {
Ady Abrahama00d2462023-12-26 14:21:20 -08002279 auto& writer = getWriter(getPrimaryDisplayId());
ramindani431aad42022-02-01 21:44:29 +00002280 const auto& [layerStatus, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08002281 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
ramindani431aad42022-02-01 21:44:29 +00002282 EXPECT_TRUE(layerStatus.isOk());
2283
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002284 writer.setLayerDisplayFrame(getPrimaryDisplayId(), layer, Rect{0, 0, 1, 1});
ramindani431aad42022-02-01 21:44:29 +00002285 execute();
2286}
2287
2288TEST_P(GraphicsComposerAidlCommandTest, SetLayerPlaneAlpha) {
Ady Abrahama00d2462023-12-26 14:21:20 -08002289 auto& writer = getWriter(getPrimaryDisplayId());
ramindani431aad42022-02-01 21:44:29 +00002290 const auto& [layerStatus, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08002291 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
ramindani431aad42022-02-01 21:44:29 +00002292 EXPECT_TRUE(layerStatus.isOk());
2293
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002294 writer.setLayerPlaneAlpha(getPrimaryDisplayId(), layer, /*alpha*/ 0.0f);
ramindani431aad42022-02-01 21:44:29 +00002295 execute();
2296 ASSERT_TRUE(mReader.takeErrors().empty());
2297
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002298 writer.setLayerPlaneAlpha(getPrimaryDisplayId(), layer, /*alpha*/ 1.0f);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002299 execute();
2300 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002301}
2302
ramindani431aad42022-02-01 21:44:29 +00002303TEST_P(GraphicsComposerAidlCommandTest, SetLayerSidebandStream) {
Jason Macnak325e8232022-01-24 14:48:55 -08002304 if (!hasCapability(Capability::SIDEBAND_STREAM)) {
ramindanidcfe3a82021-11-29 17:00:31 +00002305 GTEST_SUCCEED() << "no sideband stream support";
2306 return;
2307 }
2308
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002309 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00002310 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00002311 ASSERT_NE(nullptr, handle);
2312
Ady Abrahama00d2462023-12-26 14:21:20 -08002313 auto& writer = getWriter(getPrimaryDisplayId());
ramindani431aad42022-02-01 21:44:29 +00002314 const auto& [layerStatus, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08002315 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
ramindani431aad42022-02-01 21:44:29 +00002316 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002317
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002318 writer.setLayerSidebandStream(getPrimaryDisplayId(), layer, handle);
ramindanidcfe3a82021-11-29 17:00:31 +00002319 execute();
2320}
2321
ramindani431aad42022-02-01 21:44:29 +00002322TEST_P(GraphicsComposerAidlCommandTest, SetLayerSourceCrop) {
Ady Abrahama00d2462023-12-26 14:21:20 -08002323 auto& writer = getWriter(getPrimaryDisplayId());
ramindani431aad42022-02-01 21:44:29 +00002324 const auto& [layerStatus, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08002325 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
ramindani431aad42022-02-01 21:44:29 +00002326 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002327
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002328 writer.setLayerSourceCrop(getPrimaryDisplayId(), layer, FRect{0.0f, 0.0f, 1.0f, 1.0f});
ramindanidcfe3a82021-11-29 17:00:31 +00002329 execute();
2330}
2331
ramindani431aad42022-02-01 21:44:29 +00002332TEST_P(GraphicsComposerAidlCommandTest, SetLayerTransform) {
Ady Abrahama00d2462023-12-26 14:21:20 -08002333 auto& writer = getWriter(getPrimaryDisplayId());
ramindani431aad42022-02-01 21:44:29 +00002334 const auto& [layerStatus, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08002335 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
ramindani431aad42022-02-01 21:44:29 +00002336 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002337
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002338 writer.setLayerTransform(getPrimaryDisplayId(), layer, static_cast<Transform>(0));
ramindanidcfe3a82021-11-29 17:00:31 +00002339 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002340 ASSERT_TRUE(mReader.takeErrors().empty());
2341
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002342 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::FLIP_H);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002343 execute();
2344 ASSERT_TRUE(mReader.takeErrors().empty());
2345
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002346 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::FLIP_V);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002347 execute();
2348 ASSERT_TRUE(mReader.takeErrors().empty());
2349
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002350 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_90);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002351 execute();
2352 ASSERT_TRUE(mReader.takeErrors().empty());
2353
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002354 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_180);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002355 execute();
2356 ASSERT_TRUE(mReader.takeErrors().empty());
2357
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002358 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_270);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002359 execute();
2360 ASSERT_TRUE(mReader.takeErrors().empty());
2361
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002362 writer.setLayerTransform(getPrimaryDisplayId(), layer,
2363 static_cast<Transform>(static_cast<int>(Transform::FLIP_H) |
2364 static_cast<int>(Transform::ROT_90)));
Ady Abraham3192f3d2021-12-03 16:08:56 -08002365 execute();
2366 ASSERT_TRUE(mReader.takeErrors().empty());
2367
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002368 writer.setLayerTransform(getPrimaryDisplayId(), layer,
2369 static_cast<Transform>(static_cast<int>(Transform::FLIP_V) |
2370 static_cast<int>(Transform::ROT_90)));
Ady Abraham3192f3d2021-12-03 16:08:56 -08002371 execute();
2372 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002373}
2374
ramindani431aad42022-02-01 21:44:29 +00002375TEST_P(GraphicsComposerAidlCommandTest, SetLayerVisibleRegion) {
Ady Abrahama00d2462023-12-26 14:21:20 -08002376 auto& writer = getWriter(getPrimaryDisplayId());
ramindani431aad42022-02-01 21:44:29 +00002377 const auto& [layerStatus, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08002378 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
ramindani431aad42022-02-01 21:44:29 +00002379 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002380
2381 Rect empty{0, 0, 0, 0};
2382 Rect unit{0, 0, 1, 1};
2383
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002384 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
ramindanidcfe3a82021-11-29 17:00:31 +00002385 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002386 ASSERT_TRUE(mReader.takeErrors().empty());
2387
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002388 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
Ady Abraham3192f3d2021-12-03 16:08:56 -08002389 execute();
2390 ASSERT_TRUE(mReader.takeErrors().empty());
2391
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002392 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>());
Ady Abraham3192f3d2021-12-03 16:08:56 -08002393 execute();
2394 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002395}
2396
ramindani431aad42022-02-01 21:44:29 +00002397TEST_P(GraphicsComposerAidlCommandTest, SetLayerZOrder) {
Ady Abrahama00d2462023-12-26 14:21:20 -08002398 auto& writer = getWriter(getPrimaryDisplayId());
2399
ramindani431aad42022-02-01 21:44:29 +00002400 const auto& [layerStatus, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08002401 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
ramindani431aad42022-02-01 21:44:29 +00002402 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002403
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002404 writer.setLayerZOrder(getPrimaryDisplayId(), layer, /*z*/ 10);
ramindanidcfe3a82021-11-29 17:00:31 +00002405 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002406 ASSERT_TRUE(mReader.takeErrors().empty());
2407
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002408 writer.setLayerZOrder(getPrimaryDisplayId(), layer, /*z*/ 0);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002409 execute();
2410 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002411}
2412
ramindani431aad42022-02-01 21:44:29 +00002413TEST_P(GraphicsComposerAidlCommandTest, SetLayerPerFrameMetadata) {
Ady Abrahama00d2462023-12-26 14:21:20 -08002414 auto& writer = getWriter(getPrimaryDisplayId());
ramindani431aad42022-02-01 21:44:29 +00002415 const auto& [layerStatus, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08002416 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
ramindani431aad42022-02-01 21:44:29 +00002417 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002418
ramindanidcfe3a82021-11-29 17:00:31 +00002419 /**
2420 * DISPLAY_P3 is a color space that uses the DCI_P3 primaries,
2421 * the D65 white point and the SRGB transfer functions.
2422 * Rendering Intent: Colorimetric
2423 * Primaries:
2424 * x y
2425 * green 0.265 0.690
2426 * blue 0.150 0.060
2427 * red 0.680 0.320
2428 * white (D65) 0.3127 0.3290
2429 */
2430
2431 std::vector<PerFrameMetadata> aidlMetadata;
2432 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X, 0.680f});
2433 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y, 0.320f});
2434 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X, 0.265f});
2435 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y, 0.690f});
2436 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X, 0.150f});
2437 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y, 0.060f});
2438 aidlMetadata.push_back({PerFrameMetadataKey::WHITE_POINT_X, 0.3127f});
2439 aidlMetadata.push_back({PerFrameMetadataKey::WHITE_POINT_Y, 0.3290f});
2440 aidlMetadata.push_back({PerFrameMetadataKey::MAX_LUMINANCE, 100.0f});
2441 aidlMetadata.push_back({PerFrameMetadataKey::MIN_LUMINANCE, 0.1f});
2442 aidlMetadata.push_back({PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL, 78.0});
2443 aidlMetadata.push_back({PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL, 62.0});
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002444 writer.setLayerPerFrameMetadata(getPrimaryDisplayId(), layer, aidlMetadata);
ramindanidcfe3a82021-11-29 17:00:31 +00002445 execute();
2446
Ady Abraham3192f3d2021-12-03 16:08:56 -08002447 const auto errors = mReader.takeErrors();
2448 if (errors.size() == 1 && errors[0].errorCode == EX_UNSUPPORTED_OPERATION) {
ramindanidcfe3a82021-11-29 17:00:31 +00002449 GTEST_SUCCEED() << "SetLayerPerFrameMetadata is not supported";
Ady Abrahama00d2462023-12-26 14:21:20 -08002450 EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer, &writer).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002451 return;
2452 }
2453
Ady Abrahama00d2462023-12-26 14:21:20 -08002454 EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer, &writer).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002455}
2456
Alec Mourib1f16722022-02-07 13:03:44 -08002457TEST_P(GraphicsComposerAidlCommandTest, setLayerBrightness) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002458 auto& writer = getWriter(getPrimaryDisplayId());
Ady Abrahama00d2462023-12-26 14:21:20 -08002459
2460 const auto& [layerStatus, layer] =
2461 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
2462
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002463 writer.setLayerBrightness(getPrimaryDisplayId(), layer, 0.2f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002464 execute();
2465 ASSERT_TRUE(mReader.takeErrors().empty());
2466
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002467 writer.setLayerBrightness(getPrimaryDisplayId(), layer, 1.f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002468 execute();
2469 ASSERT_TRUE(mReader.takeErrors().empty());
2470
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002471 writer.setLayerBrightness(getPrimaryDisplayId(), layer, 0.f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002472 execute();
2473 ASSERT_TRUE(mReader.takeErrors().empty());
2474
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002475 writer.setLayerBrightness(getPrimaryDisplayId(), layer, -1.f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002476 execute();
Alec Mourib1f16722022-02-07 13:03:44 -08002477 {
2478 const auto errors = mReader.takeErrors();
2479 ASSERT_EQ(1, errors.size());
2480 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
2481 }
2482
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002483 writer.setLayerBrightness(getPrimaryDisplayId(), layer, std::nanf(""));
Alec Mourib1f16722022-02-07 13:03:44 -08002484 execute();
2485 {
2486 const auto errors = mReader.takeErrors();
2487 ASSERT_EQ(1, errors.size());
2488 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
2489 }
Alec Mouri95e490b2022-01-06 13:46:58 -08002490}
2491
ramindani431aad42022-02-01 21:44:29 +00002492TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints) {
ramindanidcfe3a82021-11-29 17:00:31 +00002493 Test_setActiveConfigWithConstraints({.delayForChange = 0, .refreshMiss = false});
2494}
2495
ramindani431aad42022-02-01 21:44:29 +00002496TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_Delayed) {
ramindanidcfe3a82021-11-29 17:00:31 +00002497 Test_setActiveConfigWithConstraints({.delayForChange = 300'000'000, // 300ms
2498 .refreshMiss = false});
2499}
2500
ramindani431aad42022-02-01 21:44:29 +00002501TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_MissRefresh) {
ramindanidcfe3a82021-11-29 17:00:31 +00002502 Test_setActiveConfigWithConstraints({.delayForChange = 0, .refreshMiss = true});
2503}
2504
ramindani431aad42022-02-01 21:44:29 +00002505TEST_P(GraphicsComposerAidlCommandTest, GetDisplayVsyncPeriod) {
ramindanidcfe3a82021-11-29 17:00:31 +00002506 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +00002507 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
2508 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002509
ramindani431aad42022-02-01 21:44:29 +00002510 for (int32_t config : configs) {
2511 int32_t expectedVsyncPeriodNanos = display.getDisplayConfig(config).vsyncPeriod;
2512
ramindanidcfe3a82021-11-29 17:00:31 +00002513 VsyncPeriodChangeConstraints constraints;
2514
2515 constraints.desiredTimeNanos = systemTime();
2516 constraints.seamlessRequired = false;
ramindani431aad42022-02-01 21:44:29 +00002517
2518 const auto& [timelineStatus, timeline] =
2519 mComposerClient->setActiveConfigWithConstraints(&display, config, constraints);
2520 EXPECT_TRUE(timelineStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002521
2522 if (timeline.refreshRequired) {
2523 sendRefreshFrame(display, &timeline);
2524 }
ramindani431aad42022-02-01 21:44:29 +00002525 waitForVsyncPeriodChange(display.getDisplayId(), timeline, constraints.desiredTimeNanos,
2526 /*odPeriodNanos*/ 0, expectedVsyncPeriodNanos);
ramindanidcfe3a82021-11-29 17:00:31 +00002527
2528 int32_t vsyncPeriodNanos;
2529 int retryCount = 100;
2530 do {
2531 std::this_thread::sleep_for(10ms);
ramindani431aad42022-02-01 21:44:29 +00002532 const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanosValue] =
2533 mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
2534
2535 EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
2536 vsyncPeriodNanos = vsyncPeriodNanosValue;
ramindanidcfe3a82021-11-29 17:00:31 +00002537 --retryCount;
2538 } while (vsyncPeriodNanos != expectedVsyncPeriodNanos && retryCount > 0);
2539
2540 EXPECT_EQ(vsyncPeriodNanos, expectedVsyncPeriodNanos);
2541
2542 // Make sure that the vsync period stays the same if the active config is not
2543 // changed.
2544 auto timeout = 1ms;
2545 for (int i = 0; i < 10; i++) {
2546 std::this_thread::sleep_for(timeout);
2547 timeout *= 2;
2548 vsyncPeriodNanos = 0;
ramindani431aad42022-02-01 21:44:29 +00002549 const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanosValue] =
2550 mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
2551
2552 EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
2553 vsyncPeriodNanos = vsyncPeriodNanosValue;
ramindanidcfe3a82021-11-29 17:00:31 +00002554 EXPECT_EQ(vsyncPeriodNanos, expectedVsyncPeriodNanos);
2555 }
2556 }
2557 }
2558}
2559
ramindani431aad42022-02-01 21:44:29 +00002560TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_SeamlessNotAllowed) {
ramindanidcfe3a82021-11-29 17:00:31 +00002561 VsyncPeriodChangeConstraints constraints;
ramindanidcfe3a82021-11-29 17:00:31 +00002562 constraints.seamlessRequired = true;
2563 constraints.desiredTimeNanos = systemTime();
2564
2565 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +00002566 forEachTwoConfigs(display.getDisplayId(), [&](int32_t config1, int32_t config2) {
2567 int32_t configGroup1 = display.getDisplayConfig(config1).configGroup;
2568 int32_t configGroup2 = display.getDisplayConfig(config2).configGroup;
ramindanidcfe3a82021-11-29 17:00:31 +00002569 if (configGroup1 != configGroup2) {
ramindani431aad42022-02-01 21:44:29 +00002570 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002571 sendRefreshFrame(display, nullptr);
ramindani431aad42022-02-01 21:44:29 +00002572 const auto& [status, _] = mComposerClient->setActiveConfigWithConstraints(
2573 &display, config2, constraints);
2574 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00002575 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(
2576 status, IComposerClient::EX_SEAMLESS_NOT_ALLOWED));
ramindanidcfe3a82021-11-29 17:00:31 +00002577 }
2578 });
2579 }
2580}
2581
ramindani431aad42022-02-01 21:44:29 +00002582TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_NoTimestamp) {
2583 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ std::nullopt));
Ady Abraham72c5b502021-12-10 17:23:39 -08002584}
2585
ramindani431aad42022-02-01 21:44:29 +00002586TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_0) {
2587 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ 0));
Ady Abraham72c5b502021-12-10 17:23:39 -08002588}
2589
ramindani431aad42022-02-01 21:44:29 +00002590TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_5) {
2591 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ 5));
Ady Abraham72c5b502021-12-10 17:23:39 -08002592}
2593
ramindani431aad42022-02-01 21:44:29 +00002594TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Unsupported) {
2595 const bool hasDisplayIdleTimerSupport =
2596 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002597 if (!hasDisplayIdleTimerSupport) {
ramindani431aad42022-02-01 21:44:29 +00002598 const auto& status =
2599 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0);
2600 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00002601 EXPECT_NO_FATAL_FAILURE(
2602 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
Midas Chiena0b56bd2022-01-13 23:27:33 +08002603 }
2604}
2605
ramindani431aad42022-02-01 21:44:29 +00002606TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_BadParameter) {
2607 const bool hasDisplayIdleTimerSupport =
2608 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002609 if (!hasDisplayIdleTimerSupport) {
2610 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2611 return;
2612 }
2613
ramindani431aad42022-02-01 21:44:29 +00002614 const auto& status =
2615 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ -1);
2616 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00002617 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
Midas Chiena0b56bd2022-01-13 23:27:33 +08002618}
2619
ramindani431aad42022-02-01 21:44:29 +00002620TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Disable) {
2621 const bool hasDisplayIdleTimerSupport =
2622 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002623 if (!hasDisplayIdleTimerSupport) {
2624 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2625 return;
2626 }
2627
ramindani431aad42022-02-01 21:44:29 +00002628 EXPECT_TRUE(mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002629 std::this_thread::sleep_for(1s);
ramindani431aad42022-02-01 21:44:29 +00002630 EXPECT_EQ(0, mComposerClient->getVsyncIdleCount());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002631}
2632
ramindani431aad42022-02-01 21:44:29 +00002633TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Timeout_2) {
2634 const bool hasDisplayIdleTimerSupport =
2635 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002636 if (!hasDisplayIdleTimerSupport) {
2637 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2638 return;
2639 }
2640
ramindani431aad42022-02-01 21:44:29 +00002641 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
2642 EXPECT_TRUE(mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002643
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002644 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002645 ASSERT_NE(nullptr, buffer->handle);
2646
ramindanifc93b732024-02-15 21:36:19 +00002647 const auto layer = createOnScreenLayer(getPrimaryDisplay());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002648 auto& writer = getWriter(getPrimaryDisplayId());
2649 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer->handle,
2650 /*acquireFence*/ -1);
ramindani431aad42022-02-01 21:44:29 +00002651 int32_t vsyncIdleCount = mComposerClient->getVsyncIdleCount();
Midas Chiena0b56bd2022-01-13 23:27:33 +08002652 auto earlyVsyncIdleTime = systemTime() + std::chrono::nanoseconds(2s).count();
ramindani431aad42022-02-01 21:44:29 +00002653 EXPECT_TRUE(
2654 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 2000).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002655
2656 const sp<::android::Fence> presentFence =
ramindani431aad42022-02-01 21:44:29 +00002657 presentAndGetFence(ComposerClientWriter::kNoTimestamp);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002658 presentFence->waitForever(LOG_TAG);
2659
2660 std::this_thread::sleep_for(3s);
ramindani431aad42022-02-01 21:44:29 +00002661 if (vsyncIdleCount < mComposerClient->getVsyncIdleCount()) {
2662 EXPECT_GE(mComposerClient->getVsyncIdleTime(), earlyVsyncIdleTime);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002663 }
2664
ramindani431aad42022-02-01 21:44:29 +00002665 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002666}
2667
ramindani12423f52023-06-14 20:04:51 -07002668class GraphicsComposerAidlCommandV2Test : public GraphicsComposerAidlCommandTest {
2669 protected:
2670 void SetUp() override {
2671 GraphicsComposerAidlTest::SetUp();
2672 if (getInterfaceVersion() <= 1) {
2673 GTEST_SKIP() << "Device interface version is expected to be >= 2";
2674 }
ramindani17c71102023-03-20 10:51:14 -07002675 }
ramindani12423f52023-06-14 20:04:51 -07002676};
2677/**
2678 * Test Capability::SKIP_VALIDATE
2679 *
2680 * Capability::SKIP_VALIDATE has been deprecated and should not be enabled.
2681 */
2682TEST_P(GraphicsComposerAidlCommandV2Test, SkipValidateDeprecatedTest) {
Leon Scroggins III79d7ae82023-10-11 16:03:52 -04002683#pragma clang diagnostic push
2684#pragma clang diagnostic ignored "-Wdeprecated-declarations"
ramindani12423f52023-06-14 20:04:51 -07002685 ASSERT_FALSE(hasCapability(Capability::SKIP_VALIDATE))
2686 << "Found Capability::SKIP_VALIDATE capability.";
Leon Scroggins III79d7ae82023-10-11 16:03:52 -04002687#pragma clang diagnostic pop
ramindani12423f52023-06-14 20:04:51 -07002688}
2689
2690TEST_P(GraphicsComposerAidlCommandV2Test, SetLayerBufferSlotsToClear) {
Ady Abrahama00d2462023-12-26 14:21:20 -08002691 auto& writer = getWriter(getPrimaryDisplayId());
ramindani12423f52023-06-14 20:04:51 -07002692 // Older HAL versions use a backwards compatible way of clearing buffer slots
2693 // HAL at version 1 or lower does not have LayerCommand::bufferSlotsToClear
2694 const auto& [layerStatus, layer] =
Ady Abrahama00d2462023-12-26 14:21:20 -08002695 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
ramindani12423f52023-06-14 20:04:51 -07002696 EXPECT_TRUE(layerStatus.isOk());
ramindani12423f52023-06-14 20:04:51 -07002697
2698 // setup 3 buffers in the buffer cache, with the last buffer being active
2699 // then emulate the Android platform code that clears all 3 buffer slots
2700
2701 const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2702 ASSERT_NE(nullptr, buffer1);
2703 const auto handle1 = buffer1->handle;
2704 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle1, /*acquireFence*/ -1);
2705 execute();
2706 ASSERT_TRUE(mReader.takeErrors().empty());
2707
2708 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2709 ASSERT_NE(nullptr, buffer2);
2710 const auto handle2 = buffer2->handle;
2711 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 1, handle2, /*acquireFence*/ -1);
2712 execute();
2713 ASSERT_TRUE(mReader.takeErrors().empty());
2714
2715 const auto buffer3 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2716 ASSERT_NE(nullptr, buffer3);
2717 const auto handle3 = buffer3->handle;
2718 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 2, handle3, /*acquireFence*/ -1);
2719 execute();
2720 ASSERT_TRUE(mReader.takeErrors().empty());
2721
2722 // Ensure we can clear all 3 buffer slots, even the active buffer - it is assumed the
2723 // current active buffer's slot will be cleared, but still remain the active buffer and no
2724 // errors will occur.
2725 writer.setLayerBufferSlotsToClear(getPrimaryDisplayId(), layer, {0, 1, 2});
2726 execute();
2727 ASSERT_TRUE(mReader.takeErrors().empty());
2728}
2729
2730TEST_P(GraphicsComposerAidlCommandV2Test, SetRefreshRateChangedCallbackDebug_Unsupported) {
ramindani9dd8c482023-02-21 18:07:56 -08002731 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2732 auto status = mComposerClient->setRefreshRateChangedCallbackDebugEnabled(
2733 getPrimaryDisplayId(), /*enabled*/ true);
2734 EXPECT_FALSE(status.isOk());
2735 EXPECT_NO_FATAL_FAILURE(
2736 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
2737
2738 status = mComposerClient->setRefreshRateChangedCallbackDebugEnabled(getPrimaryDisplayId(),
2739 /*enabled*/ false);
2740 EXPECT_FALSE(status.isOk());
2741 EXPECT_NO_FATAL_FAILURE(
2742 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
2743 }
2744}
2745
ramindani12423f52023-06-14 20:04:51 -07002746TEST_P(GraphicsComposerAidlCommandV2Test, SetRefreshRateChangedCallbackDebug_Enabled) {
ramindani9dd8c482023-02-21 18:07:56 -08002747 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2748 GTEST_SUCCEED() << "Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG is not supported";
2749 return;
2750 }
2751
ramindania2a6dea2023-12-11 13:42:36 -08002752 for (VtsDisplay& display : mDisplays) {
2753 const auto displayId = display.getDisplayId();
2754 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2755 // Enable the callback
2756 ASSERT_TRUE(mComposerClient
2757 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2758 /*enabled*/ true)
2759 .isOk());
2760 std::this_thread::sleep_for(100ms);
ramindani9dd8c482023-02-21 18:07:56 -08002761
ramindania2a6dea2023-12-11 13:42:36 -08002762 const auto [status, configId] = mComposerClient->getActiveConfig(display.getDisplayId());
2763 EXPECT_TRUE(status.isOk());
ramindani9dd8c482023-02-21 18:07:56 -08002764
ramindania2a6dea2023-12-11 13:42:36 -08002765 const auto displayFilter = [&](auto refreshRateChangedDebugData) {
2766 bool nonVrrRateMatching = true;
2767 if (std::optional<VrrConfig> vrrConfigOpt =
ramindani3ba73342024-04-01 11:42:33 -07002768 display.getDisplayConfig(configId).vrrConfigOpt;
ramindania2a6dea2023-12-11 13:42:36 -08002769 getInterfaceVersion() >= 3 && !vrrConfigOpt) {
2770 nonVrrRateMatching = refreshRateChangedDebugData.refreshPeriodNanos ==
2771 refreshRateChangedDebugData.vsyncPeriodNanos;
2772 }
2773 const bool isDisplaySame =
2774 display.getDisplayId() == refreshRateChangedDebugData.display;
2775 return nonVrrRateMatching && isDisplaySame;
2776 };
ramindani9dd8c482023-02-21 18:07:56 -08002777
ramindania2a6dea2023-12-11 13:42:36 -08002778 // Check that we immediately got a callback
2779 EXPECT_TRUE(checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter));
2780
2781 ASSERT_TRUE(mComposerClient
2782 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2783 /*enabled*/ false)
2784 .isOk());
2785 }
ramindani9dd8c482023-02-21 18:07:56 -08002786}
2787
ramindani12423f52023-06-14 20:04:51 -07002788TEST_P(GraphicsComposerAidlCommandV2Test,
ramindani9dd8c482023-02-21 18:07:56 -08002789 SetRefreshRateChangedCallbackDebugEnabled_noCallbackWhenIdle) {
2790 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2791 GTEST_SUCCEED() << "Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG is not supported";
2792 return;
2793 }
2794
2795 auto display = getEditablePrimaryDisplay();
2796 const auto displayId = display.getDisplayId();
2797
2798 if (!hasDisplayCapability(displayId, DisplayCapability::DISPLAY_IDLE_TIMER)) {
2799 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2800 return;
2801 }
2802
2803 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2804 EXPECT_TRUE(mComposerClient->setPeakRefreshRateConfig(&display).isOk());
2805
2806 ASSERT_TRUE(mComposerClient->setIdleTimerEnabled(displayId, /*timeoutMs*/ 500).isOk());
2807 // Enable the callback
2808 ASSERT_TRUE(mComposerClient
2809 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2810 /*enabled*/ true)
2811 .isOk());
2812
ramindani91518892023-03-03 16:55:09 +00002813 const auto displayFilter = [displayId](auto refreshRateChangedDebugData) {
2814 return displayId == refreshRateChangedDebugData.display;
2815 };
ramindani9dd8c482023-02-21 18:07:56 -08002816
2817 int retryCount = 3;
2818 do {
2819 // Wait for 1s so that we enter the idle state
2820 std::this_thread::sleep_for(1s);
ramindani91518892023-03-03 16:55:09 +00002821 if (!checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter)) {
ramindani9dd8c482023-02-21 18:07:56 -08002822 // DID NOT receive a callback, we are in the idle state.
2823 break;
2824 }
2825 } while (--retryCount > 0);
2826
2827 if (retryCount == 0) {
2828 GTEST_SUCCEED() << "Unable to enter the idle mode";
2829 return;
2830 }
2831
2832 // Send the REFRESH_RATE_INDICATOR update
ramindanifc93b732024-02-15 21:36:19 +00002833 ASSERT_NO_FATAL_FAILURE(sendBufferUpdate(
2834 createOnScreenLayer(getPrimaryDisplay(), Composition::REFRESH_RATE_INDICATOR)));
ramindani9dd8c482023-02-21 18:07:56 -08002835 std::this_thread::sleep_for(1s);
ramindani91518892023-03-03 16:55:09 +00002836 EXPECT_FALSE(checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter))
ramindani9dd8c482023-02-21 18:07:56 -08002837 << "A callback should not be received for REFRESH_RATE_INDICATOR";
2838
2839 EXPECT_TRUE(mComposerClient
2840 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2841 /*enabled*/ false)
2842 .isOk());
2843}
2844
ramindani12423f52023-06-14 20:04:51 -07002845TEST_P(GraphicsComposerAidlCommandV2Test,
ramindani9dd8c482023-02-21 18:07:56 -08002846 SetRefreshRateChangedCallbackDebugEnabled_SetActiveConfigWithConstraints) {
2847 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2848 GTEST_SUCCEED() << "Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG is not supported";
2849 return;
2850 }
2851
2852 VsyncPeriodChangeConstraints constraints;
2853 constraints.seamlessRequired = false;
2854 constraints.desiredTimeNanos = systemTime();
2855
2856 for (VtsDisplay& display : mDisplays) {
2857 const auto displayId = display.getDisplayId();
2858 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2859
2860 // Enable the callback
2861 ASSERT_TRUE(mComposerClient
2862 ->setRefreshRateChangedCallbackDebugEnabled(displayId, /*enabled*/ true)
2863 .isOk());
2864
2865 forEachTwoConfigs(displayId, [&](int32_t config1, int32_t config2) {
ramindani3ba73342024-04-01 11:42:33 -07002866 if (display.isRateSameBetweenConfigs(config1, config2)) {
ramindani9dd8c482023-02-21 18:07:56 -08002867 return; // continue
2868 }
2869
2870 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
2871 sendRefreshFrame(display, nullptr);
2872
2873 const auto& [status, timeline] =
2874 mComposerClient->setActiveConfigWithConstraints(&display, config2, constraints);
2875 EXPECT_TRUE(status.isOk());
2876
2877 if (timeline.refreshRequired) {
2878 sendRefreshFrame(display, &timeline);
2879 }
2880
ramindani3ba73342024-04-01 11:42:33 -07002881 const int32_t vsyncPeriod2 = display.getDisplayConfig(config2).vsyncPeriod;
ramindani91518892023-03-03 16:55:09 +00002882 const auto callbackFilter = [displayId,
2883 vsyncPeriod2](auto refreshRateChangedDebugData) {
2884 constexpr int kVsyncThreshold = 1000;
2885 return displayId == refreshRateChangedDebugData.display &&
2886 std::abs(vsyncPeriod2 - refreshRateChangedDebugData.vsyncPeriodNanos) <=
2887 kVsyncThreshold;
2888 };
ramindani9dd8c482023-02-21 18:07:56 -08002889
2890 int retryCount = 3;
2891 do {
2892 std::this_thread::sleep_for(100ms);
ramindani91518892023-03-03 16:55:09 +00002893 if (checkIfCallbackRefreshRateChangedDebugEnabledReceived(callbackFilter)) {
ramindani9dd8c482023-02-21 18:07:56 -08002894 GTEST_SUCCEED() << "Received a callback successfully";
2895 break;
2896 }
2897 } while (--retryCount > 0);
2898
2899 if (retryCount == 0) {
Ying Weiaf547822024-05-17 16:31:12 +00002900 GTEST_FAIL() << "Failed to get a callback for Display " << displayId
2901 << " switching from " << display.printConfig(config1)
2902 << " to " << display.printConfig(config2);
ramindani9dd8c482023-02-21 18:07:56 -08002903 }
2904 });
2905
2906 EXPECT_TRUE(
2907 mComposerClient
2908 ->setRefreshRateChangedCallbackDebugEnabled(displayId, /*enabled*/ false)
2909 .isOk());
2910 }
2911}
2912
Joen Chene0a962c2023-08-28 09:49:11 +00002913TEST_P(GraphicsComposerAidlCommandTest, MultiThreadedPresent) {
2914 std::vector<VtsDisplay*> displays;
2915 for (auto& display : mDisplays) {
2916 if (hasDisplayCapability(display.getDisplayId(),
2917 DisplayCapability::MULTI_THREADED_PRESENT)) {
2918 displays.push_back(&display);
2919 }
2920 }
2921
2922 const size_t numDisplays = displays.size();
2923 if (numDisplays <= 1u) {
2924 GTEST_SKIP();
2925 }
2926
2927 // When multi-threaded, use a reader per display. As with mWriters, this mutex
2928 // guards access to the map.
2929 std::mutex readersMutex;
2930 std::unordered_map<int64_t, ComposerClientReader> readers;
2931 std::vector<std::thread> threads;
2932 threads.reserve(numDisplays);
2933
2934 // Each display will have a layer to present. This maps from the display to
2935 // the layer, so we can properly destroy each layer at the end.
2936 std::unordered_map<int64_t, int64_t> layers;
2937
2938 for (auto* const display : displays) {
2939 const int64_t displayId = display->getDisplayId();
2940
2941 // Ensure that all writers and readers have been added to their respective
2942 // maps initially, so that the following loop never modifies the maps. The
2943 // maps are accessed from different threads, and if the maps were modified,
2944 // this would invalidate their iterators, and therefore references to the
2945 // writers and readers.
2946 auto& writer = getWriter(displayId);
2947 {
2948 std::lock_guard guard{readersMutex};
2949 readers.try_emplace(displayId, displayId);
2950 }
2951
2952 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2953
Ady Abrahama00d2462023-12-26 14:21:20 -08002954 const auto& [status, layer] =
2955 mComposerClient->createLayer(displayId, kBufferSlotCount, &writer);
Joen Chene0a962c2023-08-28 09:49:11 +00002956 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2957 ASSERT_NE(nullptr, buffer);
2958 ASSERT_EQ(::android::OK, buffer->initCheck());
2959 ASSERT_NE(nullptr, buffer->handle);
2960
2961 configureLayer(*display, layer, Composition::DEVICE, display->getFrameRect(),
2962 display->getCrop());
2963 writer.setLayerBuffer(displayId, layer, /*slot*/ 0, buffer->handle,
2964 /*acquireFence*/ -1);
2965 writer.setLayerDataspace(displayId, layer, common::Dataspace::UNKNOWN);
2966 layers.try_emplace(displayId, layer);
2967 }
2968
2969 for (auto* const display : displays) {
2970 const int64_t displayId = display->getDisplayId();
2971 auto& writer = getWriter(displayId);
2972 std::unique_lock lock{readersMutex};
2973 auto& reader = readers.at(displayId);
2974 lock.unlock();
2975
ramindanicdcfcaf2023-11-09 10:00:10 -08002976 writer.validateDisplay(displayId, ComposerClientWriter::kNoTimestamp,
2977 VtsComposerClient::kNoFrameIntervalNs);
Joen Chene0a962c2023-08-28 09:49:11 +00002978 execute(writer, reader);
2979
2980 threads.emplace_back([this, displayId, &readers, &readersMutex]() {
2981 auto& writer = getWriter(displayId);
2982 std::unique_lock lock{readersMutex};
2983 ComposerClientReader& reader = readers.at(displayId);
2984 lock.unlock();
2985
2986 writer.presentDisplay(displayId);
2987 execute(writer, reader);
2988 ASSERT_TRUE(reader.takeErrors().empty());
2989
2990 auto presentFence = reader.takePresentFence(displayId);
2991 // take ownership
2992 const int fenceOwner = presentFence.get();
2993 *presentFence.getR() = -1;
2994 EXPECT_NE(-1, fenceOwner);
2995 const auto presentFence2 = sp<::android::Fence>::make(fenceOwner);
2996 presentFence2->waitForever(LOG_TAG);
2997 });
2998 }
2999
3000 for (auto& thread : threads) {
3001 thread.join();
3002 }
3003
3004 for (auto& [displayId, layer] : layers) {
Ady Abrahama00d2462023-12-26 14:21:20 -08003005 auto& writer = getWriter(displayId);
3006 EXPECT_TRUE(mComposerClient->destroyLayer(displayId, layer, &writer).isOk());
Joen Chene0a962c2023-08-28 09:49:11 +00003007 }
3008
3009 std::lock_guard guard{readersMutex};
3010 for (auto& [displayId, reader] : readers) {
3011 ASSERT_TRUE(reader.takeErrors().empty());
3012 ASSERT_TRUE(reader.takeChangedCompositionTypes(displayId).empty());
3013 }
3014}
3015
Ady Abrahama00d2462023-12-26 14:21:20 -08003016class GraphicsComposerAidlCommandV3Test : public GraphicsComposerAidlCommandTest {
Manali Bhutiyani38565cc2023-11-11 06:16:24 +00003017 protected:
3018 void SetUp() override {
Ady Abrahama00d2462023-12-26 14:21:20 -08003019 GraphicsComposerAidlTest::SetUp();
Manali Bhutiyani38565cc2023-11-11 06:16:24 +00003020 if (getInterfaceVersion() <= 2) {
3021 GTEST_SKIP() << "Device interface version is expected to be >= 3";
3022 }
3023 }
Manali Bhutiyani38565cc2023-11-11 06:16:24 +00003024};
3025
Ady Abrahama00d2462023-12-26 14:21:20 -08003026TEST_P(GraphicsComposerAidlCommandV3Test, CreateBatchedCommand) {
3027 if (!hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
3028 GTEST_SKIP() << "LAYER_LIFECYCLE_BATCH_COMMAND not supported by the implementation";
3029 return;
3030 }
Manali Bhutiyani38565cc2023-11-11 06:16:24 +00003031 auto& writer = getWriter(getPrimaryDisplayId());
Manali Bhutiyanif687f7f2024-03-25 22:07:25 +00003032 const auto& [status, layer] =
3033 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
3034 EXPECT_TRUE(status.isOk());
Manali Bhutiyani38565cc2023-11-11 06:16:24 +00003035 execute();
3036 ASSERT_TRUE(mReader.takeErrors().empty());
3037}
3038
Ady Abrahama00d2462023-12-26 14:21:20 -08003039TEST_P(GraphicsComposerAidlCommandV3Test, CreateBatchedCommand_BadDisplay) {
3040 if (!hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
3041 GTEST_SKIP() << "LAYER_LIFECYCLE_BATCH_COMMAND not supported by the implementation";
3042 return;
3043 }
Manali Bhutiyanif687f7f2024-03-25 22:07:25 +00003044 auto& writer = getWriter(getInvalidDisplayId());
Ady Abrahama00d2462023-12-26 14:21:20 -08003045 int64_t layer = 5;
3046 writer.setLayerLifecycleBatchCommandType(getInvalidDisplayId(), layer,
3047 LayerLifecycleBatchCommandType::CREATE);
Manali Bhutiyanif687f7f2024-03-25 22:07:25 +00003048 writer.setNewBufferSlotCount(getInvalidDisplayId(), layer, 1);
Ady Abrahama00d2462023-12-26 14:21:20 -08003049 execute();
Manali Bhutiyanif687f7f2024-03-25 22:07:25 +00003050
Ady Abrahama00d2462023-12-26 14:21:20 -08003051 const auto errors = mReader.takeErrors();
3052 ASSERT_TRUE(errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_BAD_DISPLAY);
3053}
3054
3055TEST_P(GraphicsComposerAidlCommandV3Test, DestroyBatchedCommand) {
3056 if (!hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
3057 GTEST_SKIP() << "LAYER_LIFECYCLE_BATCH_COMMAND not supported by the implementation";
3058 return;
3059 }
Manali Bhutiyani38565cc2023-11-11 06:16:24 +00003060 auto& writer = getWriter(getPrimaryDisplayId());
Manali Bhutiyanif687f7f2024-03-25 22:07:25 +00003061 const auto& [status, layer] =
3062 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
3063 EXPECT_TRUE(status.isOk());
Manali Bhutiyani38565cc2023-11-11 06:16:24 +00003064 execute();
3065 ASSERT_TRUE(mReader.takeErrors().empty());
Manali Bhutiyanif687f7f2024-03-25 22:07:25 +00003066 EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer, &writer).isOk());
Manali Bhutiyani38565cc2023-11-11 06:16:24 +00003067 execute();
Manali Bhutiyanif687f7f2024-03-25 22:07:25 +00003068 ASSERT_TRUE(mReader.takeErrors().empty());
Ady Abrahama00d2462023-12-26 14:21:20 -08003069}
3070
3071TEST_P(GraphicsComposerAidlCommandV3Test, DestroyBatchedCommand_BadDisplay) {
3072 if (!hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
3073 GTEST_SKIP() << "LAYER_LIFECYCLE_BATCH_COMMAND not supported by the implementation";
3074 return;
3075 }
Ady Abrahama00d2462023-12-26 14:21:20 -08003076 auto& writer = getWriter(getPrimaryDisplayId());
Manali Bhutiyanif687f7f2024-03-25 22:07:25 +00003077 const auto& [status, layer] =
3078 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
Ady Abrahama00d2462023-12-26 14:21:20 -08003079
Manali Bhutiyanif687f7f2024-03-25 22:07:25 +00003080 EXPECT_TRUE(status.isOk());
Ady Abrahama00d2462023-12-26 14:21:20 -08003081 execute();
Manali Bhutiyani38565cc2023-11-11 06:16:24 +00003082 ASSERT_TRUE(mReader.takeErrors().empty());
Manali Bhutiyanif687f7f2024-03-25 22:07:25 +00003083
3084 auto& invalid_writer = getWriter(getInvalidDisplayId());
3085 invalid_writer.setLayerLifecycleBatchCommandType(getInvalidDisplayId(), layer,
3086 LayerLifecycleBatchCommandType::DESTROY);
3087 execute();
3088 const auto errors = mReader.takeErrors();
3089 ASSERT_TRUE(errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_BAD_DISPLAY);
Manali Bhutiyani38565cc2023-11-11 06:16:24 +00003090}
3091
Ady Abrahama00d2462023-12-26 14:21:20 -08003092TEST_P(GraphicsComposerAidlCommandV3Test, NoCreateDestroyBatchedCommandIncorrectLayer) {
3093 if (!hasCapability(Capability::LAYER_LIFECYCLE_BATCH_COMMAND)) {
3094 GTEST_SKIP() << "LAYER_LIFECYCLE_BATCH_COMMAND not supported by the implementation";
3095 return;
3096 }
3097
Manali Bhutiyani38565cc2023-11-11 06:16:24 +00003098 auto& writer = getWriter(getPrimaryDisplayId());
3099 int64_t layer = 5;
3100 writer.setLayerLifecycleBatchCommandType(getPrimaryDisplayId(), layer,
3101 LayerLifecycleBatchCommandType::DESTROY);
3102 execute();
3103 const auto errors = mReader.takeErrors();
3104 ASSERT_TRUE(errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_BAD_LAYER);
3105}
3106
ramindanifc93b732024-02-15 21:36:19 +00003107TEST_P(GraphicsComposerAidlCommandV3Test, notifyExpectedPresentTimeout) {
3108 if (hasCapability(Capability::PRESENT_FENCE_IS_NOT_RELIABLE)) {
3109 GTEST_SUCCEED() << "Device has unreliable present fences capability, skipping";
3110 return;
3111 }
3112 forEachNotifyExpectedPresentConfig([&](VtsDisplay& display,
3113 const DisplayConfiguration& config) {
3114 const auto displayId = display.getDisplayId();
3115 auto minFrameIntervalNs = config.vrrConfig->minFrameIntervalNs;
3116 const auto timeoutNs = config.vrrConfig->notifyExpectedPresentConfig->timeoutNs;
3117
3118 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
3119 ASSERT_NE(nullptr, buffer);
3120 const auto layer = createOnScreenLayer(display);
3121 auto& writer = getWriter(displayId);
3122 writer.setLayerBuffer(displayId, layer, /*slot*/ 0, buffer->handle,
3123 /*acquireFence*/ -1);
3124 sp<::android::Fence> presentFence = presentAndGetFence(ComposerClientWriter::kNoTimestamp,
3125 displayId, minFrameIntervalNs);
3126 presentFence->waitForever(LOG_TAG);
3127 auto lastPresentTimeNs = presentFence->getSignalTime();
3128
3129 // Frame presents 30ms after timeout
3130 const auto timeout = static_cast<const std::chrono::nanoseconds>(timeoutNs);
3131 const auto vsyncPeriod = config.vsyncPeriod;
3132 int32_t frameAfterTimeoutNs =
3133 vsyncPeriod * static_cast<int32_t>((timeout + 30ms).count() / vsyncPeriod);
3134 auto expectedPresentTimestamp =
3135 ClockMonotonicTimestamp{lastPresentTimeNs + frameAfterTimeoutNs};
3136 std::this_thread::sleep_for(timeout);
3137 mComposerClient->notifyExpectedPresent(displayId, expectedPresentTimestamp,
3138 minFrameIntervalNs);
3139 presentFence = presentAndGetFence(expectedPresentTimestamp, displayId, minFrameIntervalNs);
3140 presentFence->waitForever(LOG_TAG);
3141 lastPresentTimeNs = presentFence->getSignalTime();
3142 ASSERT_GE(lastPresentTimeNs, expectedPresentTimestamp.timestampNanos - vsyncPeriod / 2);
3143 mComposerClient->destroyLayer(displayId, layer, &writer);
3144 });
3145}
3146
3147TEST_P(GraphicsComposerAidlCommandV3Test, notifyExpectedPresentFrameIntervalChange) {
3148 if (hasCapability(Capability::PRESENT_FENCE_IS_NOT_RELIABLE)) {
3149 GTEST_SUCCEED() << "Device has unreliable present fences capability, skipping";
3150 return;
3151 }
3152 forEachNotifyExpectedPresentConfig([&](VtsDisplay& display,
3153 const DisplayConfiguration& config) {
3154 const auto displayId = display.getDisplayId();
3155 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
3156 ASSERT_NE(nullptr, buffer);
3157 const auto layer = createOnScreenLayer(display);
3158 auto& writer = getWriter(displayId);
3159 writer.setLayerBuffer(displayId, layer, /*slot*/ 0, buffer->handle,
3160 /*acquireFence*/ -1);
3161 auto minFrameIntervalNs = config.vrrConfig->minFrameIntervalNs;
3162 sp<::android::Fence> presentFence = presentAndGetFence(ComposerClientWriter::kNoTimestamp,
3163 displayId, minFrameIntervalNs);
3164 presentFence->waitForever(LOG_TAG);
3165 auto lastPresentTimeNs = presentFence->getSignalTime();
3166
3167 auto vsyncPeriod = config.vsyncPeriod;
3168 int32_t highestDivisor = VtsComposerClient::kMaxFrameIntervalNs / vsyncPeriod;
3169 int32_t lowestDivisor = minFrameIntervalNs / vsyncPeriod;
3170 const auto headsUpNs = config.vrrConfig->notifyExpectedPresentConfig->headsUpNs;
3171 float totalDivisorsPassed = 0.f;
3172 for (int divisor = lowestDivisor; divisor <= highestDivisor; divisor++) {
3173 const auto frameIntervalNs = vsyncPeriod * divisor;
3174 const auto frameAfterHeadsUp = frameIntervalNs * (headsUpNs / frameIntervalNs);
3175 auto presentTime = lastPresentTimeNs + frameIntervalNs + frameAfterHeadsUp;
3176 const auto expectedPresentTimestamp = ClockMonotonicTimestamp{presentTime};
3177 ASSERT_TRUE(mComposerClient
3178 ->notifyExpectedPresent(displayId, expectedPresentTimestamp,
3179 frameIntervalNs)
3180 .isOk());
3181 presentFence = presentAndGetFence(expectedPresentTimestamp, displayId, frameIntervalNs);
3182 presentFence->waitForever(LOG_TAG);
3183 lastPresentTimeNs = presentFence->getSignalTime();
3184 if (lastPresentTimeNs >= expectedPresentTimestamp.timestampNanos - vsyncPeriod / 2) {
3185 ++totalDivisorsPassed;
3186 }
3187 }
3188 EXPECT_TRUE(totalDivisorsPassed >
3189 (static_cast<float>(highestDivisor - lowestDivisor)) * 0.75f);
3190 mComposerClient->destroyLayer(displayId, layer, &writer);
3191 });
3192}
3193
3194TEST_P(GraphicsComposerAidlCommandV3Test, frameIntervalChangeAtPresentFrame) {
3195 if (hasCapability(Capability::PRESENT_FENCE_IS_NOT_RELIABLE)) {
3196 GTEST_SUCCEED() << "Device has unreliable present fences capability, skipping";
3197 return;
3198 }
3199 forEachNotifyExpectedPresentConfig([&](VtsDisplay& display,
3200 const DisplayConfiguration& config) {
3201 const auto displayId = display.getDisplayId();
3202 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
3203 ASSERT_NE(nullptr, buffer);
3204 const auto layer = createOnScreenLayer(display);
3205 auto& writer = getWriter(displayId);
3206 writer.setLayerBuffer(displayId, layer, /*slot*/ 0, buffer->handle,
3207 /*acquireFence*/ -1);
3208 auto minFrameIntervalNs = config.vrrConfig->minFrameIntervalNs;
3209
3210 auto vsyncPeriod = config.vsyncPeriod;
3211 int32_t highestDivisor = VtsComposerClient::kMaxFrameIntervalNs / vsyncPeriod;
3212 int32_t lowestDivisor = minFrameIntervalNs / vsyncPeriod;
3213 const auto headsUpNs = config.vrrConfig->notifyExpectedPresentConfig->headsUpNs;
3214 float totalDivisorsPassed = 0.f;
3215 int divisor = lowestDivisor;
3216 auto frameIntervalNs = vsyncPeriod * divisor;
3217 sp<::android::Fence> presentFence =
3218 presentAndGetFence(ComposerClientWriter::kNoTimestamp, displayId, frameIntervalNs);
3219 presentFence->waitForever(LOG_TAG);
3220 auto lastPresentTimeNs = presentFence->getSignalTime();
3221 do {
3222 frameIntervalNs = vsyncPeriod * divisor;
3223 ++divisor;
3224 const auto nextFrameIntervalNs = vsyncPeriod * divisor;
3225 const auto frameAfterHeadsUp = frameIntervalNs * (headsUpNs / frameIntervalNs);
3226 auto presentTime = lastPresentTimeNs + frameIntervalNs + frameAfterHeadsUp;
3227 const auto expectedPresentTimestamp = ClockMonotonicTimestamp{presentTime};
3228 presentFence =
3229 presentAndGetFence(expectedPresentTimestamp, displayId, nextFrameIntervalNs);
3230 presentFence->waitForever(LOG_TAG);
3231 lastPresentTimeNs = presentFence->getSignalTime();
3232 if (lastPresentTimeNs >= expectedPresentTimestamp.timestampNanos - vsyncPeriod / 2) {
3233 ++totalDivisorsPassed;
3234 }
3235 } while (divisor < highestDivisor);
3236 EXPECT_TRUE(totalDivisorsPassed >
3237 (static_cast<float>(highestDivisor - lowestDivisor)) * 0.75f);
3238 mComposerClient->destroyLayer(displayId, layer, &writer);
3239 });
3240}
3241
Brian Lindahl9f9d2f02024-10-24 16:23:57 -06003242TEST_P(GraphicsComposerAidlCommandV3Test, getMaxLayerPictureProfiles_success) {
3243 for (auto& display : mDisplays) {
3244 int64_t displayId = display.getDisplayId();
3245 if (!hasDisplayCapability(displayId, DisplayCapability::PICTURE_PROCESSING)) {
3246 continue;
3247 }
3248 const auto& [status, maxProfiles] =
3249 mComposerClient->getMaxLayerPictureProfiles(getPrimaryDisplayId());
3250 EXPECT_TRUE(status.isOk());
3251 }
3252}
3253
3254TEST_P(GraphicsComposerAidlCommandV3Test, setDisplayPictureProfileId_success) {
3255 for (auto& display : mDisplays) {
3256 int64_t displayId = display.getDisplayId();
3257 if (!hasDisplayCapability(displayId, DisplayCapability::PICTURE_PROCESSING)) {
3258 continue;
3259 }
3260
3261 auto& writer = getWriter(displayId);
3262 const auto layer = createOnScreenLayer(display);
3263 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
3264 ASSERT_NE(nullptr, buffer->handle);
3265 // TODO(b/337330263): Lookup profile IDs from PictureProfileService
3266 writer.setDisplayPictureProfileId(displayId, PictureProfileId(1));
3267 writer.setLayerBuffer(displayId, layer, /*slot*/ 0, buffer->handle,
3268 /*acquireFence*/ -1);
3269 execute();
3270 ASSERT_TRUE(mReader.takeErrors().empty());
3271 }
3272}
3273
3274TEST_P(GraphicsComposerAidlCommandV3Test, setLayerPictureProfileId_success) {
3275 for (auto& display : mDisplays) {
3276 int64_t displayId = display.getDisplayId();
3277 if (!hasDisplayCapability(displayId, DisplayCapability::PICTURE_PROCESSING)) {
3278 continue;
3279 }
3280 const auto& [status, maxProfiles] = mComposerClient->getMaxLayerPictureProfiles(displayId);
3281 EXPECT_TRUE(status.isOk());
3282 if (maxProfiles == 0) {
3283 continue;
3284 }
3285
3286 auto& writer = getWriter(displayId);
3287 const auto layer = createOnScreenLayer(display);
3288 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
3289 ASSERT_NE(nullptr, buffer->handle);
3290 writer.setLayerBuffer(displayId, layer, /*slot*/ 0, buffer->handle,
3291 /*acquireFence*/ -1);
3292 // TODO(b/337330263): Lookup profile IDs from PictureProfileService
3293 writer.setLayerPictureProfileId(displayId, layer, PictureProfileId(1));
3294 execute();
3295 ASSERT_TRUE(mReader.takeErrors().empty());
3296 }
3297}
3298
3299TEST_P(GraphicsComposerAidlCommandV3Test, setLayerPictureProfileId_failsWithTooManyProfiles) {
3300 for (auto& display : mDisplays) {
3301 int64_t displayId = display.getDisplayId();
3302 if (!hasDisplayCapability(displayId, DisplayCapability::PICTURE_PROCESSING)) {
3303 continue;
3304 }
3305 const auto& [status, maxProfiles] = mComposerClient->getMaxLayerPictureProfiles(displayId);
3306 EXPECT_TRUE(status.isOk());
3307 if (maxProfiles == 0) {
3308 continue;
3309 }
3310
3311 auto& writer = getWriter(displayId);
3312 for (int profileId = 1; profileId <= maxProfiles + 1; ++profileId) {
3313 const auto layer = createOnScreenLayer(display);
3314 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
3315 ASSERT_NE(nullptr, buffer->handle);
3316 writer.setLayerBuffer(displayId, layer, /*slot*/ 0, buffer->handle,
3317 /*acquireFence*/ -1);
3318 // TODO(b/337330263): Lookup profile IDs from PictureProfileService
3319 writer.setLayerPictureProfileId(displayId, layer, PictureProfileId(profileId));
3320 }
3321 execute();
3322 const auto errors = mReader.takeErrors();
3323 ASSERT_TRUE(errors.size() == 1 &&
3324 errors[0].errorCode == IComposerClient::EX_PICTURE_PROFILE_MAX_EXCEEDED);
3325 }
3326}
3327
Sally Qi2d94f522024-10-15 12:53:51 -07003328class GraphicsComposerAidlCommandV4Test : public GraphicsComposerAidlCommandTest {
3329 protected:
3330 void SetUp() override {
3331 GraphicsComposerAidlTest::SetUp();
3332 if (getInterfaceVersion() <= 3) {
3333 GTEST_SKIP() << "Device interface version is expected to be >= 4";
3334 }
3335 }
3336};
3337
3338TEST_P(GraphicsComposerAidlCommandV4Test, SetUnsupportedLayerLuts) {
3339 auto& writer = getWriter(getPrimaryDisplayId());
3340 const auto& [layerStatus, layer] =
3341 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
3342 EXPECT_TRUE(layerStatus.isOk());
3343 const auto& [status, properties] = mComposerClient->getOverlaySupport();
3344 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
3345 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
3346 GTEST_SUCCEED() << "getOverlaySupport is not supported";
3347 return;
3348 }
3349 ASSERT_TRUE(status.isOk());
3350
3351 // TODO (b/362319189): add Lut VTS enforcement
3352 if (!properties.lutProperties) {
3353 int32_t size = 7;
3354 size_t bufferSize = static_cast<size_t>(size) * sizeof(float);
3355 int32_t fd = ashmem_create_region("lut_shared_mem", bufferSize);
3356 void* ptr = mmap(nullptr, bufferSize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
3357 std::vector<float> buffers = {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f};
3358 memcpy(ptr, buffers.data(), bufferSize);
3359 munmap(ptr, bufferSize);
3360 Luts luts;
3361 luts.offsets = {0};
3362 luts.lutProperties = {
3363 {LutProperties::Dimension::ONE_D, size, {LutProperties::SamplingKey::RGB}}};
3364 luts.pfd = ndk::ScopedFileDescriptor(fd);
3365
3366 writer.setLayerLuts(getPrimaryDisplayId(), layer, luts);
3367 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
3368 VtsComposerClient::kNoFrameIntervalNs);
3369 execute();
3370 // change to client composition
3371 ASSERT_FALSE(mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty());
3372 ASSERT_TRUE(mReader.takeErrors().empty());
3373 }
3374}
3375
ramindanidcfe3a82021-11-29 17:00:31 +00003376GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlCommandTest);
3377INSTANTIATE_TEST_SUITE_P(
3378 PerInstance, GraphicsComposerAidlCommandTest,
3379 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
3380 ::android::PrintInstanceNameToString);
ramindanid32ae8e2021-10-01 18:48:39 +00003381GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlTest);
3382INSTANTIATE_TEST_SUITE_P(
3383 PerInstance, GraphicsComposerAidlTest,
3384 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
3385 ::android::PrintInstanceNameToString);
ramindani12423f52023-06-14 20:04:51 -07003386GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlV2Test);
3387INSTANTIATE_TEST_SUITE_P(
3388 PerInstance, GraphicsComposerAidlV2Test,
3389 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
3390 ::android::PrintInstanceNameToString);
ramindani02fe4772023-06-30 18:04:41 -07003391GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlV3Test);
3392INSTANTIATE_TEST_SUITE_P(
3393 PerInstance, GraphicsComposerAidlV3Test,
3394 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
3395 ::android::PrintInstanceNameToString);
ramindani12423f52023-06-14 20:04:51 -07003396GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlCommandV2Test);
3397INSTANTIATE_TEST_SUITE_P(
3398 PerInstance, GraphicsComposerAidlCommandV2Test,
3399 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
3400 ::android::PrintInstanceNameToString);
Ady Abrahama00d2462023-12-26 14:21:20 -08003401GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlCommandV3Test);
3402INSTANTIATE_TEST_SUITE_P(
3403 PerInstance, GraphicsComposerAidlCommandV3Test,
3404 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
3405 ::android::PrintInstanceNameToString);
Sally Qi2d94f522024-10-15 12:53:51 -07003406GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlCommandV4Test);
3407INSTANTIATE_TEST_SUITE_P(
3408 PerInstance, GraphicsComposerAidlCommandV4Test,
3409 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
3410 ::android::PrintInstanceNameToString);
ramindanid32ae8e2021-10-01 18:48:39 +00003411} // namespace aidl::android::hardware::graphics::composer3::vts
3412
3413int main(int argc, char** argv) {
3414 ::testing::InitGoogleTest(&argc, argv);
3415
3416 using namespace std::chrono_literals;
3417 if (!android::base::WaitForProperty("init.svc.surfaceflinger", "stopped", 10s)) {
3418 ALOGE("Failed to stop init.svc.surfaceflinger");
3419 return -1;
3420 }
ramindanibeea10e2021-12-07 21:02:49 +00003421
3422 android::ProcessState::self()->setThreadPoolMaxThreadCount(4);
3423
3424 // The binder threadpool we start will inherit sched policy and priority
3425 // of (this) creating thread. We want the binder thread pool to have
3426 // SCHED_FIFO policy and priority 1 (lowest RT priority)
3427 // Once the pool is created we reset this thread's priority back to
3428 // original.
3429 // This thread policy is based on what we do in the SurfaceFlinger while starting
3430 // the thread pool and we need to replicate that for the VTS tests.
3431 int newPriority = 0;
3432 int origPolicy = sched_getscheduler(0);
3433 struct sched_param origSchedParam;
3434
3435 int errorInPriorityModification = sched_getparam(0, &origSchedParam);
3436 if (errorInPriorityModification == 0) {
3437 int policy = SCHED_FIFO;
3438 newPriority = sched_get_priority_min(policy);
3439
3440 struct sched_param param;
3441 param.sched_priority = newPriority;
3442
3443 errorInPriorityModification = sched_setscheduler(0, policy, &param);
3444 }
3445
3446 // start the thread pool
3447 android::ProcessState::self()->startThreadPool();
3448
3449 // Reset current thread's policy and priority
3450 if (errorInPriorityModification == 0) {
3451 errorInPriorityModification = sched_setscheduler(0, origPolicy, &origSchedParam);
3452 } else {
3453 ALOGE("Failed to set VtsHalGraphicsComposer3_TargetTest binder threadpool priority to "
3454 "SCHED_FIFO");
3455 }
3456
ramindanid32ae8e2021-10-01 18:48:39 +00003457 return RUN_ALL_TESTS();
Leon Scroggins III45095052023-03-23 18:23:15 -04003458}