blob: 1e6f34b534dbe4671ff53dc7722e014b1a436656 [file] [log] [blame]
ramindani431aad42022-02-01 21:44:29 +00001/**
2 * Copyright (c) 2022, The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
Sally Qi2600d342022-08-16 12:46:17 -070016
ramindanid32ae8e2021-10-01 18:48:39 +000017#include <aidl/Gtest.h>
18#include <aidl/Vintf.h>
Ady Abraham3192f3d2021-12-03 16:08:56 -080019#include <aidl/android/hardware/graphics/common/BlendMode.h>
ramindani3335f7a2021-10-25 17:22:35 +000020#include <aidl/android/hardware/graphics/common/BufferUsage.h>
21#include <aidl/android/hardware/graphics/common/FRect.h>
Leon Scroggins IIIde057582022-01-13 12:26:00 -050022#include <aidl/android/hardware/graphics/common/PixelFormat.h>
ramindani3335f7a2021-10-25 17:22:35 +000023#include <aidl/android/hardware/graphics/common/Rect.h>
ramindani3335f7a2021-10-25 17:22:35 +000024#include <aidl/android/hardware/graphics/composer3/Composition.h>
ramindanid32ae8e2021-10-01 18:48:39 +000025#include <aidl/android/hardware/graphics/composer3/IComposer.h>
26#include <android-base/properties.h>
ramindania9780262021-10-01 18:48:39 +000027#include <android/binder_process.h>
Ady Abraham91c9d1a2021-12-15 18:14:45 -080028#include <android/hardware/graphics/composer3/ComposerClientReader.h>
29#include <android/hardware/graphics/composer3/ComposerClientWriter.h>
ramindanid32ae8e2021-10-01 18:48:39 +000030#include <binder/ProcessState.h>
31#include <gtest/gtest.h>
Ady Abraham72c5b502021-12-10 17:23:39 -080032#include <ui/Fence.h>
ramindani3335f7a2021-10-25 17:22:35 +000033#include <ui/GraphicBuffer.h>
34#include <ui/PixelFormat.h>
ramindani0291f112021-11-04 03:45:46 +000035#include <algorithm>
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -040036#include <iterator>
ramindani592b6512021-10-08 21:15:19 +000037#include <numeric>
ramindanid32ae8e2021-10-01 18:48:39 +000038#include <string>
ramindani1cb794e2021-10-13 20:45:23 +000039#include <thread>
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -040040#include <unordered_map>
ramindani458e53e2022-02-23 17:30:16 +000041#include "GraphicsComposerCallback.h"
42#include "VtsComposerClient.h"
ramindani3335f7a2021-10-25 17:22:35 +000043
ramindanid32ae8e2021-10-01 18:48:39 +000044#undef LOG_TAG
45#define LOG_TAG "VtsHalGraphicsComposer3_TargetTest"
46
47namespace aidl::android::hardware::graphics::composer3::vts {
ramindanid32ae8e2021-10-01 18:48:39 +000048
ramindani1cb794e2021-10-13 20:45:23 +000049using namespace std::chrono_literals;
50
ramindanidcfe3a82021-11-29 17:00:31 +000051using ::android::GraphicBuffer;
52using ::android::sp;
53
ramindanid32ae8e2021-10-01 18:48:39 +000054class GraphicsComposerAidlTest : public ::testing::TestWithParam<std::string> {
ramindania9780262021-10-01 18:48:39 +000055 protected:
56 void SetUp() override {
ramindani431aad42022-02-01 21:44:29 +000057 mComposerClient = std::make_unique<VtsComposerClient>(GetParam());
58 ASSERT_TRUE(mComposerClient->createClient().isOk());
Jason Macnake531a092022-01-20 08:49:09 -080059
ramindani431aad42022-02-01 21:44:29 +000060 const auto& [status, displays] = mComposerClient->getDisplays();
Jason Macnake531a092022-01-20 08:49:09 -080061 ASSERT_TRUE(status.isOk());
ramindani431aad42022-02-01 21:44:29 +000062 mDisplays = displays;
ramindanidcfe3a82021-11-29 17:00:31 +000063
ramindani3335f7a2021-10-25 17:22:35 +000064 // explicitly disable vsync
65 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +000066 EXPECT_TRUE(mComposerClient->setVsync(display.getDisplayId(), false).isOk());
ramindani3335f7a2021-10-25 17:22:35 +000067 }
ramindani431aad42022-02-01 21:44:29 +000068 mComposerClient->setVsyncAllowed(false);
ramindania9780262021-10-01 18:48:39 +000069 }
70
ramindani3335f7a2021-10-25 17:22:35 +000071 void TearDown() override {
ramindani431aad42022-02-01 21:44:29 +000072 ASSERT_TRUE(mComposerClient->tearDown());
73 mComposerClient.reset();
ramindani3335f7a2021-10-25 17:22:35 +000074 }
ramindanic2b8d082021-11-06 02:03:50 +000075
ramindanid5751092022-04-22 22:30:20 +000076 void assertServiceSpecificError(const ScopedAStatus& status, int32_t serviceSpecificError) {
77 ASSERT_EQ(status.getExceptionCode(), EX_SERVICE_SPECIFIC);
78 ASSERT_EQ(status.getServiceSpecificError(), serviceSpecificError);
79 }
80
ramindani431aad42022-02-01 21:44:29 +000081 void Test_setContentTypeForDisplay(int64_t display,
82 const std::vector<ContentType>& supportedContentTypes,
83 ContentType contentType, const char* contentTypeStr) {
84 const bool contentTypeSupport =
85 std::find(supportedContentTypes.begin(), supportedContentTypes.end(),
86 contentType) != supportedContentTypes.end();
ramindanidcfe3a82021-11-29 17:00:31 +000087
88 if (!contentTypeSupport) {
ramindani431aad42022-02-01 21:44:29 +000089 const auto& status = mComposerClient->setContentType(display, contentType);
90 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +000091 EXPECT_NO_FATAL_FAILURE(
92 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
ramindanidcfe3a82021-11-29 17:00:31 +000093 GTEST_SUCCEED() << contentTypeStr << " content type is not supported on display "
94 << std::to_string(display) << ", skipping test";
95 return;
96 }
97
98 EXPECT_TRUE(mComposerClient->setContentType(display, contentType).isOk());
99 EXPECT_TRUE(mComposerClient->setContentType(display, ContentType::NONE).isOk());
100 }
101
ramindani431aad42022-02-01 21:44:29 +0000102 void Test_setContentType(ContentType contentType, const char* contentTypeStr) {
ramindanidcfe3a82021-11-29 17:00:31 +0000103 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000104 const auto& [status, supportedContentTypes] =
105 mComposerClient->getSupportedContentTypes(display.getDisplayId());
106 EXPECT_TRUE(status.isOk());
107 Test_setContentTypeForDisplay(display.getDisplayId(), supportedContentTypes,
108 contentType, contentTypeStr);
ramindanidcfe3a82021-11-29 17:00:31 +0000109 }
110 }
111
Jason Macnak325e8232022-01-24 14:48:55 -0800112 bool hasCapability(Capability capability) {
ramindani431aad42022-02-01 21:44:29 +0000113 const auto& [status, capabilities] = mComposerClient->getCapabilities();
114 EXPECT_TRUE(status.isOk());
Jason Macnak325e8232022-01-24 14:48:55 -0800115 return std::any_of(
116 capabilities.begin(), capabilities.end(),
117 [&](const Capability& activeCapability) { return activeCapability == capability; });
118 }
119
ramindani17c71102023-03-20 10:51:14 -0700120 int getInterfaceVersion() {
121 const auto& [versionStatus, version] = mComposerClient->getInterfaceVersion();
122 EXPECT_TRUE(versionStatus.isOk());
123 return version;
124 }
125
ramindani431aad42022-02-01 21:44:29 +0000126 const VtsDisplay& getPrimaryDisplay() const { return mDisplays[0]; }
ramindania9780262021-10-01 18:48:39 +0000127
ramindani431aad42022-02-01 21:44:29 +0000128 int64_t getPrimaryDisplayId() const { return getPrimaryDisplay().getDisplayId(); }
ramindania9780262021-10-01 18:48:39 +0000129
ramindani431aad42022-02-01 21:44:29 +0000130 int64_t getInvalidDisplayId() const { return mComposerClient->getInvalidDisplayId(); }
ramindani1cb794e2021-10-13 20:45:23 +0000131
ramindani431aad42022-02-01 21:44:29 +0000132 VtsDisplay& getEditablePrimaryDisplay() { return mDisplays[0]; }
ramindani0291f112021-11-04 03:45:46 +0000133
ramindani3335f7a2021-10-25 17:22:35 +0000134 struct TestParameters {
135 nsecs_t delayForChange;
136 bool refreshMiss;
137 };
138
ramindani431aad42022-02-01 21:44:29 +0000139 std::unique_ptr<VtsComposerClient> mComposerClient;
ramindani1cb794e2021-10-13 20:45:23 +0000140 std::vector<VtsDisplay> mDisplays;
ramindani3335f7a2021-10-25 17:22:35 +0000141 // use the slot count usually set by SF
142 static constexpr uint32_t kBufferSlotCount = 64;
ramindanid32ae8e2021-10-01 18:48:39 +0000143};
144
ramindani431aad42022-02-01 21:44:29 +0000145TEST_P(GraphicsComposerAidlTest, GetDisplayCapabilities_BadDisplay) {
146 const auto& [status, _] = mComposerClient->getDisplayCapabilities(getInvalidDisplayId());
ramindani5f696942021-10-14 16:24:18 +0000147
ramindani431aad42022-02-01 21:44:29 +0000148 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000149 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindania9780262021-10-01 18:48:39 +0000150}
151
ramindani431aad42022-02-01 21:44:29 +0000152TEST_P(GraphicsComposerAidlTest, GetDisplayCapabilities) {
ramindania9780262021-10-01 18:48:39 +0000153 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000154 const auto& [status, capabilities] =
155 mComposerClient->getDisplayCapabilities(display.getDisplayId());
ramindania9780262021-10-01 18:48:39 +0000156
ramindani431aad42022-02-01 21:44:29 +0000157 EXPECT_TRUE(status.isOk());
ramindania9780262021-10-01 18:48:39 +0000158 }
ramindanid32ae8e2021-10-01 18:48:39 +0000159}
160
ramindani2740bac2021-11-24 22:58:32 +0000161TEST_P(GraphicsComposerAidlTest, DumpDebugInfo) {
ramindani431aad42022-02-01 21:44:29 +0000162 ASSERT_TRUE(mComposerClient->dumpDebugInfo().isOk());
ramindani2740bac2021-11-24 22:58:32 +0000163}
164
165TEST_P(GraphicsComposerAidlTest, CreateClientSingleton) {
166 std::shared_ptr<IComposerClient> composerClient;
ramindani431aad42022-02-01 21:44:29 +0000167 const auto& status = mComposerClient->createClient();
ramindani2740bac2021-11-24 22:58:32 +0000168
ramindani431aad42022-02-01 21:44:29 +0000169 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000170 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_NO_RESOURCES));
ramindani2740bac2021-11-24 22:58:32 +0000171}
172
ramindani592b6512021-10-08 21:15:19 +0000173TEST_P(GraphicsComposerAidlTest, GetDisplayIdentificationData) {
ramindani431aad42022-02-01 21:44:29 +0000174 const auto& [status0, displayIdentification0] =
175 mComposerClient->getDisplayIdentificationData(getPrimaryDisplayId());
ramindanid5751092022-04-22 22:30:20 +0000176 if (!status0.isOk() && status0.getExceptionCode() == EX_SERVICE_SPECIFIC &&
177 status0.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindani431aad42022-02-01 21:44:29 +0000178 GTEST_SUCCEED() << "Display identification data not supported, skipping test";
ramindani592b6512021-10-08 21:15:19 +0000179 return;
180 }
ramindani431aad42022-02-01 21:44:29 +0000181 ASSERT_TRUE(status0.isOk()) << "failed to get display identification data";
ramindani592b6512021-10-08 21:15:19 +0000182 ASSERT_FALSE(displayIdentification0.data.empty());
183
184 constexpr size_t kEdidBlockSize = 128;
185 ASSERT_TRUE(displayIdentification0.data.size() % kEdidBlockSize == 0)
186 << "EDID blob length is not a multiple of " << kEdidBlockSize;
187
188 const uint8_t kEdidHeader[] = {0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00};
189 ASSERT_TRUE(std::equal(std::begin(kEdidHeader), std::end(kEdidHeader),
190 displayIdentification0.data.begin()))
191 << "EDID blob doesn't start with the fixed EDID header";
192 ASSERT_EQ(0, std::accumulate(displayIdentification0.data.begin(),
193 displayIdentification0.data.begin() + kEdidBlockSize,
194 static_cast<uint8_t>(0)))
195 << "EDID base block doesn't checksum";
196
ramindani431aad42022-02-01 21:44:29 +0000197 const auto& [status1, displayIdentification1] =
198 mComposerClient->getDisplayIdentificationData(getPrimaryDisplayId());
199 ASSERT_TRUE(status1.isOk());
ramindani592b6512021-10-08 21:15:19 +0000200
201 ASSERT_EQ(displayIdentification0.port, displayIdentification1.port) << "ports are not stable";
202 ASSERT_TRUE(displayIdentification0.data.size() == displayIdentification1.data.size() &&
203 std::equal(displayIdentification0.data.begin(), displayIdentification0.data.end(),
204 displayIdentification1.data.begin()))
205 << "data is not stable";
206}
207
208TEST_P(GraphicsComposerAidlTest, GetHdrCapabilities) {
ramindani431aad42022-02-01 21:44:29 +0000209 const auto& [status, hdrCapabilities] =
210 mComposerClient->getHdrCapabilities(getPrimaryDisplayId());
ramindani592b6512021-10-08 21:15:19 +0000211
ramindani431aad42022-02-01 21:44:29 +0000212 ASSERT_TRUE(status.isOk());
213 EXPECT_TRUE(hdrCapabilities.maxLuminance >= hdrCapabilities.minLuminance);
ramindani592b6512021-10-08 21:15:19 +0000214}
215
216TEST_P(GraphicsComposerAidlTest, GetPerFrameMetadataKeys) {
ramindani431aad42022-02-01 21:44:29 +0000217 const auto& [status, keys] = mComposerClient->getPerFrameMetadataKeys(getPrimaryDisplayId());
ramindanid5751092022-04-22 22:30:20 +0000218 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
219 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindanic2b8d082021-11-06 02:03:50 +0000220 GTEST_SUCCEED() << "getPerFrameMetadataKeys is not supported";
221 return;
ramindani592b6512021-10-08 21:15:19 +0000222 }
ramindani431aad42022-02-01 21:44:29 +0000223
224 ASSERT_TRUE(status.isOk());
225 EXPECT_TRUE(keys.size() >= 0);
ramindani592b6512021-10-08 21:15:19 +0000226}
227
228TEST_P(GraphicsComposerAidlTest, GetReadbackBufferAttributes) {
ramindani431aad42022-02-01 21:44:29 +0000229 const auto& [status, _] = mComposerClient->getReadbackBufferAttributes(getPrimaryDisplayId());
ramindanid5751092022-04-22 22:30:20 +0000230 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
231 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindani431aad42022-02-01 21:44:29 +0000232 GTEST_SUCCEED() << "getReadbackBufferAttributes is not supported";
233 return;
ramindani592b6512021-10-08 21:15:19 +0000234 }
ramindani431aad42022-02-01 21:44:29 +0000235
236 ASSERT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000237}
238
239TEST_P(GraphicsComposerAidlTest, GetRenderIntents) {
ramindani431aad42022-02-01 21:44:29 +0000240 const auto& [status, modes] = mComposerClient->getColorModes(getPrimaryDisplayId());
241 EXPECT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000242
ramindani431aad42022-02-01 21:44:29 +0000243 for (auto mode : modes) {
244 const auto& [intentStatus, intents] =
245 mComposerClient->getRenderIntents(getPrimaryDisplayId(), mode);
246 EXPECT_TRUE(intentStatus.isOk());
ramindani592b6512021-10-08 21:15:19 +0000247 bool isHdr;
248 switch (mode) {
249 case ColorMode::BT2100_PQ:
250 case ColorMode::BT2100_HLG:
251 isHdr = true;
252 break;
253 default:
254 isHdr = false;
255 break;
256 }
257 RenderIntent requiredIntent =
258 isHdr ? RenderIntent::TONE_MAP_COLORIMETRIC : RenderIntent::COLORIMETRIC;
259
ramindani431aad42022-02-01 21:44:29 +0000260 const auto iter = std::find(intents.cbegin(), intents.cend(), requiredIntent);
ramindani592b6512021-10-08 21:15:19 +0000261 EXPECT_NE(intents.cend(), iter);
262 }
263}
264
ramindani431aad42022-02-01 21:44:29 +0000265TEST_P(GraphicsComposerAidlTest, GetRenderIntents_BadDisplay) {
266 const auto& [status, modes] = mComposerClient->getColorModes(getPrimaryDisplayId());
267 ASSERT_TRUE(status.isOk());
268
ramindani592b6512021-10-08 21:15:19 +0000269 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +0000270 const auto& [intentStatus, _] =
271 mComposerClient->getRenderIntents(getInvalidDisplayId(), mode);
272
273 EXPECT_FALSE(intentStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000274 EXPECT_NO_FATAL_FAILURE(
275 assertServiceSpecificError(intentStatus, IComposerClient::EX_BAD_DISPLAY));
ramindani592b6512021-10-08 21:15:19 +0000276 }
277}
278
ramindani431aad42022-02-01 21:44:29 +0000279TEST_P(GraphicsComposerAidlTest, GetRenderIntents_BadParameter) {
280 const auto& [status, _] =
281 mComposerClient->getRenderIntents(getPrimaryDisplayId(), static_cast<ColorMode>(-1));
282
283 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000284 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
ramindani592b6512021-10-08 21:15:19 +0000285}
286
287TEST_P(GraphicsComposerAidlTest, GetColorModes) {
ramindani431aad42022-02-01 21:44:29 +0000288 const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
289 ASSERT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000290
ramindani431aad42022-02-01 21:44:29 +0000291 const auto native = std::find(colorModes.cbegin(), colorModes.cend(), ColorMode::NATIVE);
292 EXPECT_NE(colorModes.cend(), native);
ramindani592b6512021-10-08 21:15:19 +0000293}
294
ramindani431aad42022-02-01 21:44:29 +0000295TEST_P(GraphicsComposerAidlTest, GetColorMode_BadDisplay) {
296 const auto& [status, _] = mComposerClient->getColorModes(getInvalidDisplayId());
ramindani592b6512021-10-08 21:15:19 +0000297
ramindani431aad42022-02-01 21:44:29 +0000298 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000299 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani592b6512021-10-08 21:15:19 +0000300}
301
302TEST_P(GraphicsComposerAidlTest, SetColorMode) {
ramindani431aad42022-02-01 21:44:29 +0000303 const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
304 EXPECT_TRUE(status.isOk());
305
ramindani592b6512021-10-08 21:15:19 +0000306 for (auto mode : colorModes) {
ramindani431aad42022-02-01 21:44:29 +0000307 const auto& [intentStatus, intents] =
308 mComposerClient->getRenderIntents(getPrimaryDisplayId(), mode);
309 EXPECT_TRUE(intentStatus.isOk()) << "failed to get render intents";
310
ramindani592b6512021-10-08 21:15:19 +0000311 for (auto intent : intents) {
ramindani431aad42022-02-01 21:44:29 +0000312 const auto modeStatus =
313 mComposerClient->setColorMode(getPrimaryDisplayId(), mode, intent);
314 EXPECT_TRUE(modeStatus.isOk() ||
ramindanid5751092022-04-22 22:30:20 +0000315 (modeStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
316 IComposerClient::EX_UNSUPPORTED == modeStatus.getServiceSpecificError()))
ramindani592b6512021-10-08 21:15:19 +0000317 << "failed to set color mode";
318 }
319 }
320
ramindani431aad42022-02-01 21:44:29 +0000321 const auto modeStatus = mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE,
322 RenderIntent::COLORIMETRIC);
323 EXPECT_TRUE(modeStatus.isOk() ||
ramindanid5751092022-04-22 22:30:20 +0000324 (modeStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
325 IComposerClient::EX_UNSUPPORTED == modeStatus.getServiceSpecificError()))
ramindani592b6512021-10-08 21:15:19 +0000326 << "failed to set color mode";
327}
328
ramindani431aad42022-02-01 21:44:29 +0000329TEST_P(GraphicsComposerAidlTest, SetColorMode_BadDisplay) {
330 const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
331 ASSERT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000332
ramindani431aad42022-02-01 21:44:29 +0000333 for (auto mode : colorModes) {
334 const auto& [intentStatus, intents] =
335 mComposerClient->getRenderIntents(getPrimaryDisplayId(), mode);
336 ASSERT_TRUE(intentStatus.isOk()) << "failed to get render intents";
337
338 for (auto intent : intents) {
339 auto const modeStatus =
340 mComposerClient->setColorMode(getInvalidDisplayId(), mode, intent);
341
342 EXPECT_FALSE(modeStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000343 EXPECT_NO_FATAL_FAILURE(
344 assertServiceSpecificError(modeStatus, IComposerClient::EX_BAD_DISPLAY));
ramindani770d7082021-11-30 00:36:42 +0000345 }
346 }
ramindani592b6512021-10-08 21:15:19 +0000347}
348
ramindani431aad42022-02-01 21:44:29 +0000349TEST_P(GraphicsComposerAidlTest, SetColorMode_BadParameter) {
350 auto status = mComposerClient->setColorMode(getPrimaryDisplayId(), static_cast<ColorMode>(-1),
351 RenderIntent::COLORIMETRIC);
ramindani592b6512021-10-08 21:15:19 +0000352
ramindani431aad42022-02-01 21:44:29 +0000353 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000354 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
ramindani592b6512021-10-08 21:15:19 +0000355
ramindani431aad42022-02-01 21:44:29 +0000356 status = mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE,
357 static_cast<RenderIntent>(-1));
ramindani592b6512021-10-08 21:15:19 +0000358
ramindani431aad42022-02-01 21:44:29 +0000359 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000360 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
ramindani592b6512021-10-08 21:15:19 +0000361}
362
363TEST_P(GraphicsComposerAidlTest, GetDisplayedContentSamplingAttributes) {
ramindani431aad42022-02-01 21:44:29 +0000364 int constexpr kInvalid = -1;
365 const auto& [status, format] =
366 mComposerClient->getDisplayedContentSamplingAttributes(getPrimaryDisplayId());
ramindani592b6512021-10-08 21:15:19 +0000367
ramindanid5751092022-04-22 22:30:20 +0000368 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
369 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindani592b6512021-10-08 21:15:19 +0000370 SUCCEED() << "Device does not support optional extension. Test skipped";
371 return;
372 }
373
ramindani431aad42022-02-01 21:44:29 +0000374 ASSERT_TRUE(status.isOk());
375 EXPECT_NE(kInvalid, static_cast<int>(format.format));
376 EXPECT_NE(kInvalid, static_cast<int>(format.dataspace));
377 EXPECT_NE(kInvalid, static_cast<int>(format.componentMask));
ramindani592b6512021-10-08 21:15:19 +0000378};
379
380TEST_P(GraphicsComposerAidlTest, SetDisplayedContentSamplingEnabled) {
ramindani431aad42022-02-01 21:44:29 +0000381 int constexpr kMaxFrames = 10;
ramindani592b6512021-10-08 21:15:19 +0000382 FormatColorComponent enableAllComponents = FormatColorComponent::FORMAT_COMPONENT_0;
ramindani431aad42022-02-01 21:44:29 +0000383 auto status = mComposerClient->setDisplayedContentSamplingEnabled(
384 getPrimaryDisplayId(), /*isEnabled*/ true, enableAllComponents, kMaxFrames);
ramindanid5751092022-04-22 22:30:20 +0000385 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
386 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindani592b6512021-10-08 21:15:19 +0000387 SUCCEED() << "Device does not support optional extension. Test skipped";
388 return;
389 }
ramindani431aad42022-02-01 21:44:29 +0000390 EXPECT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000391
ramindani431aad42022-02-01 21:44:29 +0000392 status = mComposerClient->setDisplayedContentSamplingEnabled(
393 getPrimaryDisplayId(), /*isEnabled*/ false, enableAllComponents, kMaxFrames);
394 EXPECT_TRUE(status.isOk());
ramindani592b6512021-10-08 21:15:19 +0000395}
396
397TEST_P(GraphicsComposerAidlTest, GetDisplayedContentSample) {
ramindani431aad42022-02-01 21:44:29 +0000398 const auto& [status, displayContentSamplingAttributes] =
399 mComposerClient->getDisplayedContentSamplingAttributes(getPrimaryDisplayId());
ramindanid5751092022-04-22 22:30:20 +0000400 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
401 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindanideb059e2021-11-18 01:57:25 +0000402 SUCCEED() << "Sampling attributes aren't supported on this device, test skipped";
403 return;
404 }
ramindani592b6512021-10-08 21:15:19 +0000405
ramindani431aad42022-02-01 21:44:29 +0000406 int64_t constexpr kMaxFrames = 10;
407 int64_t constexpr kTimestamp = 0;
408 const auto& [sampleStatus, displayContentSample] = mComposerClient->getDisplayedContentSample(
409 getPrimaryDisplayId(), kMaxFrames, kTimestamp);
ramindanid5751092022-04-22 22:30:20 +0000410 if (!sampleStatus.isOk() && sampleStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
ramindani431aad42022-02-01 21:44:29 +0000411 sampleStatus.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
ramindani592b6512021-10-08 21:15:19 +0000412 SUCCEED() << "Device does not support optional extension. Test skipped";
413 return;
414 }
415
ramindani431aad42022-02-01 21:44:29 +0000416 EXPECT_TRUE(sampleStatus.isOk());
417 const std::vector<std::vector<int64_t>> histogram = {
ramindani592b6512021-10-08 21:15:19 +0000418 displayContentSample.sampleComponent0, displayContentSample.sampleComponent1,
419 displayContentSample.sampleComponent2, displayContentSample.sampleComponent3};
420
ramindani3335f7a2021-10-25 17:22:35 +0000421 for (size_t i = 0; i < histogram.size(); i++) {
422 const bool shouldHaveHistogram =
423 static_cast<int>(displayContentSamplingAttributes.componentMask) & (1 << i);
424 EXPECT_EQ(shouldHaveHistogram, !histogram[i].empty());
ramindani592b6512021-10-08 21:15:19 +0000425 }
426}
427
ramindani431aad42022-02-01 21:44:29 +0000428TEST_P(GraphicsComposerAidlTest, GetDisplayConnectionType) {
429 const auto& [status, type] = mComposerClient->getDisplayConnectionType(getInvalidDisplayId());
430
431 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000432 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani431aad42022-02-01 21:44:29 +0000433
ramindani0291f112021-11-04 03:45:46 +0000434 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000435 const auto& [connectionTypeStatus, _] =
436 mComposerClient->getDisplayConnectionType(display.getDisplayId());
437 EXPECT_TRUE(connectionTypeStatus.isOk());
ramindani0291f112021-11-04 03:45:46 +0000438 }
439}
440
ramindani431aad42022-02-01 21:44:29 +0000441TEST_P(GraphicsComposerAidlTest, GetDisplayAttribute) {
ramindani0291f112021-11-04 03:45:46 +0000442 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000443 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
444 EXPECT_TRUE(status.isOk());
445
ramindani0291f112021-11-04 03:45:46 +0000446 for (const auto& config : configs) {
447 const std::array<DisplayAttribute, 4> requiredAttributes = {{
448 DisplayAttribute::WIDTH,
449 DisplayAttribute::HEIGHT,
450 DisplayAttribute::VSYNC_PERIOD,
451 DisplayAttribute::CONFIG_GROUP,
452 }};
ramindani0291f112021-11-04 03:45:46 +0000453 for (const auto& attribute : requiredAttributes) {
ramindani431aad42022-02-01 21:44:29 +0000454 const auto& [attribStatus, value] = mComposerClient->getDisplayAttribute(
455 display.getDisplayId(), config, attribute);
456 EXPECT_TRUE(attribStatus.isOk());
ramindani0291f112021-11-04 03:45:46 +0000457 EXPECT_NE(-1, value);
458 }
459
460 const std::array<DisplayAttribute, 2> optionalAttributes = {{
461 DisplayAttribute::DPI_X,
462 DisplayAttribute::DPI_Y,
463 }};
464 for (const auto& attribute : optionalAttributes) {
ramindani431aad42022-02-01 21:44:29 +0000465 const auto& [attribStatus, value] = mComposerClient->getDisplayAttribute(
466 display.getDisplayId(), config, attribute);
ramindanid5751092022-04-22 22:30:20 +0000467 EXPECT_TRUE(attribStatus.isOk() ||
468 (attribStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
469 IComposerClient::EX_UNSUPPORTED ==
470 attribStatus.getServiceSpecificError()));
ramindani0291f112021-11-04 03:45:46 +0000471 }
472 }
473 }
474}
475
ramindani431aad42022-02-01 21:44:29 +0000476TEST_P(GraphicsComposerAidlTest, CheckConfigsAreValid) {
ramindani0291f112021-11-04 03:45:46 +0000477 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000478 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
479 EXPECT_TRUE(status.isOk());
ramindani0291f112021-11-04 03:45:46 +0000480
481 EXPECT_FALSE(std::any_of(configs.begin(), configs.end(), [](auto config) {
482 return config == IComposerClient::INVALID_CONFIGURATION;
483 }));
484 }
485}
486
ramindani431aad42022-02-01 21:44:29 +0000487TEST_P(GraphicsComposerAidlTest, GetDisplayVsyncPeriod_BadDisplay) {
488 const auto& [status, vsyncPeriodNanos] =
489 mComposerClient->getDisplayVsyncPeriod(getInvalidDisplayId());
490
491 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000492 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani0291f112021-11-04 03:45:46 +0000493}
494
ramindani431aad42022-02-01 21:44:29 +0000495TEST_P(GraphicsComposerAidlTest, SetActiveConfigWithConstraints_BadDisplay) {
ramindani0291f112021-11-04 03:45:46 +0000496 VsyncPeriodChangeConstraints constraints;
ramindani0291f112021-11-04 03:45:46 +0000497 constraints.seamlessRequired = false;
498 constraints.desiredTimeNanos = systemTime();
ramindani431aad42022-02-01 21:44:29 +0000499 auto invalidDisplay = VtsDisplay(getInvalidDisplayId());
ramindani0291f112021-11-04 03:45:46 +0000500
ramindani431aad42022-02-01 21:44:29 +0000501 const auto& [status, timeline] = mComposerClient->setActiveConfigWithConstraints(
502 &invalidDisplay, /*config*/ 0, constraints);
503
504 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000505 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani0291f112021-11-04 03:45:46 +0000506}
507
ramindani431aad42022-02-01 21:44:29 +0000508TEST_P(GraphicsComposerAidlTest, SetActiveConfigWithConstraints_BadConfig) {
ramindani0291f112021-11-04 03:45:46 +0000509 VsyncPeriodChangeConstraints constraints;
ramindani0291f112021-11-04 03:45:46 +0000510 constraints.seamlessRequired = false;
511 constraints.desiredTimeNanos = systemTime();
512
513 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000514 int32_t constexpr kInvalidConfigId = IComposerClient::INVALID_CONFIGURATION;
515 const auto& [status, _] = mComposerClient->setActiveConfigWithConstraints(
516 &display, kInvalidConfigId, constraints);
517
518 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000519 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_CONFIG));
ramindani0291f112021-11-04 03:45:46 +0000520 }
521}
522
ramindani431aad42022-02-01 21:44:29 +0000523TEST_P(GraphicsComposerAidlTest, SetBootDisplayConfig_BadDisplay) {
ramindani476314c2022-03-16 00:17:08 +0000524 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
525 GTEST_SUCCEED() << "Boot Display Config not supported";
526 return;
527 }
ramindani431aad42022-02-01 21:44:29 +0000528 const auto& status = mComposerClient->setBootDisplayConfig(getInvalidDisplayId(), /*config*/ 0);
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100529
ramindani431aad42022-02-01 21:44:29 +0000530 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000531 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100532}
533
ramindani431aad42022-02-01 21:44:29 +0000534TEST_P(GraphicsComposerAidlTest, SetBootDisplayConfig_BadConfig) {
ramindani476314c2022-03-16 00:17:08 +0000535 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
536 GTEST_SUCCEED() << "Boot Display Config not supported";
537 return;
538 }
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100539 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000540 int32_t constexpr kInvalidConfigId = IComposerClient::INVALID_CONFIGURATION;
541 const auto& status =
542 mComposerClient->setBootDisplayConfig(display.getDisplayId(), kInvalidConfigId);
543
544 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000545 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_CONFIG));
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100546 }
547}
548
ramindani431aad42022-02-01 21:44:29 +0000549TEST_P(GraphicsComposerAidlTest, SetBootDisplayConfig) {
ramindani476314c2022-03-16 00:17:08 +0000550 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
551 GTEST_SUCCEED() << "Boot Display Config not supported";
552 return;
553 }
ramindani431aad42022-02-01 21:44:29 +0000554 const auto& [status, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
555 EXPECT_TRUE(status.isOk());
556 for (const auto& config : configs) {
557 EXPECT_TRUE(mComposerClient->setBootDisplayConfig(getPrimaryDisplayId(), config).isOk());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100558 }
559}
560
ramindani431aad42022-02-01 21:44:29 +0000561TEST_P(GraphicsComposerAidlTest, ClearBootDisplayConfig_BadDisplay) {
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 = mComposerClient->clearBootDisplayConfig(getInvalidDisplayId());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100567
ramindani431aad42022-02-01 21:44:29 +0000568 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000569 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100570}
571
ramindani431aad42022-02-01 21:44:29 +0000572TEST_P(GraphicsComposerAidlTest, ClearBootDisplayConfig) {
ramindani476314c2022-03-16 00:17:08 +0000573 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
574 GTEST_SUCCEED() << "Boot Display Config not supported";
575 return;
576 }
ramindani431aad42022-02-01 21:44:29 +0000577 EXPECT_TRUE(mComposerClient->clearBootDisplayConfig(getPrimaryDisplayId()).isOk());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100578}
579
ramindani431aad42022-02-01 21:44:29 +0000580TEST_P(GraphicsComposerAidlTest, GetPreferredBootDisplayConfig_BadDisplay) {
ramindani476314c2022-03-16 00:17:08 +0000581 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
582 GTEST_SUCCEED() << "Boot Display Config not supported";
583 return;
584 }
ramindani431aad42022-02-01 21:44:29 +0000585 const auto& [status, _] = mComposerClient->getPreferredBootDisplayConfig(getInvalidDisplayId());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100586
ramindani431aad42022-02-01 21:44:29 +0000587 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000588 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100589}
590
ramindani431aad42022-02-01 21:44:29 +0000591TEST_P(GraphicsComposerAidlTest, GetPreferredBootDisplayConfig) {
ramindani476314c2022-03-16 00:17:08 +0000592 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
593 GTEST_SUCCEED() << "Boot Display Config not supported";
594 return;
595 }
ramindani431aad42022-02-01 21:44:29 +0000596 const auto& [status, preferredDisplayConfig] =
597 mComposerClient->getPreferredBootDisplayConfig(getPrimaryDisplayId());
598 EXPECT_TRUE(status.isOk());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100599
ramindani431aad42022-02-01 21:44:29 +0000600 const auto& [configStatus, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
601
602 EXPECT_TRUE(configStatus.isOk());
Kriti Dang4c6e9eb2021-11-17 14:56:29 +0100603 EXPECT_NE(configs.end(), std::find(configs.begin(), configs.end(), preferredDisplayConfig));
604}
605
ramindani476314c2022-03-16 00:17:08 +0000606TEST_P(GraphicsComposerAidlTest, BootDisplayConfig_Unsupported) {
607 if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
608 const auto& [configStatus, config] =
609 mComposerClient->getActiveConfig(getPrimaryDisplayId());
610 EXPECT_TRUE(configStatus.isOk());
611
612 auto status = mComposerClient->setBootDisplayConfig(getPrimaryDisplayId(), config);
613 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000614 EXPECT_NO_FATAL_FAILURE(
615 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
ramindani476314c2022-03-16 00:17:08 +0000616
617 status = mComposerClient->getPreferredBootDisplayConfig(getPrimaryDisplayId()).first;
618 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000619 EXPECT_NO_FATAL_FAILURE(
620 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
ramindani476314c2022-03-16 00:17:08 +0000621
622 status = mComposerClient->clearBootDisplayConfig(getPrimaryDisplayId());
623 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000624 EXPECT_NO_FATAL_FAILURE(
625 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
ramindani476314c2022-03-16 00:17:08 +0000626 }
627}
628
Kriti Dang3793ebd2022-12-05 13:03:49 +0100629TEST_P(GraphicsComposerAidlTest, GetHdrConversionCapabilities) {
630 if (!hasCapability(Capability::HDR_OUTPUT_CONVERSION_CONFIG)) {
631 GTEST_SUCCEED() << "HDR output conversion not supported";
632 return;
633 }
634 const auto& [status, conversionCapabilities] = mComposerClient->getHdrConversionCapabilities();
635 EXPECT_TRUE(status.isOk());
636}
637
638TEST_P(GraphicsComposerAidlTest, SetHdrConversionStrategy_Passthrough) {
639 if (!hasCapability(Capability::HDR_OUTPUT_CONVERSION_CONFIG)) {
640 GTEST_SUCCEED() << "HDR output conversion not supported";
641 return;
642 }
643 common::HdrConversionStrategy hdrConversionStrategy;
644 hdrConversionStrategy.set<common::HdrConversionStrategy::Tag::passthrough>(true);
Kriti Dang37622762023-02-09 18:15:37 +0100645 const auto& [status, preferredHdrOutputType] =
646 mComposerClient->setHdrConversionStrategy(hdrConversionStrategy);
Kriti Dang3793ebd2022-12-05 13:03:49 +0100647 EXPECT_TRUE(status.isOk());
Kriti Dang37622762023-02-09 18:15:37 +0100648 EXPECT_EQ(common::Hdr::INVALID, preferredHdrOutputType);
Kriti Dang3793ebd2022-12-05 13:03:49 +0100649}
650
651TEST_P(GraphicsComposerAidlTest, SetHdrConversionStrategy_Force) {
652 if (!hasCapability(Capability::HDR_OUTPUT_CONVERSION_CONFIG)) {
653 GTEST_SUCCEED() << "HDR output conversion not supported";
654 return;
655 }
656 const auto& [status, conversionCapabilities] = mComposerClient->getHdrConversionCapabilities();
Kriti Dang79bbec92023-05-04 17:54:26 +0200657 const auto& [status2, hdrCapabilities] =
658 mComposerClient->getHdrCapabilities(getPrimaryDisplayId());
659 const auto& hdrTypes = hdrCapabilities.types;
Kriti Dang3793ebd2022-12-05 13:03:49 +0100660 for (auto conversionCapability : conversionCapabilities) {
Kriti Dang5fcddd72023-03-07 14:55:51 +0100661 if (conversionCapability.outputType != common::Hdr::INVALID) {
Kriti Dang79bbec92023-05-04 17:54:26 +0200662 if (std::find(hdrTypes.begin(), hdrTypes.end(), conversionCapability.outputType) ==
663 hdrTypes.end()) {
664 continue;
665 }
Kriti Dang3793ebd2022-12-05 13:03:49 +0100666 common::HdrConversionStrategy hdrConversionStrategy;
667 hdrConversionStrategy.set<common::HdrConversionStrategy::Tag::forceHdrConversion>(
Kriti Dang5fcddd72023-03-07 14:55:51 +0100668 conversionCapability.outputType);
Kriti Dang37622762023-02-09 18:15:37 +0100669 const auto& [statusSet, preferredHdrOutputType] =
Kriti Dang3793ebd2022-12-05 13:03:49 +0100670 mComposerClient->setHdrConversionStrategy(hdrConversionStrategy);
Kriti Dang37622762023-02-09 18:15:37 +0100671 EXPECT_TRUE(statusSet.isOk());
672 EXPECT_EQ(common::Hdr::INVALID, preferredHdrOutputType);
Kriti Dang3793ebd2022-12-05 13:03:49 +0100673 }
674 }
675}
676
677TEST_P(GraphicsComposerAidlTest, SetHdrConversionStrategy_Auto) {
678 if (!hasCapability(Capability::HDR_OUTPUT_CONVERSION_CONFIG)) {
679 GTEST_SUCCEED() << "HDR output conversion not supported";
680 return;
681 }
682 const auto& [status, conversionCapabilities] = mComposerClient->getHdrConversionCapabilities();
Kriti Dang79bbec92023-05-04 17:54:26 +0200683 const auto& [status2, hdrCapabilities] =
684 mComposerClient->getHdrCapabilities(getPrimaryDisplayId());
685 if (hdrCapabilities.types.size() <= 0) {
686 return;
687 }
Kriti Dang3793ebd2022-12-05 13:03:49 +0100688 std::vector<aidl::android::hardware::graphics::common::Hdr> autoHdrTypes;
689 for (auto conversionCapability : conversionCapabilities) {
Kriti Dang5fcddd72023-03-07 14:55:51 +0100690 if (conversionCapability.outputType != common::Hdr::INVALID) {
691 autoHdrTypes.push_back(conversionCapability.outputType);
Kriti Dang3793ebd2022-12-05 13:03:49 +0100692 }
693 }
694 common::HdrConversionStrategy hdrConversionStrategy;
695 hdrConversionStrategy.set<common::HdrConversionStrategy::Tag::autoAllowedHdrTypes>(
696 autoHdrTypes);
Kriti Dang37622762023-02-09 18:15:37 +0100697 const auto& [statusSet, preferredHdrOutputType] =
698 mComposerClient->setHdrConversionStrategy(hdrConversionStrategy);
699 EXPECT_TRUE(statusSet.isOk());
700 EXPECT_NE(common::Hdr::INVALID, preferredHdrOutputType);
Kriti Dang3793ebd2022-12-05 13:03:49 +0100701}
702
ramindani431aad42022-02-01 21:44:29 +0000703TEST_P(GraphicsComposerAidlTest, SetAutoLowLatencyMode_BadDisplay) {
704 auto status = mComposerClient->setAutoLowLatencyMode(getInvalidDisplayId(), /*isEnabled*/ true);
705 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000706 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani431aad42022-02-01 21:44:29 +0000707
708 status = mComposerClient->setAutoLowLatencyMode(getInvalidDisplayId(), /*isEnabled*/ false);
709 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000710 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani0291f112021-11-04 03:45:46 +0000711}
712
ramindani431aad42022-02-01 21:44:29 +0000713TEST_P(GraphicsComposerAidlTest, SetAutoLowLatencyMode) {
ramindani0291f112021-11-04 03:45:46 +0000714 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000715 const auto& [status, capabilities] =
716 mComposerClient->getDisplayCapabilities(display.getDisplayId());
717 ASSERT_TRUE(status.isOk());
ramindani0291f112021-11-04 03:45:46 +0000718
719 const bool allmSupport =
720 std::find(capabilities.begin(), capabilities.end(),
721 DisplayCapability::AUTO_LOW_LATENCY_MODE) != capabilities.end();
722
723 if (!allmSupport) {
ramindani431aad42022-02-01 21:44:29 +0000724 const auto& statusIsOn = mComposerClient->setAutoLowLatencyMode(display.getDisplayId(),
725 /*isEnabled*/ true);
726 EXPECT_FALSE(statusIsOn.isOk());
ramindanid5751092022-04-22 22:30:20 +0000727 EXPECT_NO_FATAL_FAILURE(
728 assertServiceSpecificError(statusIsOn, IComposerClient::EX_UNSUPPORTED));
ramindani431aad42022-02-01 21:44:29 +0000729 const auto& statusIsOff = mComposerClient->setAutoLowLatencyMode(display.getDisplayId(),
730 /*isEnabled*/ false);
731 EXPECT_FALSE(statusIsOff.isOk());
ramindanid5751092022-04-22 22:30:20 +0000732 EXPECT_NO_FATAL_FAILURE(
733 assertServiceSpecificError(statusIsOff, IComposerClient::EX_UNSUPPORTED));
ramindani0291f112021-11-04 03:45:46 +0000734 GTEST_SUCCEED() << "Auto Low Latency Mode is not supported on display "
ramindani431aad42022-02-01 21:44:29 +0000735 << std::to_string(display.getDisplayId()) << ", skipping test";
ramindani0291f112021-11-04 03:45:46 +0000736 return;
737 }
738
ramindani431aad42022-02-01 21:44:29 +0000739 EXPECT_TRUE(mComposerClient->setAutoLowLatencyMode(display.getDisplayId(), true).isOk());
740 EXPECT_TRUE(mComposerClient->setAutoLowLatencyMode(display.getDisplayId(), false).isOk());
ramindani0291f112021-11-04 03:45:46 +0000741 }
742}
743
ramindani431aad42022-02-01 21:44:29 +0000744TEST_P(GraphicsComposerAidlTest, GetSupportedContentTypes_BadDisplay) {
745 const auto& [status, _] = mComposerClient->getSupportedContentTypes(getInvalidDisplayId());
746
747 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000748 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani0291f112021-11-04 03:45:46 +0000749}
750
ramindani431aad42022-02-01 21:44:29 +0000751TEST_P(GraphicsComposerAidlTest, GetSupportedContentTypes) {
ramindani0291f112021-11-04 03:45:46 +0000752 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000753 const auto& [status, supportedContentTypes] =
754 mComposerClient->getSupportedContentTypes(display.getDisplayId());
755 ASSERT_TRUE(status.isOk());
ramindani0291f112021-11-04 03:45:46 +0000756
757 const bool noneSupported =
758 std::find(supportedContentTypes.begin(), supportedContentTypes.end(),
759 ContentType::NONE) != supportedContentTypes.end();
ramindani431aad42022-02-01 21:44:29 +0000760
ramindani0291f112021-11-04 03:45:46 +0000761 EXPECT_FALSE(noneSupported);
762 }
763}
764
ramindani431aad42022-02-01 21:44:29 +0000765TEST_P(GraphicsComposerAidlTest, SetContentTypeNoneAlwaysAccepted) {
ramindani0291f112021-11-04 03:45:46 +0000766 for (const auto& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +0000767 EXPECT_TRUE(
768 mComposerClient->setContentType(display.getDisplayId(), ContentType::NONE).isOk());
ramindani0291f112021-11-04 03:45:46 +0000769 }
770}
771
ramindani431aad42022-02-01 21:44:29 +0000772TEST_P(GraphicsComposerAidlTest, SetContentType_BadDisplay) {
ramindani0291f112021-11-04 03:45:46 +0000773 constexpr ContentType types[] = {ContentType::NONE, ContentType::GRAPHICS, ContentType::PHOTO,
774 ContentType::CINEMA, ContentType::GAME};
775 for (const auto& type : types) {
ramindani431aad42022-02-01 21:44:29 +0000776 const auto& status = mComposerClient->setContentType(getInvalidDisplayId(), type);
ramindani0291f112021-11-04 03:45:46 +0000777
ramindani431aad42022-02-01 21:44:29 +0000778 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000779 EXPECT_NO_FATAL_FAILURE(
780 assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani0291f112021-11-04 03:45:46 +0000781 }
782}
783
ramindani431aad42022-02-01 21:44:29 +0000784TEST_P(GraphicsComposerAidlTest, SetGraphicsContentType) {
ramindani0291f112021-11-04 03:45:46 +0000785 Test_setContentType(ContentType::GRAPHICS, "GRAPHICS");
786}
787
ramindani431aad42022-02-01 21:44:29 +0000788TEST_P(GraphicsComposerAidlTest, SetPhotoContentType) {
ramindani0291f112021-11-04 03:45:46 +0000789 Test_setContentType(ContentType::PHOTO, "PHOTO");
790}
791
ramindani431aad42022-02-01 21:44:29 +0000792TEST_P(GraphicsComposerAidlTest, SetCinemaContentType) {
ramindani0291f112021-11-04 03:45:46 +0000793 Test_setContentType(ContentType::CINEMA, "CINEMA");
794}
795
ramindani431aad42022-02-01 21:44:29 +0000796TEST_P(GraphicsComposerAidlTest, SetGameContentType) {
ramindani0291f112021-11-04 03:45:46 +0000797 Test_setContentType(ContentType::GAME, "GAME");
798}
799
ramindanic2b8d082021-11-06 02:03:50 +0000800TEST_P(GraphicsComposerAidlTest, CreateVirtualDisplay) {
ramindani431aad42022-02-01 21:44:29 +0000801 const auto& [status, maxVirtualDisplayCount] = mComposerClient->getMaxVirtualDisplayCount();
802 EXPECT_TRUE(status.isOk());
803
ramindanic2b8d082021-11-06 02:03:50 +0000804 if (maxVirtualDisplayCount == 0) {
805 GTEST_SUCCEED() << "no virtual display support";
806 return;
807 }
808
ramindani431aad42022-02-01 21:44:29 +0000809 const auto& [virtualDisplayStatus, virtualDisplay] = mComposerClient->createVirtualDisplay(
810 /*width*/ 64, /*height*/ 64, common::PixelFormat::IMPLEMENTATION_DEFINED,
811 kBufferSlotCount);
ramindanic2b8d082021-11-06 02:03:50 +0000812
ramindani431aad42022-02-01 21:44:29 +0000813 ASSERT_TRUE(virtualDisplayStatus.isOk());
ramindanic2b8d082021-11-06 02:03:50 +0000814 EXPECT_TRUE(mComposerClient->destroyVirtualDisplay(virtualDisplay.display).isOk());
815}
816
ramindani431aad42022-02-01 21:44:29 +0000817TEST_P(GraphicsComposerAidlTest, DestroyVirtualDisplay_BadDisplay) {
818 const auto& [status, maxDisplayCount] = mComposerClient->getMaxVirtualDisplayCount();
819 EXPECT_TRUE(status.isOk());
820
ramindani2740bac2021-11-24 22:58:32 +0000821 if (maxDisplayCount == 0) {
822 GTEST_SUCCEED() << "no virtual display support";
823 return;
824 }
ramindani2740bac2021-11-24 22:58:32 +0000825
ramindani431aad42022-02-01 21:44:29 +0000826 const auto& destroyStatus = mComposerClient->destroyVirtualDisplay(getInvalidDisplayId());
827
828 EXPECT_FALSE(destroyStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000829 EXPECT_NO_FATAL_FAILURE(
830 assertServiceSpecificError(destroyStatus, IComposerClient::EX_BAD_DISPLAY));
ramindani2740bac2021-11-24 22:58:32 +0000831}
832
833TEST_P(GraphicsComposerAidlTest, CreateLayer) {
ramindani431aad42022-02-01 21:44:29 +0000834 const auto& [status, layer] =
835 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
ramindani2740bac2021-11-24 22:58:32 +0000836
ramindani431aad42022-02-01 21:44:29 +0000837 EXPECT_TRUE(status.isOk());
838 EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
ramindani2740bac2021-11-24 22:58:32 +0000839}
840
ramindani431aad42022-02-01 21:44:29 +0000841TEST_P(GraphicsComposerAidlTest, CreateLayer_BadDisplay) {
842 const auto& [status, _] = mComposerClient->createLayer(getInvalidDisplayId(), kBufferSlotCount);
ramindani2740bac2021-11-24 22:58:32 +0000843
ramindani431aad42022-02-01 21:44:29 +0000844 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000845 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani2740bac2021-11-24 22:58:32 +0000846}
847
ramindani431aad42022-02-01 21:44:29 +0000848TEST_P(GraphicsComposerAidlTest, DestroyLayer_BadDisplay) {
849 const auto& [status, layer] =
850 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
851 EXPECT_TRUE(status.isOk());
ramindani2740bac2021-11-24 22:58:32 +0000852
ramindani431aad42022-02-01 21:44:29 +0000853 const auto& destroyStatus = mComposerClient->destroyLayer(getInvalidDisplayId(), layer);
ramindani2740bac2021-11-24 22:58:32 +0000854
ramindani431aad42022-02-01 21:44:29 +0000855 EXPECT_FALSE(destroyStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000856 EXPECT_NO_FATAL_FAILURE(
857 assertServiceSpecificError(destroyStatus, IComposerClient::EX_BAD_DISPLAY));
ramindani431aad42022-02-01 21:44:29 +0000858 ASSERT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
ramindani2740bac2021-11-24 22:58:32 +0000859}
860
ramindani431aad42022-02-01 21:44:29 +0000861TEST_P(GraphicsComposerAidlTest, DestroyLayer_BadLayerError) {
ramindani2740bac2021-11-24 22:58:32 +0000862 // We haven't created any layers yet, so any id should be invalid
ramindani431aad42022-02-01 21:44:29 +0000863 const auto& status = mComposerClient->destroyLayer(getPrimaryDisplayId(), /*layer*/ 1);
ramindani2740bac2021-11-24 22:58:32 +0000864
ramindani431aad42022-02-01 21:44:29 +0000865 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000866 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_LAYER));
ramindani2740bac2021-11-24 22:58:32 +0000867}
868
ramindani431aad42022-02-01 21:44:29 +0000869TEST_P(GraphicsComposerAidlTest, GetActiveConfig_BadDisplay) {
870 const auto& [status, _] = mComposerClient->getActiveConfig(getInvalidDisplayId());
ramindani2740bac2021-11-24 22:58:32 +0000871
ramindani431aad42022-02-01 21:44:29 +0000872 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000873 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani2740bac2021-11-24 22:58:32 +0000874}
875
876TEST_P(GraphicsComposerAidlTest, GetDisplayConfig) {
ramindani431aad42022-02-01 21:44:29 +0000877 const auto& [status, _] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
878 EXPECT_TRUE(status.isOk());
ramindani2740bac2021-11-24 22:58:32 +0000879}
880
ramindani431aad42022-02-01 21:44:29 +0000881TEST_P(GraphicsComposerAidlTest, GetDisplayConfig_BadDisplay) {
882 const auto& [status, _] = mComposerClient->getDisplayConfigs(getInvalidDisplayId());
ramindani2740bac2021-11-24 22:58:32 +0000883
ramindani431aad42022-02-01 21:44:29 +0000884 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000885 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindani2740bac2021-11-24 22:58:32 +0000886}
887
888TEST_P(GraphicsComposerAidlTest, GetDisplayName) {
ramindani431aad42022-02-01 21:44:29 +0000889 const auto& [status, _] = mComposerClient->getDisplayName(getPrimaryDisplayId());
890 EXPECT_TRUE(status.isOk());
ramindani2740bac2021-11-24 22:58:32 +0000891}
892
ramindani431aad42022-02-01 21:44:29 +0000893TEST_P(GraphicsComposerAidlTest, GetDisplayPhysicalOrientation_BadDisplay) {
894 const auto& [status, _] = mComposerClient->getDisplayPhysicalOrientation(getInvalidDisplayId());
Ady Abrahamae12e382022-01-13 18:06:21 -0800895
ramindani431aad42022-02-01 21:44:29 +0000896 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +0000897 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
Ady Abrahamae12e382022-01-13 18:06:21 -0800898}
899
900TEST_P(GraphicsComposerAidlTest, GetDisplayPhysicalOrientation) {
901 const auto allowedDisplayOrientations = std::array<Transform, 4>{
902 Transform::NONE,
903 Transform::ROT_90,
904 Transform::ROT_180,
905 Transform::ROT_270,
906 };
907
ramindani431aad42022-02-01 21:44:29 +0000908 const auto& [status, displayOrientation] =
909 mComposerClient->getDisplayPhysicalOrientation(getPrimaryDisplayId());
Ady Abrahamae12e382022-01-13 18:06:21 -0800910
ramindani431aad42022-02-01 21:44:29 +0000911 EXPECT_TRUE(status.isOk());
Ady Abrahamae12e382022-01-13 18:06:21 -0800912 EXPECT_NE(std::find(allowedDisplayOrientations.begin(), allowedDisplayOrientations.end(),
913 displayOrientation),
914 allowedDisplayOrientations.end());
915}
916
ramindani2740bac2021-11-24 22:58:32 +0000917TEST_P(GraphicsComposerAidlTest, SetClientTargetSlotCount) {
ramindani431aad42022-02-01 21:44:29 +0000918 EXPECT_TRUE(mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kBufferSlotCount)
919 .isOk());
ramindani2740bac2021-11-24 22:58:32 +0000920}
921
922TEST_P(GraphicsComposerAidlTest, SetActiveConfig) {
ramindani431aad42022-02-01 21:44:29 +0000923 const auto& [status, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
924 EXPECT_TRUE(status.isOk());
925
926 for (const auto& config : configs) {
927 auto display = getEditablePrimaryDisplay();
928 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config).isOk());
929 const auto& [configStatus, config1] =
930 mComposerClient->getActiveConfig(getPrimaryDisplayId());
931 EXPECT_TRUE(configStatus.isOk());
ramindani2740bac2021-11-24 22:58:32 +0000932 EXPECT_EQ(config, config1);
933 }
934}
935
936TEST_P(GraphicsComposerAidlTest, SetActiveConfigPowerCycle) {
ramindani431aad42022-02-01 21:44:29 +0000937 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
938 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
ramindani2740bac2021-11-24 22:58:32 +0000939
ramindani431aad42022-02-01 21:44:29 +0000940 const auto& [status, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
941 EXPECT_TRUE(status.isOk());
942
943 for (const auto& config : configs) {
944 auto display = getEditablePrimaryDisplay();
945 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config).isOk());
946 const auto& [config1Status, config1] =
947 mComposerClient->getActiveConfig(getPrimaryDisplayId());
948 EXPECT_TRUE(config1Status.isOk());
ramindani2740bac2021-11-24 22:58:32 +0000949 EXPECT_EQ(config, config1);
950
ramindani431aad42022-02-01 21:44:29 +0000951 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
952 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
953 const auto& [config2Status, config2] =
954 mComposerClient->getActiveConfig(getPrimaryDisplayId());
955 EXPECT_TRUE(config2Status.isOk());
956 EXPECT_EQ(config, config2);
ramindani2740bac2021-11-24 22:58:32 +0000957 }
958}
959
ramindani2740bac2021-11-24 22:58:32 +0000960TEST_P(GraphicsComposerAidlTest, SetPowerModeUnsupported) {
ramindani431aad42022-02-01 21:44:29 +0000961 const auto& [status, capabilities] =
962 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
963 ASSERT_TRUE(status.isOk());
964
Ady Abraham6679baf2021-12-08 18:28:27 -0800965 const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
966 DisplayCapability::DOZE) != capabilities.end();
967 const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
968 DisplayCapability::SUSPEND) != capabilities.end();
ramindani2740bac2021-11-24 22:58:32 +0000969
ramindani431aad42022-02-01 21:44:29 +0000970 if (!isDozeSupported) {
971 const auto& powerModeDozeStatus =
972 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE);
973 EXPECT_FALSE(powerModeDozeStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000974 EXPECT_NO_FATAL_FAILURE(
975 assertServiceSpecificError(powerModeDozeStatus, IComposerClient::EX_UNSUPPORTED));
ramindani431aad42022-02-01 21:44:29 +0000976
977 const auto& powerModeDozeSuspendStatus =
978 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE_SUSPEND);
979 EXPECT_FALSE(powerModeDozeSuspendStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000980 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeDozeSuspendStatus,
981 IComposerClient::EX_UNSUPPORTED));
ramindani2740bac2021-11-24 22:58:32 +0000982 }
Ady Abraham6679baf2021-12-08 18:28:27 -0800983
984 if (!isSuspendSupported) {
ramindani431aad42022-02-01 21:44:29 +0000985 const auto& powerModeSuspendStatus =
986 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON_SUSPEND);
987 EXPECT_FALSE(powerModeSuspendStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000988 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeSuspendStatus,
989 IComposerClient::EX_UNSUPPORTED));
Ady Abraham6679baf2021-12-08 18:28:27 -0800990
ramindani431aad42022-02-01 21:44:29 +0000991 const auto& powerModeDozeSuspendStatus =
992 mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE_SUSPEND);
993 EXPECT_FALSE(powerModeDozeSuspendStatus.isOk());
ramindanid5751092022-04-22 22:30:20 +0000994 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeDozeSuspendStatus,
995 IComposerClient::EX_UNSUPPORTED));
Ady Abraham6679baf2021-12-08 18:28:27 -0800996 }
ramindani2740bac2021-11-24 22:58:32 +0000997}
998
999TEST_P(GraphicsComposerAidlTest, SetVsyncEnabled) {
ramindani431aad42022-02-01 21:44:29 +00001000 mComposerClient->setVsyncAllowed(true);
ramindani2740bac2021-11-24 22:58:32 +00001001
ramindani431aad42022-02-01 21:44:29 +00001002 EXPECT_TRUE(mComposerClient->setVsync(getPrimaryDisplayId(), true).isOk());
ramindani2740bac2021-11-24 22:58:32 +00001003 usleep(60 * 1000);
ramindani431aad42022-02-01 21:44:29 +00001004 EXPECT_TRUE(mComposerClient->setVsync(getPrimaryDisplayId(), false).isOk());
ramindani2740bac2021-11-24 22:58:32 +00001005
ramindani431aad42022-02-01 21:44:29 +00001006 mComposerClient->setVsyncAllowed(false);
ramindani2740bac2021-11-24 22:58:32 +00001007}
1008
ramindanic2b8d082021-11-06 02:03:50 +00001009TEST_P(GraphicsComposerAidlTest, SetPowerMode) {
ramindani431aad42022-02-01 21:44:29 +00001010 const auto& [status, capabilities] =
1011 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
1012 ASSERT_TRUE(status.isOk());
1013
Ady Abraham6679baf2021-12-08 18:28:27 -08001014 const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
1015 DisplayCapability::DOZE) != capabilities.end();
1016 const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
1017 DisplayCapability::SUSPEND) != capabilities.end();
1018
ramindanic2b8d082021-11-06 02:03:50 +00001019 std::vector<PowerMode> modes;
1020 modes.push_back(PowerMode::OFF);
ramindanic2b8d082021-11-06 02:03:50 +00001021 modes.push_back(PowerMode::ON);
1022
Ady Abraham6679baf2021-12-08 18:28:27 -08001023 if (isSuspendSupported) {
1024 modes.push_back(PowerMode::ON_SUSPEND);
1025 }
1026
ramindani770d7082021-11-30 00:36:42 +00001027 if (isDozeSupported) {
1028 modes.push_back(PowerMode::DOZE);
Ady Abraham6679baf2021-12-08 18:28:27 -08001029 }
1030
1031 if (isSuspendSupported && isDozeSupported) {
ramindani770d7082021-11-30 00:36:42 +00001032 modes.push_back(PowerMode::DOZE_SUSPEND);
1033 }
1034
ramindanic2b8d082021-11-06 02:03:50 +00001035 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001036 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindanic2b8d082021-11-06 02:03:50 +00001037 }
1038}
1039
1040TEST_P(GraphicsComposerAidlTest, SetPowerModeVariations) {
ramindani431aad42022-02-01 21:44:29 +00001041 const auto& [status, capabilities] =
1042 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
1043 ASSERT_TRUE(status.isOk());
1044
Ady Abraham6679baf2021-12-08 18:28:27 -08001045 const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
1046 DisplayCapability::DOZE) != capabilities.end();
1047 const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
1048 DisplayCapability::SUSPEND) != capabilities.end();
1049
ramindanic2b8d082021-11-06 02:03:50 +00001050 std::vector<PowerMode> modes;
1051
1052 modes.push_back(PowerMode::OFF);
ramindani770d7082021-11-30 00:36:42 +00001053 modes.push_back(PowerMode::ON);
ramindanic2b8d082021-11-06 02:03:50 +00001054 modes.push_back(PowerMode::OFF);
ramindanic2b8d082021-11-06 02:03:50 +00001055 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001056 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindanic2b8d082021-11-06 02:03:50 +00001057 }
ramindani770d7082021-11-30 00:36:42 +00001058 modes.clear();
ramindanic2b8d082021-11-06 02:03:50 +00001059
ramindani770d7082021-11-30 00:36:42 +00001060 modes.push_back(PowerMode::OFF);
1061 modes.push_back(PowerMode::OFF);
1062 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001063 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindani770d7082021-11-30 00:36:42 +00001064 }
ramindanic2b8d082021-11-06 02:03:50 +00001065 modes.clear();
1066
1067 modes.push_back(PowerMode::ON);
1068 modes.push_back(PowerMode::ON);
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 }
ramindanic2b8d082021-11-06 02:03:50 +00001072 modes.clear();
1073
Ady Abraham6679baf2021-12-08 18:28:27 -08001074 if (isSuspendSupported) {
1075 modes.push_back(PowerMode::ON_SUSPEND);
1076 modes.push_back(PowerMode::ON_SUSPEND);
1077 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001078 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
Ady Abraham6679baf2021-12-08 18:28:27 -08001079 }
1080 modes.clear();
ramindanic2b8d082021-11-06 02:03:50 +00001081 }
1082
ramindanic2b8d082021-11-06 02:03:50 +00001083 if (isDozeSupported) {
ramindanic2b8d082021-11-06 02:03:50 +00001084 modes.push_back(PowerMode::DOZE);
1085 modes.push_back(PowerMode::DOZE);
ramindanic2b8d082021-11-06 02:03:50 +00001086 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001087 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindanic2b8d082021-11-06 02:03:50 +00001088 }
ramindanic2b8d082021-11-06 02:03:50 +00001089 modes.clear();
Ady Abraham6679baf2021-12-08 18:28:27 -08001090 }
ramindanic2b8d082021-11-06 02:03:50 +00001091
Ady Abraham6679baf2021-12-08 18:28:27 -08001092 if (isSuspendSupported && isDozeSupported) {
ramindanic2b8d082021-11-06 02:03:50 +00001093 modes.push_back(PowerMode::DOZE_SUSPEND);
1094 modes.push_back(PowerMode::DOZE_SUSPEND);
ramindanic2b8d082021-11-06 02:03:50 +00001095 for (auto mode : modes) {
ramindani431aad42022-02-01 21:44:29 +00001096 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
ramindanic2b8d082021-11-06 02:03:50 +00001097 }
Ady Abraham6679baf2021-12-08 18:28:27 -08001098 modes.clear();
ramindanic2b8d082021-11-06 02:03:50 +00001099 }
1100}
1101
ramindani431aad42022-02-01 21:44:29 +00001102TEST_P(GraphicsComposerAidlTest, SetPowerMode_BadDisplay) {
1103 const auto& status = mComposerClient->setPowerMode(getInvalidDisplayId(), PowerMode::ON);
ramindanic2b8d082021-11-06 02:03:50 +00001104
ramindani431aad42022-02-01 21:44:29 +00001105 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00001106 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
ramindanic2b8d082021-11-06 02:03:50 +00001107}
1108
ramindani431aad42022-02-01 21:44:29 +00001109TEST_P(GraphicsComposerAidlTest, SetPowerMode_BadParameter) {
1110 const auto& status =
1111 mComposerClient->setPowerMode(getPrimaryDisplayId(), static_cast<PowerMode>(-1));
ramindanic2b8d082021-11-06 02:03:50 +00001112
ramindani431aad42022-02-01 21:44:29 +00001113 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00001114 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
ramindanic2b8d082021-11-06 02:03:50 +00001115}
1116
ramindanic2b8d082021-11-06 02:03:50 +00001117TEST_P(GraphicsComposerAidlTest, GetDataspaceSaturationMatrix) {
ramindani431aad42022-02-01 21:44:29 +00001118 const auto& [status, matrix] =
1119 mComposerClient->getDataspaceSaturationMatrix(common::Dataspace::SRGB_LINEAR);
1120 ASSERT_TRUE(status.isOk());
1121 ASSERT_EQ(16, matrix.size()); // matrix should not be empty if call succeeded.
ramindanideb059e2021-11-18 01:57:25 +00001122
ramindanic2b8d082021-11-06 02:03:50 +00001123 // the last row is known
ramindani431aad42022-02-01 21:44:29 +00001124 EXPECT_EQ(0.0f, matrix[12]);
1125 EXPECT_EQ(0.0f, matrix[13]);
1126 EXPECT_EQ(0.0f, matrix[14]);
1127 EXPECT_EQ(1.0f, matrix[15]);
ramindanic2b8d082021-11-06 02:03:50 +00001128}
1129
ramindani431aad42022-02-01 21:44:29 +00001130TEST_P(GraphicsComposerAidlTest, GetDataspaceSaturationMatrix_BadParameter) {
1131 const auto& [status, matrix] =
1132 mComposerClient->getDataspaceSaturationMatrix(common::Dataspace::UNKNOWN);
ramindanic2b8d082021-11-06 02:03:50 +00001133
ramindani431aad42022-02-01 21:44:29 +00001134 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00001135 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
ramindanic2b8d082021-11-06 02:03:50 +00001136}
1137
ramindani12423f52023-06-14 20:04:51 -07001138/*
1139 * Test that no two display configs are exactly the same.
1140 */
1141TEST_P(GraphicsComposerAidlTest, GetDisplayConfigNoRepetitions) {
1142 for (const auto& display : mDisplays) {
1143 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
1144 for (std::vector<int>::size_type i = 0; i < configs.size(); i++) {
1145 for (std::vector<int>::size_type j = i + 1; j < configs.size(); j++) {
1146 const auto& [widthStatus1, width1] = mComposerClient->getDisplayAttribute(
1147 display.getDisplayId(), configs[i], DisplayAttribute::WIDTH);
1148 const auto& [heightStatus1, height1] = mComposerClient->getDisplayAttribute(
1149 display.getDisplayId(), configs[i], DisplayAttribute::HEIGHT);
1150 const auto& [vsyncPeriodStatus1, vsyncPeriod1] =
1151 mComposerClient->getDisplayAttribute(display.getDisplayId(), configs[i],
1152 DisplayAttribute::VSYNC_PERIOD);
1153 const auto& [groupStatus1, group1] = mComposerClient->getDisplayAttribute(
1154 display.getDisplayId(), configs[i], DisplayAttribute::CONFIG_GROUP);
1155
1156 const auto& [widthStatus2, width2] = mComposerClient->getDisplayAttribute(
1157 display.getDisplayId(), configs[j], DisplayAttribute::WIDTH);
1158 const auto& [heightStatus2, height2] = mComposerClient->getDisplayAttribute(
1159 display.getDisplayId(), configs[j], DisplayAttribute::HEIGHT);
1160 const auto& [vsyncPeriodStatus2, vsyncPeriod2] =
1161 mComposerClient->getDisplayAttribute(display.getDisplayId(), configs[j],
1162 DisplayAttribute::VSYNC_PERIOD);
1163 const auto& [groupStatus2, group2] = mComposerClient->getDisplayAttribute(
1164 display.getDisplayId(), configs[j], DisplayAttribute::CONFIG_GROUP);
1165
1166 ASSERT_FALSE(width1 == width2 && height1 == height2 &&
1167 vsyncPeriod1 == vsyncPeriod2 && group1 == group2);
1168 }
1169 }
1170 }
1171}
1172
1173class GraphicsComposerAidlV2Test : public GraphicsComposerAidlTest {
1174 protected:
1175 void SetUp() override {
1176 GraphicsComposerAidlTest::SetUp();
1177 if (getInterfaceVersion() <= 1) {
1178 GTEST_SKIP() << "Device interface version is expected to be >= 2";
1179 }
1180 }
1181};
1182
1183TEST_P(GraphicsComposerAidlV2Test, GetOverlaySupport) {
1184 const auto& [status, properties] = mComposerClient->getOverlaySupport();
1185 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
1186 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
1187 GTEST_SUCCEED() << "getOverlaySupport is not supported";
1188 return;
1189 }
1190
1191 ASSERT_TRUE(status.isOk());
1192 for (const auto& i : properties.combinations) {
1193 for (const auto standard : i.standards) {
1194 const auto val = static_cast<int32_t>(standard) &
1195 static_cast<int32_t>(common::Dataspace::STANDARD_MASK);
1196 ASSERT_TRUE(val == static_cast<int32_t>(standard));
1197 }
1198 for (const auto transfer : i.transfers) {
1199 const auto val = static_cast<int32_t>(transfer) &
1200 static_cast<int32_t>(common::Dataspace::TRANSFER_MASK);
1201 ASSERT_TRUE(val == static_cast<int32_t>(transfer));
1202 }
1203 for (const auto range : i.ranges) {
1204 const auto val = static_cast<int32_t>(range) &
1205 static_cast<int32_t>(common::Dataspace::RANGE_MASK);
1206 ASSERT_TRUE(val == static_cast<int32_t>(range));
1207 }
1208 }
1209}
1210
ramindani02fe4772023-06-30 18:04:41 -07001211class GraphicsComposerAidlV3Test : public GraphicsComposerAidlTest {
1212 protected:
1213 void SetUp() override {
1214 GraphicsComposerAidlTest::SetUp();
1215 if (getInterfaceVersion() <= 2) {
1216 GTEST_SKIP() << "Device interface version is expected to be >= 3";
1217 }
1218 }
1219};
1220
1221TEST_P(GraphicsComposerAidlV3Test, GetDisplayConfigurations) {
1222 for (const auto& display : mDisplays) {
1223 const auto& [status, displayConfigurations] =
1224 mComposerClient->getDisplayConfigurations(display.getDisplayId());
1225 EXPECT_TRUE(status.isOk());
1226 EXPECT_FALSE(displayConfigurations.empty());
1227
1228 for (const auto& displayConfig : displayConfigurations) {
1229 EXPECT_NE(-1, displayConfig.width);
1230 EXPECT_NE(-1, displayConfig.height);
1231 EXPECT_NE(-1, displayConfig.vsyncPeriod);
1232 EXPECT_NE(-1, displayConfig.configGroup);
1233 if (displayConfig.dpi) {
ramindani2b2ec502023-08-25 18:47:38 -07001234 EXPECT_NE(-1.f, displayConfig.dpi->x);
1235 EXPECT_NE(-1.f, displayConfig.dpi->y);
ramindani02fe4772023-06-30 18:04:41 -07001236 }
ramindani2704c5f2023-07-18 20:53:24 -07001237 if (displayConfig.vrrConfig) {
1238 const auto& vrrConfig = *displayConfig.vrrConfig;
1239 EXPECT_GE(vrrConfig.minFrameIntervalNs, displayConfig.vsyncPeriod);
1240
ramindani2b2ec502023-08-25 18:47:38 -07001241 EXPECT_EQ(1, std::count_if(
1242 displayConfigurations.cbegin(), displayConfigurations.cend(),
1243 [displayConfig](const auto& config) {
1244 return config.configGroup == displayConfig.configGroup;
1245 }))
1246 << "There should be only one VRR mode in one ConfigGroup";
1247
ramindani2704c5f2023-07-18 20:53:24 -07001248 const auto verifyFrameIntervalIsDivisorOfVsync = [&](int32_t frameIntervalNs) {
1249 constexpr auto kThreshold = 0.05f; // 5%
1250 const auto ratio =
1251 static_cast<float>(frameIntervalNs) / displayConfig.vsyncPeriod;
1252 return ratio - std::round(ratio) <= kThreshold;
1253 };
1254
1255 EXPECT_TRUE(verifyFrameIntervalIsDivisorOfVsync(vrrConfig.minFrameIntervalNs));
1256
1257 if (vrrConfig.frameIntervalPowerHints) {
1258 const auto& frameIntervalPowerHints = *vrrConfig.frameIntervalPowerHints;
1259 EXPECT_FALSE(frameIntervalPowerHints.empty());
1260
1261 const auto minFrameInterval = *min_element(frameIntervalPowerHints.cbegin(),
1262 frameIntervalPowerHints.cend());
1263 EXPECT_LE(minFrameInterval->frameIntervalNs,
1264 VtsComposerClient::kMaxFrameIntervalNs);
1265
1266 EXPECT_TRUE(std::all_of(frameIntervalPowerHints.cbegin(),
1267 frameIntervalPowerHints.cend(),
1268 [&](const auto& frameIntervalPowerHint) {
1269 return verifyFrameIntervalIsDivisorOfVsync(
1270 frameIntervalPowerHint->frameIntervalNs);
1271 }));
1272 }
1273
1274 if (vrrConfig.notifyExpectedPresentConfig) {
1275 const auto& notifyExpectedPresentConfig =
1276 *vrrConfig.notifyExpectedPresentConfig;
1277 EXPECT_GT(0, notifyExpectedPresentConfig.notifyExpectedPresentHeadsUpNs);
1278 EXPECT_GE(0, notifyExpectedPresentConfig.notifyExpectedPresentTimeoutNs);
1279 }
1280 }
ramindani02fe4772023-06-30 18:04:41 -07001281 }
1282 }
1283}
1284
1285TEST_P(GraphicsComposerAidlV3Test, GetDisplayConfigsIsSubsetOfGetDisplayConfigurations) {
1286 for (const auto& display : mDisplays) {
1287 const auto& [status, displayConfigurations] =
1288 mComposerClient->getDisplayConfigurations(display.getDisplayId());
1289 EXPECT_TRUE(status.isOk());
1290
1291 const auto& [legacyConfigStatus, legacyConfigs] =
1292 mComposerClient->getDisplayConfigs(display.getDisplayId());
1293 EXPECT_TRUE(legacyConfigStatus.isOk());
1294 EXPECT_FALSE(legacyConfigs.empty());
1295 EXPECT_TRUE(legacyConfigs.size() <= displayConfigurations.size());
1296
1297 for (const auto legacyConfigId : legacyConfigs) {
1298 const auto& legacyWidth = mComposerClient->getDisplayAttribute(
1299 display.getDisplayId(), legacyConfigId, DisplayAttribute::WIDTH);
1300 const auto& legacyHeight = mComposerClient->getDisplayAttribute(
1301 display.getDisplayId(), legacyConfigId, DisplayAttribute::HEIGHT);
1302 const auto& legacyVsyncPeriod = mComposerClient->getDisplayAttribute(
1303 display.getDisplayId(), legacyConfigId, DisplayAttribute::VSYNC_PERIOD);
1304 const auto& legacyConfigGroup = mComposerClient->getDisplayAttribute(
1305 display.getDisplayId(), legacyConfigId, DisplayAttribute::CONFIG_GROUP);
1306 const auto& legacyDpiX = mComposerClient->getDisplayAttribute(
1307 display.getDisplayId(), legacyConfigId, DisplayAttribute::DPI_X);
1308 const auto& legacyDpiY = mComposerClient->getDisplayAttribute(
1309 display.getDisplayId(), legacyConfigId, DisplayAttribute::DPI_Y);
1310
1311 EXPECT_TRUE(legacyWidth.first.isOk() && legacyHeight.first.isOk() &&
1312 legacyVsyncPeriod.first.isOk() && legacyConfigGroup.first.isOk());
1313
1314 EXPECT_TRUE(std::any_of(
1315 displayConfigurations.begin(), displayConfigurations.end(),
1316 [&](const auto& displayConfiguration) {
1317 const bool requiredAttributesPredicate =
1318 displayConfiguration.configId == legacyConfigId &&
1319 displayConfiguration.width == legacyWidth.second &&
1320 displayConfiguration.height == legacyHeight.second &&
1321 displayConfiguration.vsyncPeriod == legacyVsyncPeriod.second &&
1322 displayConfiguration.configGroup == legacyConfigGroup.second;
1323
1324 if (!requiredAttributesPredicate) {
1325 // Required attributes did not match
1326 return false;
1327 }
1328
1329 // Check optional attributes
1330 const auto& [legacyDpiXStatus, legacyDpiXValue] = legacyDpiX;
1331 const auto& [legacyDpiYStatus, legacyDpiYValue] = legacyDpiY;
1332 if (displayConfiguration.dpi) {
1333 if (!legacyDpiXStatus.isOk() || !legacyDpiYStatus.isOk()) {
1334 // getDisplayAttribute failed for optional attributes
1335 return false;
1336 }
1337
1338 // DPI values in DisplayConfigurations are not scaled (* 1000.f)
1339 // the way they are in the legacy DisplayConfigs.
1340 constexpr float kEpsilon = 0.001f;
1341 return std::abs(displayConfiguration.dpi->x -
1342 legacyDpiXValue / 1000.f) < kEpsilon &&
1343 std::abs(displayConfiguration.dpi->y -
1344 legacyDpiYValue / 1000.f) < kEpsilon;
1345 } else {
1346 return !legacyDpiXStatus.isOk() && !legacyDpiYStatus.isOk() &&
1347 EX_SERVICE_SPECIFIC == legacyDpiXStatus.getExceptionCode() &&
1348 EX_SERVICE_SPECIFIC == legacyDpiYStatus.getExceptionCode() &&
1349 IComposerClient::EX_UNSUPPORTED ==
1350 legacyDpiXStatus.getServiceSpecificError() &&
1351 IComposerClient::EX_UNSUPPORTED ==
1352 legacyDpiYStatus.getServiceSpecificError();
1353 }
1354 }));
1355 }
1356 }
1357}
1358
ramindani2704c5f2023-07-18 20:53:24 -07001359// TODO(b/291792736) Add detailed VTS test cases for NotifyExpectedPresent
1360TEST_P(GraphicsComposerAidlV3Test, NotifyExpectedPresent) {
1361 for (const auto& display : mDisplays) {
1362 EXPECT_TRUE(mComposerClient
1363 ->notifyExpectedPresent(display.getDisplayId(),
1364 ClockMonotonicTimestamp{0},
1365 std::chrono::nanoseconds{8ms}.count())
1366 .isOk());
1367 }
1368}
1369
ramindanidcfe3a82021-11-29 17:00:31 +00001370// Tests for Command.
1371class GraphicsComposerAidlCommandTest : public GraphicsComposerAidlTest {
1372 protected:
ramindanidcfe3a82021-11-29 17:00:31 +00001373 void TearDown() override {
Ady Abraham3192f3d2021-12-03 16:08:56 -08001374 const auto errors = mReader.takeErrors();
1375 ASSERT_TRUE(mReader.takeErrors().empty());
ramindani431aad42022-02-01 21:44:29 +00001376 ASSERT_TRUE(mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty());
Ady Abraham3192f3d2021-12-03 16:08:56 -08001377
ramindanidcfe3a82021-11-29 17:00:31 +00001378 ASSERT_NO_FATAL_FAILURE(GraphicsComposerAidlTest::TearDown());
1379 }
1380
1381 void execute() {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001382 std::vector<CommandResultPayload> payloads;
1383 for (auto& [_, writer] : mWriters) {
Huihong Luo651806f2023-04-21 18:48:48 +00001384 auto commands = writer.takePendingCommands();
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001385 if (commands.empty()) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001386 continue;
1387 }
1388
1389 auto [status, results] = mComposerClient->executeCommands(commands);
1390 ASSERT_TRUE(status.isOk()) << "executeCommands failed " << status.getDescription();
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001391
1392 payloads.reserve(payloads.size() + results.size());
1393 payloads.insert(payloads.end(), std::make_move_iterator(results.begin()),
1394 std::make_move_iterator(results.end()));
ramindanidcfe3a82021-11-29 17:00:31 +00001395 }
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001396 mReader.parse(std::move(payloads));
ramindanidcfe3a82021-11-29 17:00:31 +00001397 }
1398
1399 static inline auto toTimePoint(nsecs_t time) {
1400 return std::chrono::time_point<std::chrono::steady_clock>(std::chrono::nanoseconds(time));
1401 }
1402
ramindanidcfe3a82021-11-29 17:00:31 +00001403 void forEachTwoConfigs(int64_t display, std::function<void(int32_t, int32_t)> func) {
ramindani431aad42022-02-01 21:44:29 +00001404 const auto& [status, displayConfigs] = mComposerClient->getDisplayConfigs(display);
1405 ASSERT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001406 for (const int32_t config1 : displayConfigs) {
1407 for (const int32_t config2 : displayConfigs) {
1408 if (config1 != config2) {
1409 func(config1, config2);
1410 }
1411 }
1412 }
1413 }
1414
1415 void waitForVsyncPeriodChange(int64_t display, const VsyncPeriodChangeTimeline& timeline,
1416 int64_t desiredTimeNanos, int64_t oldPeriodNanos,
1417 int64_t newPeriodNanos) {
1418 const auto kChangeDeadline = toTimePoint(timeline.newVsyncAppliedTimeNanos) + 100ms;
1419 while (std::chrono::steady_clock::now() <= kChangeDeadline) {
ramindani431aad42022-02-01 21:44:29 +00001420 const auto& [status, vsyncPeriodNanos] =
1421 mComposerClient->getDisplayVsyncPeriod(display);
1422 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001423 if (systemTime() <= desiredTimeNanos) {
1424 EXPECT_EQ(vsyncPeriodNanos, oldPeriodNanos);
1425 } else if (vsyncPeriodNanos == newPeriodNanos) {
1426 break;
1427 }
1428 std::this_thread::sleep_for(std::chrono::nanoseconds(oldPeriodNanos));
1429 }
1430 }
1431
ramindani9dd8c482023-02-21 18:07:56 -08001432 bool checkIfCallbackRefreshRateChangedDebugEnabledReceived(
1433 std::function<bool(RefreshRateChangedDebugData)> filter) {
1434 const auto list = mComposerClient->takeListOfRefreshRateChangedDebugData();
1435 return std::any_of(list.begin(), list.end(), [&](auto refreshRateChangedDebugData) {
1436 return filter(refreshRateChangedDebugData);
1437 });
1438 }
1439
Brian Lindahl25e0d092022-12-09 00:32:11 -07001440 sp<GraphicBuffer> allocate(uint32_t width, uint32_t height,
1441 ::android::PixelFormat pixelFormat) {
Brian Lindahl14bd07b2023-01-17 14:54:39 -07001442 return sp<GraphicBuffer>::make(
Brian Lindahl25e0d092022-12-09 00:32:11 -07001443 width, height, pixelFormat, /*layerCount*/ 1U,
1444 static_cast<uint64_t>(common::BufferUsage::CPU_WRITE_OFTEN) |
1445 static_cast<uint64_t>(common::BufferUsage::CPU_READ_OFTEN) |
1446 static_cast<uint64_t>(common::BufferUsage::COMPOSER_OVERLAY),
Brian Lindahl14bd07b2023-01-17 14:54:39 -07001447 "VtsHalGraphicsComposer3_TargetTest");
Brian Lindahlca3eef22022-12-09 00:32:11 -07001448 }
1449
Brian Lindahl25e0d092022-12-09 00:32:11 -07001450 sp<GraphicBuffer> allocate(::android::PixelFormat pixelFormat) {
1451 return allocate(static_cast<uint32_t>(getPrimaryDisplay().getDisplayWidth()),
1452 static_cast<uint32_t>(getPrimaryDisplay().getDisplayHeight()), pixelFormat);
1453 }
1454
ramindanidcfe3a82021-11-29 17:00:31 +00001455 void sendRefreshFrame(const VtsDisplay& display, const VsyncPeriodChangeTimeline* timeline) {
1456 if (timeline != nullptr) {
1457 // Refresh time should be before newVsyncAppliedTimeNanos
1458 EXPECT_LT(timeline->refreshTimeNanos, timeline->newVsyncAppliedTimeNanos);
1459
1460 std::this_thread::sleep_until(toTimePoint(timeline->refreshTimeNanos));
1461 }
1462
ramindani431aad42022-02-01 21:44:29 +00001463 EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::ON).isOk());
1464 EXPECT_TRUE(mComposerClient
1465 ->setColorMode(display.getDisplayId(), ColorMode::NATIVE,
1466 RenderIntent::COLORIMETRIC)
1467 .isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001468
ramindani431aad42022-02-01 21:44:29 +00001469 const auto& [status, layer] =
1470 mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount);
1471 EXPECT_TRUE(status.isOk());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001472 auto& writer = getWriter(display.getDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001473 {
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001474 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindanidcfe3a82021-11-29 17:00:31 +00001475 ASSERT_NE(nullptr, buffer);
1476 ASSERT_EQ(::android::OK, buffer->initCheck());
1477 ASSERT_NE(nullptr, buffer->handle);
1478
ramindani431aad42022-02-01 21:44:29 +00001479 configureLayer(display, layer, Composition::DEVICE, display.getFrameRect(),
1480 display.getCrop());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001481 writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, buffer->handle,
1482 /*acquireFence*/ -1);
1483 writer.setLayerDataspace(display.getDisplayId(), layer, common::Dataspace::UNKNOWN);
ramindanidcfe3a82021-11-29 17:00:31 +00001484
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001485 writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp);
ramindanidcfe3a82021-11-29 17:00:31 +00001486 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001487 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001488
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001489 writer.presentDisplay(display.getDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001490 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001491 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001492 }
1493
1494 {
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001495 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindanidcfe3a82021-11-29 17:00:31 +00001496 ASSERT_NE(nullptr, buffer->handle);
1497
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001498 writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, buffer->handle,
1499 /*acquireFence*/ -1);
1500 writer.setLayerSurfaceDamage(display.getDisplayId(), layer,
1501 std::vector<Rect>(1, {0, 0, 10, 10}));
1502 writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp);
ramindanidcfe3a82021-11-29 17:00:31 +00001503 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001504 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001505
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001506 writer.presentDisplay(display.getDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001507 execute();
1508 }
1509
ramindani431aad42022-02-01 21:44:29 +00001510 EXPECT_TRUE(mComposerClient->destroyLayer(display.getDisplayId(), layer).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001511 }
1512
Ady Abraham72c5b502021-12-10 17:23:39 -08001513 sp<::android::Fence> presentAndGetFence(
1514 std::optional<ClockMonotonicTimestamp> expectedPresentTime) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001515 auto& writer = getWriter(getPrimaryDisplayId());
1516 writer.validateDisplay(getPrimaryDisplayId(), expectedPresentTime);
Ady Abraham72c5b502021-12-10 17:23:39 -08001517 execute();
1518 EXPECT_TRUE(mReader.takeErrors().empty());
1519
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001520 writer.presentDisplay(getPrimaryDisplayId());
Ady Abraham72c5b502021-12-10 17:23:39 -08001521 execute();
1522 EXPECT_TRUE(mReader.takeErrors().empty());
1523
ramindani431aad42022-02-01 21:44:29 +00001524 auto presentFence = mReader.takePresentFence(getPrimaryDisplayId());
Ady Abraham46219f52021-12-20 09:44:31 -08001525 // take ownership
1526 const int fenceOwner = presentFence.get();
1527 *presentFence.getR() = -1;
1528 EXPECT_NE(-1, fenceOwner);
1529 return sp<::android::Fence>::make(fenceOwner);
Ady Abraham72c5b502021-12-10 17:23:39 -08001530 }
1531
1532 int32_t getVsyncPeriod() {
ramindani431aad42022-02-01 21:44:29 +00001533 const auto& [status, activeConfig] =
1534 mComposerClient->getActiveConfig(getPrimaryDisplayId());
1535 EXPECT_TRUE(status.isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001536
ramindani431aad42022-02-01 21:44:29 +00001537 const auto& [vsyncPeriodStatus, vsyncPeriod] = mComposerClient->getDisplayAttribute(
1538 getPrimaryDisplayId(), activeConfig, DisplayAttribute::VSYNC_PERIOD);
1539 EXPECT_TRUE(vsyncPeriodStatus.isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001540 return vsyncPeriod;
1541 }
1542
ramindani9dd8c482023-02-21 18:07:56 -08001543 int64_t createOnScreenLayer(Composition composition = Composition::DEVICE) {
ramindani431aad42022-02-01 21:44:29 +00001544 const auto& [status, layer] =
1545 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1546 EXPECT_TRUE(status.isOk());
1547 Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
1548 getPrimaryDisplay().getDisplayHeight()};
1549 FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
1550 (float)getPrimaryDisplay().getDisplayHeight()};
ramindani9dd8c482023-02-21 18:07:56 -08001551 configureLayer(getPrimaryDisplay(), layer, composition, displayFrame, cropRect);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001552 auto& writer = getWriter(getPrimaryDisplayId());
1553 writer.setLayerDataspace(getPrimaryDisplayId(), layer, common::Dataspace::UNKNOWN);
Ady Abraham72c5b502021-12-10 17:23:39 -08001554 return layer;
1555 }
1556
ramindani9dd8c482023-02-21 18:07:56 -08001557 void sendBufferUpdate(int64_t layer) {
1558 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1559 ASSERT_NE(nullptr, buffer->handle);
1560
1561 auto& writer = getWriter(getPrimaryDisplayId());
1562 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer->handle,
1563 /*acquireFence*/ -1);
1564
1565 const sp<::android::Fence> presentFence =
1566 presentAndGetFence(ComposerClientWriter::kNoTimestamp);
1567 presentFence->waitForever(LOG_TAG);
1568 }
1569
Midas Chiena0b56bd2022-01-13 23:27:33 +08001570 bool hasDisplayCapability(int64_t display, DisplayCapability cap) {
ramindani431aad42022-02-01 21:44:29 +00001571 const auto& [status, capabilities] = mComposerClient->getDisplayCapabilities(display);
1572 EXPECT_TRUE(status.isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08001573
1574 return std::find(capabilities.begin(), capabilities.end(), cap) != capabilities.end();
1575 }
1576
ramindanidcfe3a82021-11-29 17:00:31 +00001577 void Test_setActiveConfigWithConstraints(const TestParameters& params) {
1578 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +00001579 forEachTwoConfigs(display.getDisplayId(), [&](int32_t config1, int32_t config2) {
1580 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001581 sendRefreshFrame(display, nullptr);
1582
ramindani431aad42022-02-01 21:44:29 +00001583 const auto displayConfigGroup1 = display.getDisplayConfig(config1);
1584 int32_t vsyncPeriod1 = displayConfigGroup1.vsyncPeriod;
1585 int32_t configGroup1 = displayConfigGroup1.configGroup;
1586
1587 const auto displayConfigGroup2 = display.getDisplayConfig(config2);
1588 int32_t vsyncPeriod2 = displayConfigGroup2.vsyncPeriod;
1589 int32_t configGroup2 = displayConfigGroup2.configGroup;
ramindanidcfe3a82021-11-29 17:00:31 +00001590
1591 if (vsyncPeriod1 == vsyncPeriod2) {
1592 return; // continue
1593 }
1594
1595 // We don't allow delayed change when changing config groups
1596 if (params.delayForChange > 0 && configGroup1 != configGroup2) {
1597 return; // continue
1598 }
1599
ramindanidcfe3a82021-11-29 17:00:31 +00001600 VsyncPeriodChangeConstraints constraints = {
1601 .desiredTimeNanos = systemTime() + params.delayForChange,
1602 .seamlessRequired = false};
ramindani431aad42022-02-01 21:44:29 +00001603 const auto& [status, timeline] = mComposerClient->setActiveConfigWithConstraints(
1604 &display, config2, constraints);
1605 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001606
1607 EXPECT_TRUE(timeline.newVsyncAppliedTimeNanos >= constraints.desiredTimeNanos);
1608 // Refresh rate should change within a reasonable time
1609 constexpr std::chrono::nanoseconds kReasonableTimeForChange = 1s; // 1 second
1610 EXPECT_TRUE(timeline.newVsyncAppliedTimeNanos - constraints.desiredTimeNanos <=
1611 kReasonableTimeForChange.count());
1612
1613 if (timeline.refreshRequired) {
1614 if (params.refreshMiss) {
1615 // Miss the refresh frame on purpose to make sure the implementation sends a
1616 // callback
1617 std::this_thread::sleep_until(toTimePoint(timeline.refreshTimeNanos) +
1618 100ms);
1619 }
1620 sendRefreshFrame(display, &timeline);
1621 }
ramindani431aad42022-02-01 21:44:29 +00001622 waitForVsyncPeriodChange(display.getDisplayId(), timeline,
1623 constraints.desiredTimeNanos, vsyncPeriod1, vsyncPeriod2);
ramindanidcfe3a82021-11-29 17:00:31 +00001624
1625 // At this point the refresh rate should have changed already, however in rare
1626 // cases the implementation might have missed the deadline. In this case a new
1627 // timeline should have been provided.
ramindani431aad42022-02-01 21:44:29 +00001628 auto newTimeline = mComposerClient->takeLastVsyncPeriodChangeTimeline();
ramindanidcfe3a82021-11-29 17:00:31 +00001629 if (timeline.refreshRequired && params.refreshMiss) {
1630 EXPECT_TRUE(newTimeline.has_value());
1631 }
1632
1633 if (newTimeline.has_value()) {
1634 if (newTimeline->refreshRequired) {
1635 sendRefreshFrame(display, &newTimeline.value());
1636 }
ramindani431aad42022-02-01 21:44:29 +00001637 waitForVsyncPeriodChange(display.getDisplayId(), newTimeline.value(),
ramindanidcfe3a82021-11-29 17:00:31 +00001638 constraints.desiredTimeNanos, vsyncPeriod1,
1639 vsyncPeriod2);
1640 }
1641
ramindani431aad42022-02-01 21:44:29 +00001642 const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanos] =
1643 mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
1644 EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001645 EXPECT_EQ(vsyncPeriodNanos, vsyncPeriod2);
1646 });
1647 }
1648 }
1649
Ady Abraham72c5b502021-12-10 17:23:39 -08001650 void Test_expectedPresentTime(std::optional<int> framesDelay) {
Jason Macnak325e8232022-01-24 14:48:55 -08001651 if (hasCapability(Capability::PRESENT_FENCE_IS_NOT_RELIABLE)) {
1652 GTEST_SUCCEED() << "Device has unreliable present fences capability, skipping";
1653 return;
1654 }
1655
ramindani431aad42022-02-01 21:44:29 +00001656 ASSERT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001657
1658 const auto vsyncPeriod = getVsyncPeriod();
1659
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001660 const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1661 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
Ady Abraham72c5b502021-12-10 17:23:39 -08001662 ASSERT_NE(nullptr, buffer1);
1663 ASSERT_NE(nullptr, buffer2);
1664
1665 const auto layer = createOnScreenLayer();
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001666 auto& writer = getWriter(getPrimaryDisplayId());
1667 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer1->handle,
1668 /*acquireFence*/ -1);
Ady Abraham72c5b502021-12-10 17:23:39 -08001669 const sp<::android::Fence> presentFence1 =
1670 presentAndGetFence(ComposerClientWriter::kNoTimestamp);
1671 presentFence1->waitForever(LOG_TAG);
1672
1673 auto expectedPresentTime = presentFence1->getSignalTime() + vsyncPeriod;
1674 if (framesDelay.has_value()) {
1675 expectedPresentTime += *framesDelay * vsyncPeriod;
1676 }
1677
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001678 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer2->handle,
1679 /*acquireFence*/ -1);
Ady Abraham72c5b502021-12-10 17:23:39 -08001680 const auto setExpectedPresentTime = [&]() -> std::optional<ClockMonotonicTimestamp> {
1681 if (!framesDelay.has_value()) {
1682 return ComposerClientWriter::kNoTimestamp;
1683 } else if (*framesDelay == 0) {
1684 return ClockMonotonicTimestamp{0};
1685 }
1686 return ClockMonotonicTimestamp{expectedPresentTime};
1687 }();
1688
1689 const sp<::android::Fence> presentFence2 = presentAndGetFence(setExpectedPresentTime);
1690 presentFence2->waitForever(LOG_TAG);
1691
1692 const auto actualPresentTime = presentFence2->getSignalTime();
Ady Abrahamdf084f32022-01-10 14:10:23 -08001693 EXPECT_GE(actualPresentTime, expectedPresentTime - vsyncPeriod / 2);
Ady Abraham72c5b502021-12-10 17:23:39 -08001694
ramindani431aad42022-02-01 21:44:29 +00001695 ASSERT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001696 }
1697
ramindani431aad42022-02-01 21:44:29 +00001698 void configureLayer(const VtsDisplay& display, int64_t layer, Composition composition,
1699 const Rect& displayFrame, const FRect& cropRect) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001700 auto& writer = getWriter(display.getDisplayId());
1701 writer.setLayerCompositionType(display.getDisplayId(), layer, composition);
1702 writer.setLayerDisplayFrame(display.getDisplayId(), layer, displayFrame);
1703 writer.setLayerPlaneAlpha(display.getDisplayId(), layer, /*alpha*/ 1);
1704 writer.setLayerSourceCrop(display.getDisplayId(), layer, cropRect);
1705 writer.setLayerTransform(display.getDisplayId(), layer, static_cast<Transform>(0));
1706 writer.setLayerVisibleRegion(display.getDisplayId(), layer,
1707 std::vector<Rect>(1, displayFrame));
1708 writer.setLayerZOrder(display.getDisplayId(), layer, /*z*/ 10);
1709 writer.setLayerBlendMode(display.getDisplayId(), layer, BlendMode::NONE);
1710 writer.setLayerSurfaceDamage(display.getDisplayId(), layer,
1711 std::vector<Rect>(1, displayFrame));
ramindani431aad42022-02-01 21:44:29 +00001712 }
ramindanidcfe3a82021-11-29 17:00:31 +00001713 // clang-format off
1714 const std::array<float, 16> kIdentity = {{
1715 1.0f, 0.0f, 0.0f, 0.0f,
1716 0.0f, 1.0f, 0.0f, 0.0f,
1717 0.0f, 0.0f, 1.0f, 0.0f,
1718 0.0f, 0.0f, 0.0f, 1.0f,
1719 }};
1720 // clang-format on
1721
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001722 ComposerClientWriter& getWriter(int64_t display) {
1723 auto [it, _] = mWriters.try_emplace(display, display);
1724 return it->second;
1725 }
1726
Ady Abraham91c9d1a2021-12-15 18:14:45 -08001727 ComposerClientReader mReader;
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001728
1729 private:
1730 std::unordered_map<int64_t, ComposerClientWriter> mWriters;
ramindanidcfe3a82021-11-29 17:00:31 +00001731};
1732
ramindani431aad42022-02-01 21:44:29 +00001733TEST_P(GraphicsComposerAidlCommandTest, SetColorTransform) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001734 auto& writer = getWriter(getPrimaryDisplayId());
1735 writer.setColorTransform(getPrimaryDisplayId(), kIdentity.data());
ramindanidcfe3a82021-11-29 17:00:31 +00001736 execute();
1737}
1738
1739TEST_P(GraphicsComposerAidlCommandTest, SetLayerColorTransform) {
ramindani431aad42022-02-01 21:44:29 +00001740 const auto& [status, layer] =
1741 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1742 EXPECT_TRUE(status.isOk());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001743 auto& writer = getWriter(getPrimaryDisplayId());
1744 writer.setLayerColorTransform(getPrimaryDisplayId(), layer, kIdentity.data());
ramindanidcfe3a82021-11-29 17:00:31 +00001745 execute();
1746
Ady Abraham3192f3d2021-12-03 16:08:56 -08001747 const auto errors = mReader.takeErrors();
Jason Macnak062bc9a2022-01-20 15:00:09 -08001748 if (errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_UNSUPPORTED) {
ramindanidcfe3a82021-11-29 17:00:31 +00001749 GTEST_SUCCEED() << "setLayerColorTransform is not supported";
1750 return;
1751 }
1752}
1753
Alec Mouri60564e12021-12-09 18:48:20 -08001754TEST_P(GraphicsComposerAidlCommandTest, SetDisplayBrightness) {
ramindani431aad42022-02-01 21:44:29 +00001755 const auto& [status, capabilities] =
1756 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
1757 ASSERT_TRUE(status.isOk());
Alec Mouri60564e12021-12-09 18:48:20 -08001758 bool brightnessSupport = std::find(capabilities.begin(), capabilities.end(),
1759 DisplayCapability::BRIGHTNESS) != capabilities.end();
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001760 auto& writer = getWriter(getPrimaryDisplayId());
Alec Mouri60564e12021-12-09 18:48:20 -08001761 if (!brightnessSupport) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001762 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.5f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001763 execute();
1764 const auto errors = mReader.takeErrors();
1765 EXPECT_EQ(1, errors.size());
Jason Macnak062bc9a2022-01-20 15:00:09 -08001766 EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, errors[0].errorCode);
Alec Mouri60564e12021-12-09 18:48:20 -08001767 GTEST_SUCCEED() << "SetDisplayBrightness is not supported";
1768 return;
1769 }
1770
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001771 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001772 execute();
1773 EXPECT_TRUE(mReader.takeErrors().empty());
1774
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001775 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.5f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001776 execute();
1777 EXPECT_TRUE(mReader.takeErrors().empty());
1778
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001779 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 1.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001780 execute();
1781 EXPECT_TRUE(mReader.takeErrors().empty());
1782
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001783 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ -1.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001784 execute();
1785 EXPECT_TRUE(mReader.takeErrors().empty());
1786
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001787 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 2.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001788 execute();
1789 {
1790 const auto errors = mReader.takeErrors();
ramindanib3bdf052022-01-12 18:27:05 +00001791 ASSERT_EQ(1, errors.size());
Alec Mouri60564e12021-12-09 18:48:20 -08001792 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
1793 }
1794
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001795 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ -2.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001796 execute();
1797 {
1798 const auto errors = mReader.takeErrors();
ramindanib3bdf052022-01-12 18:27:05 +00001799 ASSERT_EQ(1, errors.size());
Alec Mouri60564e12021-12-09 18:48:20 -08001800 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
1801 }
1802}
1803
ramindani431aad42022-02-01 21:44:29 +00001804TEST_P(GraphicsComposerAidlCommandTest, SetClientTarget) {
1805 EXPECT_TRUE(mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kBufferSlotCount)
1806 .isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001807
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001808 auto& writer = getWriter(getPrimaryDisplayId());
1809 writer.setClientTarget(getPrimaryDisplayId(), /*slot*/ 0, nullptr, /*acquireFence*/ -1,
1810 Dataspace::UNKNOWN, std::vector<Rect>());
ramindanidcfe3a82021-11-29 17:00:31 +00001811
1812 execute();
1813}
1814
ramindani431aad42022-02-01 21:44:29 +00001815TEST_P(GraphicsComposerAidlCommandTest, SetOutputBuffer) {
1816 const auto& [status, virtualDisplayCount] = mComposerClient->getMaxVirtualDisplayCount();
1817 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001818 if (virtualDisplayCount == 0) {
1819 GTEST_SUCCEED() << "no virtual display support";
1820 return;
1821 }
1822
ramindani431aad42022-02-01 21:44:29 +00001823 const auto& [displayStatus, display] = mComposerClient->createVirtualDisplay(
1824 /*width*/ 64, /*height*/ 64, common::PixelFormat::IMPLEMENTATION_DEFINED,
1825 kBufferSlotCount);
1826 EXPECT_TRUE(displayStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001827
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001828 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001829 const auto handle = buffer->handle;
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001830 auto& writer = getWriter(display.display);
1831 writer.setOutputBuffer(display.display, /*slot*/ 0, handle, /*releaseFence*/ -1);
ramindanidcfe3a82021-11-29 17:00:31 +00001832 execute();
1833}
1834
ramindani431aad42022-02-01 21:44:29 +00001835TEST_P(GraphicsComposerAidlCommandTest, ValidDisplay) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001836 auto& writer = getWriter(getPrimaryDisplayId());
1837 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
ramindanidcfe3a82021-11-29 17:00:31 +00001838 execute();
1839}
1840
ramindani431aad42022-02-01 21:44:29 +00001841TEST_P(GraphicsComposerAidlCommandTest, AcceptDisplayChanges) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001842 auto& writer = getWriter(getPrimaryDisplayId());
1843 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
1844 writer.acceptDisplayChanges(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001845 execute();
1846}
1847
ramindani431aad42022-02-01 21:44:29 +00001848TEST_P(GraphicsComposerAidlCommandTest, PresentDisplay) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001849 auto& writer = getWriter(getPrimaryDisplayId());
1850 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
1851 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001852 execute();
1853}
1854
1855/**
1856 * Test IComposerClient::Command::PRESENT_DISPLAY
1857 *
1858 * Test that IComposerClient::Command::PRESENT_DISPLAY works without
1859 * additional call to validateDisplay when only the layer buffer handle and
1860 * surface damage have been set
1861 */
ramindani431aad42022-02-01 21:44:29 +00001862TEST_P(GraphicsComposerAidlCommandTest, PresentDisplayNoLayerStateChanges) {
Jason Macnak325e8232022-01-24 14:48:55 -08001863 if (!hasCapability(Capability::SKIP_VALIDATE)) {
ramindanidcfe3a82021-11-29 17:00:31 +00001864 GTEST_SUCCEED() << "Device does not have skip validate capability, skipping";
1865 return;
1866 }
ramindani431aad42022-02-01 21:44:29 +00001867 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001868
ramindani431aad42022-02-01 21:44:29 +00001869 const auto& [renderIntentsStatus, renderIntents] =
1870 mComposerClient->getRenderIntents(getPrimaryDisplayId(), ColorMode::NATIVE);
1871 EXPECT_TRUE(renderIntentsStatus.isOk());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001872 auto& writer = getWriter(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001873 for (auto intent : renderIntents) {
ramindani431aad42022-02-01 21:44:29 +00001874 EXPECT_TRUE(mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE, intent)
1875 .isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001876
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001877 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001878 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001879 ASSERT_NE(nullptr, handle);
1880
ramindani431aad42022-02-01 21:44:29 +00001881 const auto& [layerStatus, layer] =
1882 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1883 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001884
ramindani431aad42022-02-01 21:44:29 +00001885 Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
1886 getPrimaryDisplay().getDisplayHeight()};
1887 FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
1888 (float)getPrimaryDisplay().getDisplayHeight()};
1889 configureLayer(getPrimaryDisplay(), layer, Composition::CURSOR, displayFrame, cropRect);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001890 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle,
1891 /*acquireFence*/ -1);
1892 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
1893 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
ramindanidcfe3a82021-11-29 17:00:31 +00001894 execute();
ramindani431aad42022-02-01 21:44:29 +00001895 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
ramindanidcfe3a82021-11-29 17:00:31 +00001896 GTEST_SUCCEED() << "Composition change requested, skipping test";
1897 return;
1898 }
1899
Ady Abraham3192f3d2021-12-03 16:08:56 -08001900 ASSERT_TRUE(mReader.takeErrors().empty());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001901 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001902 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001903 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001904
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001905 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001906 const auto handle2 = buffer2->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001907 ASSERT_NE(nullptr, handle2);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001908 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle2,
1909 /*acquireFence*/ -1);
1910 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer,
1911 std::vector<Rect>(1, {0, 0, 10, 10}));
1912 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001913 execute();
1914 }
1915}
1916
ramindani431aad42022-02-01 21:44:29 +00001917TEST_P(GraphicsComposerAidlCommandTest, SetLayerCursorPosition) {
1918 const auto& [layerStatus, layer] =
1919 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1920 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001921
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001922 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001923 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001924 ASSERT_NE(nullptr, handle);
ramindanidcfe3a82021-11-29 17:00:31 +00001925
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001926 auto& writer = getWriter(getPrimaryDisplayId());
1927 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle, /*acquireFence*/ -1);
ramindani431aad42022-02-01 21:44:29 +00001928
1929 Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
1930 getPrimaryDisplay().getDisplayHeight()};
1931 FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
1932 (float)getPrimaryDisplay().getDisplayHeight()};
1933 configureLayer(getPrimaryDisplay(), layer, Composition::CURSOR, displayFrame, cropRect);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001934 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
1935 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
ramindanidcfe3a82021-11-29 17:00:31 +00001936
1937 execute();
Ady Abraham46219f52021-12-20 09:44:31 -08001938
ramindani431aad42022-02-01 21:44:29 +00001939 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
ramindanidcfe3a82021-11-29 17:00:31 +00001940 GTEST_SUCCEED() << "Composition change requested, skipping test";
1941 return;
1942 }
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001943 writer.presentDisplay(getPrimaryDisplayId());
Ady Abraham3192f3d2021-12-03 16:08:56 -08001944 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001945
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001946 writer.setLayerCursorPosition(getPrimaryDisplayId(), layer, /*x*/ 1, /*y*/ 1);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001947 execute();
1948
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001949 writer.setLayerCursorPosition(getPrimaryDisplayId(), layer, /*x*/ 0, /*y*/ 0);
1950 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
1951 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001952 execute();
1953}
1954
ramindani431aad42022-02-01 21:44:29 +00001955TEST_P(GraphicsComposerAidlCommandTest, SetLayerBuffer) {
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001956 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001957 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001958 ASSERT_NE(nullptr, handle);
1959
ramindani431aad42022-02-01 21:44:29 +00001960 const auto& [layerStatus, layer] =
1961 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1962 EXPECT_TRUE(layerStatus.isOk());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001963 auto& writer = getWriter(getPrimaryDisplayId());
1964 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle, /*acquireFence*/ -1);
ramindanidcfe3a82021-11-29 17:00:31 +00001965 execute();
1966}
1967
Brian Lindahl25e0d092022-12-09 00:32:11 -07001968TEST_P(GraphicsComposerAidlCommandTest, SetLayerBufferMultipleTimes) {
1969 const auto& [layerStatus, layer] =
1970 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1971 EXPECT_TRUE(layerStatus.isOk());
1972 auto& writer = getWriter(getPrimaryDisplayId());
1973
1974 // Setup 3 buffers in the buffer cache, with the last buffer being active. Then, emulate the
1975 // Android platform code that clears all 3 buffer slots by setting all but the active buffer
1976 // slot to a placeholder buffer, and then restoring the active buffer.
1977
1978 // This is used on HALs that don't support setLayerBufferSlotsToClear (version <= 3.1).
1979
1980 const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1981 ASSERT_NE(nullptr, buffer1);
1982 const auto handle1 = buffer1->handle;
1983 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle1, /*acquireFence*/ -1);
1984 execute();
1985 ASSERT_TRUE(mReader.takeErrors().empty());
1986
1987 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1988 ASSERT_NE(nullptr, buffer2);
1989 const auto handle2 = buffer2->handle;
1990 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 1, handle2, /*acquireFence*/ -1);
1991 execute();
1992 ASSERT_TRUE(mReader.takeErrors().empty());
1993
1994 const auto buffer3 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1995 ASSERT_NE(nullptr, buffer3);
1996 const auto handle3 = buffer3->handle;
1997 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 2, handle3, /*acquireFence*/ -1);
1998 execute();
1999 ASSERT_TRUE(mReader.takeErrors().empty());
2000
2001 // Older versions of the HAL clear all but the active buffer slot with a placeholder buffer,
2002 // and then restoring the current active buffer at the end
2003 auto clearSlotBuffer = allocate(1u, 1u, ::android::PIXEL_FORMAT_RGB_888);
2004 ASSERT_NE(nullptr, clearSlotBuffer);
2005 auto clearSlotBufferHandle = clearSlotBuffer->handle;
2006
2007 // clear buffer slots 0 and 1 with new layer commands... and then...
2008 writer.setLayerBufferWithNewCommand(getPrimaryDisplayId(), layer, /* slot */ 0,
2009 clearSlotBufferHandle, /*acquireFence*/ -1);
2010 writer.setLayerBufferWithNewCommand(getPrimaryDisplayId(), layer, /* slot */ 1,
2011 clearSlotBufferHandle, /*acquireFence*/ -1);
2012 // ...reset the layer buffer to the current active buffer slot with a final new command
2013 writer.setLayerBufferWithNewCommand(getPrimaryDisplayId(), layer, /*slot*/ 2, nullptr,
2014 /*acquireFence*/ -1);
2015 execute();
2016 ASSERT_TRUE(mReader.takeErrors().empty());
2017}
2018
ramindani431aad42022-02-01 21:44:29 +00002019TEST_P(GraphicsComposerAidlCommandTest, SetLayerSurfaceDamage) {
2020 const auto& [layerStatus, layer] =
2021 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2022 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002023
2024 Rect empty{0, 0, 0, 0};
2025 Rect unit{0, 0, 1, 1};
2026
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002027 auto& writer = getWriter(getPrimaryDisplayId());
2028 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
ramindanidcfe3a82021-11-29 17:00:31 +00002029 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002030 ASSERT_TRUE(mReader.takeErrors().empty());
2031
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002032 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
Ady Abraham3192f3d2021-12-03 16:08:56 -08002033 execute();
2034 ASSERT_TRUE(mReader.takeErrors().empty());
2035
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002036 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>());
Ady Abraham3192f3d2021-12-03 16:08:56 -08002037 execute();
2038 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002039}
2040
ramindani431aad42022-02-01 21:44:29 +00002041TEST_P(GraphicsComposerAidlCommandTest, SetLayerBlockingRegion) {
2042 const auto& [layerStatus, layer] =
2043 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2044 EXPECT_TRUE(layerStatus.isOk());
Leon Scroggins III03318152022-01-13 12:24:19 -05002045
2046 Rect empty{0, 0, 0, 0};
2047 Rect unit{0, 0, 1, 1};
2048
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002049 auto& writer = getWriter(getPrimaryDisplayId());
2050 writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
Leon Scroggins III03318152022-01-13 12:24:19 -05002051 execute();
2052 ASSERT_TRUE(mReader.takeErrors().empty());
2053
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002054 writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
Leon Scroggins III03318152022-01-13 12:24:19 -05002055 execute();
2056 ASSERT_TRUE(mReader.takeErrors().empty());
2057
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002058 writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>());
Leon Scroggins III03318152022-01-13 12:24:19 -05002059 execute();
2060 ASSERT_TRUE(mReader.takeErrors().empty());
2061}
2062
ramindani431aad42022-02-01 21:44:29 +00002063TEST_P(GraphicsComposerAidlCommandTest, SetLayerBlendMode) {
2064 const auto& [layerStatus, layer] =
2065 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2066 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002067
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002068 auto& writer = getWriter(getPrimaryDisplayId());
2069 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::NONE);
ramindanidcfe3a82021-11-29 17:00:31 +00002070 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002071 ASSERT_TRUE(mReader.takeErrors().empty());
2072
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002073 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::PREMULTIPLIED);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002074 execute();
2075 ASSERT_TRUE(mReader.takeErrors().empty());
2076
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002077 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::COVERAGE);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002078 execute();
2079 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002080}
2081
ramindani431aad42022-02-01 21:44:29 +00002082TEST_P(GraphicsComposerAidlCommandTest, SetLayerColor) {
2083 const auto& [layerStatus, layer] =
2084 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2085 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002086
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002087 auto& writer = getWriter(getPrimaryDisplayId());
2088 writer.setLayerColor(getPrimaryDisplayId(), layer, Color{1.0f, 1.0f, 1.0f, 1.0f});
ramindanidcfe3a82021-11-29 17:00:31 +00002089 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002090 ASSERT_TRUE(mReader.takeErrors().empty());
2091
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002092 writer.setLayerColor(getPrimaryDisplayId(), layer, Color{0.0f, 0.0f, 0.0f, 0.0f});
Ady Abraham3192f3d2021-12-03 16:08:56 -08002093 execute();
2094 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002095}
2096
ramindani431aad42022-02-01 21:44:29 +00002097TEST_P(GraphicsComposerAidlCommandTest, SetLayerCompositionType) {
2098 const auto& [layerStatus, layer] =
2099 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2100 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002101
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002102 auto& writer = getWriter(getPrimaryDisplayId());
2103 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::CLIENT);
ramindanidcfe3a82021-11-29 17:00:31 +00002104 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002105 ASSERT_TRUE(mReader.takeErrors().empty());
2106
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002107 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::DEVICE);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002108 execute();
2109 ASSERT_TRUE(mReader.takeErrors().empty());
2110
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002111 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::SOLID_COLOR);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002112 execute();
2113 ASSERT_TRUE(mReader.takeErrors().empty());
2114
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002115 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::CURSOR);
ramindani431aad42022-02-01 21:44:29 +00002116 execute();
2117}
2118
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002119TEST_P(GraphicsComposerAidlCommandTest, DisplayDecoration) {
2120 for (VtsDisplay& display : mDisplays) {
2121 const auto [layerStatus, layer] =
2122 mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount);
2123 EXPECT_TRUE(layerStatus.isOk());
2124
2125 const auto [error, support] =
2126 mComposerClient->getDisplayDecorationSupport(display.getDisplayId());
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002127
Leon Scroggins III91590872022-02-23 09:51:21 -05002128 const auto format = (error.isOk() && support) ? support->format
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002129 : aidl::android::hardware::graphics::common::PixelFormat::RGBA_8888;
2130 const auto decorBuffer = allocate(static_cast<::android::PixelFormat>(format));
2131 ASSERT_NE(nullptr, decorBuffer);
2132 if (::android::OK != decorBuffer->initCheck()) {
2133 if (support) {
2134 FAIL() << "Device advertised display decoration support with format "
2135 << aidl::android::hardware::graphics::common::toString(format)
2136 << " but failed to allocate it!";
2137 } else {
2138 FAIL() << "Device advertised NO display decoration support, but it should "
2139 << "still be able to allocate "
2140 << aidl::android::hardware::graphics::common::toString(format);
2141 }
2142 }
2143
Midas Chien7d55d422022-06-07 02:32:28 +08002144 configureLayer(display, layer, Composition::DISPLAY_DECORATION, display.getFrameRect(),
2145 display.getCrop());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002146 auto& writer = getWriter(display.getDisplayId());
2147 writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, decorBuffer->handle,
2148 /*acquireFence*/ -1);
2149 writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp);
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002150 execute();
2151 if (support) {
2152 ASSERT_TRUE(mReader.takeErrors().empty());
2153 } else {
2154 const auto errors = mReader.takeErrors();
2155 ASSERT_EQ(1, errors.size());
Leon Scroggins III6455e792022-02-24 12:18:58 -05002156 EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, errors[0].errorCode);
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002157 }
2158 }
2159}
2160
ramindani431aad42022-02-01 21:44:29 +00002161TEST_P(GraphicsComposerAidlCommandTest, SetLayerDataspace) {
2162 const auto& [layerStatus, layer] =
2163 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2164 EXPECT_TRUE(layerStatus.isOk());
2165
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002166 auto& writer = getWriter(getPrimaryDisplayId());
2167 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
ramindani431aad42022-02-01 21:44:29 +00002168 execute();
2169}
2170
2171TEST_P(GraphicsComposerAidlCommandTest, SetLayerDisplayFrame) {
2172 const auto& [layerStatus, layer] =
2173 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2174 EXPECT_TRUE(layerStatus.isOk());
2175
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002176 auto& writer = getWriter(getPrimaryDisplayId());
2177 writer.setLayerDisplayFrame(getPrimaryDisplayId(), layer, Rect{0, 0, 1, 1});
ramindani431aad42022-02-01 21:44:29 +00002178 execute();
2179}
2180
2181TEST_P(GraphicsComposerAidlCommandTest, SetLayerPlaneAlpha) {
2182 const auto& [layerStatus, layer] =
2183 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2184 EXPECT_TRUE(layerStatus.isOk());
2185
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002186 auto& writer = getWriter(getPrimaryDisplayId());
2187 writer.setLayerPlaneAlpha(getPrimaryDisplayId(), layer, /*alpha*/ 0.0f);
ramindani431aad42022-02-01 21:44:29 +00002188 execute();
2189 ASSERT_TRUE(mReader.takeErrors().empty());
2190
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002191 writer.setLayerPlaneAlpha(getPrimaryDisplayId(), layer, /*alpha*/ 1.0f);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002192 execute();
2193 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002194}
2195
ramindani431aad42022-02-01 21:44:29 +00002196TEST_P(GraphicsComposerAidlCommandTest, SetLayerSidebandStream) {
Jason Macnak325e8232022-01-24 14:48:55 -08002197 if (!hasCapability(Capability::SIDEBAND_STREAM)) {
ramindanidcfe3a82021-11-29 17:00:31 +00002198 GTEST_SUCCEED() << "no sideband stream support";
2199 return;
2200 }
2201
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002202 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00002203 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00002204 ASSERT_NE(nullptr, handle);
2205
ramindani431aad42022-02-01 21:44:29 +00002206 const auto& [layerStatus, layer] =
2207 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2208 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002209
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002210 auto& writer = getWriter(getPrimaryDisplayId());
2211 writer.setLayerSidebandStream(getPrimaryDisplayId(), layer, handle);
ramindanidcfe3a82021-11-29 17:00:31 +00002212 execute();
2213}
2214
ramindani431aad42022-02-01 21:44:29 +00002215TEST_P(GraphicsComposerAidlCommandTest, SetLayerSourceCrop) {
2216 const auto& [layerStatus, layer] =
2217 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2218 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002219
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002220 auto& writer = getWriter(getPrimaryDisplayId());
2221 writer.setLayerSourceCrop(getPrimaryDisplayId(), layer, FRect{0.0f, 0.0f, 1.0f, 1.0f});
ramindanidcfe3a82021-11-29 17:00:31 +00002222 execute();
2223}
2224
ramindani431aad42022-02-01 21:44:29 +00002225TEST_P(GraphicsComposerAidlCommandTest, SetLayerTransform) {
2226 const auto& [layerStatus, layer] =
2227 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2228 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002229
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002230 auto& writer = getWriter(getPrimaryDisplayId());
2231 writer.setLayerTransform(getPrimaryDisplayId(), layer, static_cast<Transform>(0));
ramindanidcfe3a82021-11-29 17:00:31 +00002232 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002233 ASSERT_TRUE(mReader.takeErrors().empty());
2234
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002235 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::FLIP_H);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002236 execute();
2237 ASSERT_TRUE(mReader.takeErrors().empty());
2238
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002239 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::FLIP_V);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002240 execute();
2241 ASSERT_TRUE(mReader.takeErrors().empty());
2242
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002243 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_90);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002244 execute();
2245 ASSERT_TRUE(mReader.takeErrors().empty());
2246
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002247 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_180);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002248 execute();
2249 ASSERT_TRUE(mReader.takeErrors().empty());
2250
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002251 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_270);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002252 execute();
2253 ASSERT_TRUE(mReader.takeErrors().empty());
2254
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002255 writer.setLayerTransform(getPrimaryDisplayId(), layer,
2256 static_cast<Transform>(static_cast<int>(Transform::FLIP_H) |
2257 static_cast<int>(Transform::ROT_90)));
Ady Abraham3192f3d2021-12-03 16:08:56 -08002258 execute();
2259 ASSERT_TRUE(mReader.takeErrors().empty());
2260
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002261 writer.setLayerTransform(getPrimaryDisplayId(), layer,
2262 static_cast<Transform>(static_cast<int>(Transform::FLIP_V) |
2263 static_cast<int>(Transform::ROT_90)));
Ady Abraham3192f3d2021-12-03 16:08:56 -08002264 execute();
2265 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002266}
2267
ramindani431aad42022-02-01 21:44:29 +00002268TEST_P(GraphicsComposerAidlCommandTest, SetLayerVisibleRegion) {
2269 const auto& [layerStatus, layer] =
2270 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2271 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002272
2273 Rect empty{0, 0, 0, 0};
2274 Rect unit{0, 0, 1, 1};
2275
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002276 auto& writer = getWriter(getPrimaryDisplayId());
2277 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
ramindanidcfe3a82021-11-29 17:00:31 +00002278 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002279 ASSERT_TRUE(mReader.takeErrors().empty());
2280
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002281 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
Ady Abraham3192f3d2021-12-03 16:08:56 -08002282 execute();
2283 ASSERT_TRUE(mReader.takeErrors().empty());
2284
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002285 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>());
Ady Abraham3192f3d2021-12-03 16:08:56 -08002286 execute();
2287 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002288}
2289
ramindani431aad42022-02-01 21:44:29 +00002290TEST_P(GraphicsComposerAidlCommandTest, SetLayerZOrder) {
2291 const auto& [layerStatus, layer] =
2292 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2293 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002294
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002295 auto& writer = getWriter(getPrimaryDisplayId());
2296 writer.setLayerZOrder(getPrimaryDisplayId(), layer, /*z*/ 10);
ramindanidcfe3a82021-11-29 17:00:31 +00002297 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002298 ASSERT_TRUE(mReader.takeErrors().empty());
2299
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002300 writer.setLayerZOrder(getPrimaryDisplayId(), layer, /*z*/ 0);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002301 execute();
2302 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002303}
2304
ramindani431aad42022-02-01 21:44:29 +00002305TEST_P(GraphicsComposerAidlCommandTest, SetLayerPerFrameMetadata) {
2306 const auto& [layerStatus, layer] =
2307 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2308 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002309
ramindanidcfe3a82021-11-29 17:00:31 +00002310 /**
2311 * DISPLAY_P3 is a color space that uses the DCI_P3 primaries,
2312 * the D65 white point and the SRGB transfer functions.
2313 * Rendering Intent: Colorimetric
2314 * Primaries:
2315 * x y
2316 * green 0.265 0.690
2317 * blue 0.150 0.060
2318 * red 0.680 0.320
2319 * white (D65) 0.3127 0.3290
2320 */
2321
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002322 auto& writer = getWriter(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00002323 std::vector<PerFrameMetadata> aidlMetadata;
2324 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X, 0.680f});
2325 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y, 0.320f});
2326 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X, 0.265f});
2327 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y, 0.690f});
2328 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X, 0.150f});
2329 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y, 0.060f});
2330 aidlMetadata.push_back({PerFrameMetadataKey::WHITE_POINT_X, 0.3127f});
2331 aidlMetadata.push_back({PerFrameMetadataKey::WHITE_POINT_Y, 0.3290f});
2332 aidlMetadata.push_back({PerFrameMetadataKey::MAX_LUMINANCE, 100.0f});
2333 aidlMetadata.push_back({PerFrameMetadataKey::MIN_LUMINANCE, 0.1f});
2334 aidlMetadata.push_back({PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL, 78.0});
2335 aidlMetadata.push_back({PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL, 62.0});
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002336 writer.setLayerPerFrameMetadata(getPrimaryDisplayId(), layer, aidlMetadata);
ramindanidcfe3a82021-11-29 17:00:31 +00002337 execute();
2338
Ady Abraham3192f3d2021-12-03 16:08:56 -08002339 const auto errors = mReader.takeErrors();
2340 if (errors.size() == 1 && errors[0].errorCode == EX_UNSUPPORTED_OPERATION) {
ramindanidcfe3a82021-11-29 17:00:31 +00002341 GTEST_SUCCEED() << "SetLayerPerFrameMetadata is not supported";
ramindani431aad42022-02-01 21:44:29 +00002342 EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002343 return;
2344 }
2345
ramindani431aad42022-02-01 21:44:29 +00002346 EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002347}
2348
Alec Mourib1f16722022-02-07 13:03:44 -08002349TEST_P(GraphicsComposerAidlCommandTest, setLayerBrightness) {
ramindani431aad42022-02-01 21:44:29 +00002350 const auto& [layerStatus, layer] =
2351 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
Alec Mouri95e490b2022-01-06 13:46:58 -08002352
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002353 auto& writer = getWriter(getPrimaryDisplayId());
2354 writer.setLayerBrightness(getPrimaryDisplayId(), layer, 0.2f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002355 execute();
2356 ASSERT_TRUE(mReader.takeErrors().empty());
2357
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002358 writer.setLayerBrightness(getPrimaryDisplayId(), layer, 1.f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002359 execute();
2360 ASSERT_TRUE(mReader.takeErrors().empty());
2361
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002362 writer.setLayerBrightness(getPrimaryDisplayId(), layer, 0.f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002363 execute();
2364 ASSERT_TRUE(mReader.takeErrors().empty());
2365
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002366 writer.setLayerBrightness(getPrimaryDisplayId(), layer, -1.f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002367 execute();
Alec Mourib1f16722022-02-07 13:03:44 -08002368 {
2369 const auto errors = mReader.takeErrors();
2370 ASSERT_EQ(1, errors.size());
2371 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
2372 }
2373
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002374 writer.setLayerBrightness(getPrimaryDisplayId(), layer, std::nanf(""));
Alec Mourib1f16722022-02-07 13:03:44 -08002375 execute();
2376 {
2377 const auto errors = mReader.takeErrors();
2378 ASSERT_EQ(1, errors.size());
2379 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
2380 }
Alec Mouri95e490b2022-01-06 13:46:58 -08002381}
2382
ramindani431aad42022-02-01 21:44:29 +00002383TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints) {
ramindanidcfe3a82021-11-29 17:00:31 +00002384 Test_setActiveConfigWithConstraints({.delayForChange = 0, .refreshMiss = false});
2385}
2386
ramindani431aad42022-02-01 21:44:29 +00002387TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_Delayed) {
ramindanidcfe3a82021-11-29 17:00:31 +00002388 Test_setActiveConfigWithConstraints({.delayForChange = 300'000'000, // 300ms
2389 .refreshMiss = false});
2390}
2391
ramindani431aad42022-02-01 21:44:29 +00002392TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_MissRefresh) {
ramindanidcfe3a82021-11-29 17:00:31 +00002393 Test_setActiveConfigWithConstraints({.delayForChange = 0, .refreshMiss = true});
2394}
2395
ramindani431aad42022-02-01 21:44:29 +00002396TEST_P(GraphicsComposerAidlCommandTest, GetDisplayVsyncPeriod) {
ramindanidcfe3a82021-11-29 17:00:31 +00002397 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +00002398 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
2399 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002400
ramindani431aad42022-02-01 21:44:29 +00002401 for (int32_t config : configs) {
2402 int32_t expectedVsyncPeriodNanos = display.getDisplayConfig(config).vsyncPeriod;
2403
ramindanidcfe3a82021-11-29 17:00:31 +00002404 VsyncPeriodChangeConstraints constraints;
2405
2406 constraints.desiredTimeNanos = systemTime();
2407 constraints.seamlessRequired = false;
ramindani431aad42022-02-01 21:44:29 +00002408
2409 const auto& [timelineStatus, timeline] =
2410 mComposerClient->setActiveConfigWithConstraints(&display, config, constraints);
2411 EXPECT_TRUE(timelineStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002412
2413 if (timeline.refreshRequired) {
2414 sendRefreshFrame(display, &timeline);
2415 }
ramindani431aad42022-02-01 21:44:29 +00002416 waitForVsyncPeriodChange(display.getDisplayId(), timeline, constraints.desiredTimeNanos,
2417 /*odPeriodNanos*/ 0, expectedVsyncPeriodNanos);
ramindanidcfe3a82021-11-29 17:00:31 +00002418
2419 int32_t vsyncPeriodNanos;
2420 int retryCount = 100;
2421 do {
2422 std::this_thread::sleep_for(10ms);
ramindani431aad42022-02-01 21:44:29 +00002423 const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanosValue] =
2424 mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
2425
2426 EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
2427 vsyncPeriodNanos = vsyncPeriodNanosValue;
ramindanidcfe3a82021-11-29 17:00:31 +00002428 --retryCount;
2429 } while (vsyncPeriodNanos != expectedVsyncPeriodNanos && retryCount > 0);
2430
2431 EXPECT_EQ(vsyncPeriodNanos, expectedVsyncPeriodNanos);
2432
2433 // Make sure that the vsync period stays the same if the active config is not
2434 // changed.
2435 auto timeout = 1ms;
2436 for (int i = 0; i < 10; i++) {
2437 std::this_thread::sleep_for(timeout);
2438 timeout *= 2;
2439 vsyncPeriodNanos = 0;
ramindani431aad42022-02-01 21:44:29 +00002440 const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanosValue] =
2441 mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
2442
2443 EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
2444 vsyncPeriodNanos = vsyncPeriodNanosValue;
ramindanidcfe3a82021-11-29 17:00:31 +00002445 EXPECT_EQ(vsyncPeriodNanos, expectedVsyncPeriodNanos);
2446 }
2447 }
2448 }
2449}
2450
ramindani431aad42022-02-01 21:44:29 +00002451TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_SeamlessNotAllowed) {
ramindanidcfe3a82021-11-29 17:00:31 +00002452 VsyncPeriodChangeConstraints constraints;
ramindanidcfe3a82021-11-29 17:00:31 +00002453 constraints.seamlessRequired = true;
2454 constraints.desiredTimeNanos = systemTime();
2455
2456 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +00002457 forEachTwoConfigs(display.getDisplayId(), [&](int32_t config1, int32_t config2) {
2458 int32_t configGroup1 = display.getDisplayConfig(config1).configGroup;
2459 int32_t configGroup2 = display.getDisplayConfig(config2).configGroup;
ramindanidcfe3a82021-11-29 17:00:31 +00002460 if (configGroup1 != configGroup2) {
ramindani431aad42022-02-01 21:44:29 +00002461 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002462 sendRefreshFrame(display, nullptr);
ramindani431aad42022-02-01 21:44:29 +00002463 const auto& [status, _] = mComposerClient->setActiveConfigWithConstraints(
2464 &display, config2, constraints);
2465 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00002466 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(
2467 status, IComposerClient::EX_SEAMLESS_NOT_ALLOWED));
ramindanidcfe3a82021-11-29 17:00:31 +00002468 }
2469 });
2470 }
2471}
2472
ramindani431aad42022-02-01 21:44:29 +00002473TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_NoTimestamp) {
2474 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ std::nullopt));
Ady Abraham72c5b502021-12-10 17:23:39 -08002475}
2476
ramindani431aad42022-02-01 21:44:29 +00002477TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_0) {
2478 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ 0));
Ady Abraham72c5b502021-12-10 17:23:39 -08002479}
2480
ramindani431aad42022-02-01 21:44:29 +00002481TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_5) {
2482 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ 5));
Ady Abraham72c5b502021-12-10 17:23:39 -08002483}
2484
ramindani431aad42022-02-01 21:44:29 +00002485TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Unsupported) {
2486 const bool hasDisplayIdleTimerSupport =
2487 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002488 if (!hasDisplayIdleTimerSupport) {
ramindani431aad42022-02-01 21:44:29 +00002489 const auto& status =
2490 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0);
2491 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00002492 EXPECT_NO_FATAL_FAILURE(
2493 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
Midas Chiena0b56bd2022-01-13 23:27:33 +08002494 }
2495}
2496
ramindani431aad42022-02-01 21:44:29 +00002497TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_BadParameter) {
2498 const bool hasDisplayIdleTimerSupport =
2499 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002500 if (!hasDisplayIdleTimerSupport) {
2501 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2502 return;
2503 }
2504
ramindani431aad42022-02-01 21:44:29 +00002505 const auto& status =
2506 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ -1);
2507 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00002508 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
Midas Chiena0b56bd2022-01-13 23:27:33 +08002509}
2510
ramindani431aad42022-02-01 21:44:29 +00002511TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Disable) {
2512 const bool hasDisplayIdleTimerSupport =
2513 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002514 if (!hasDisplayIdleTimerSupport) {
2515 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2516 return;
2517 }
2518
ramindani431aad42022-02-01 21:44:29 +00002519 EXPECT_TRUE(mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002520 std::this_thread::sleep_for(1s);
ramindani431aad42022-02-01 21:44:29 +00002521 EXPECT_EQ(0, mComposerClient->getVsyncIdleCount());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002522}
2523
ramindani431aad42022-02-01 21:44:29 +00002524TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Timeout_2) {
2525 const bool hasDisplayIdleTimerSupport =
2526 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002527 if (!hasDisplayIdleTimerSupport) {
2528 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2529 return;
2530 }
2531
ramindani431aad42022-02-01 21:44:29 +00002532 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
2533 EXPECT_TRUE(mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002534
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002535 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002536 ASSERT_NE(nullptr, buffer->handle);
2537
2538 const auto layer = createOnScreenLayer();
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002539 auto& writer = getWriter(getPrimaryDisplayId());
2540 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer->handle,
2541 /*acquireFence*/ -1);
ramindani431aad42022-02-01 21:44:29 +00002542 int32_t vsyncIdleCount = mComposerClient->getVsyncIdleCount();
Midas Chiena0b56bd2022-01-13 23:27:33 +08002543 auto earlyVsyncIdleTime = systemTime() + std::chrono::nanoseconds(2s).count();
ramindani431aad42022-02-01 21:44:29 +00002544 EXPECT_TRUE(
2545 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 2000).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002546
2547 const sp<::android::Fence> presentFence =
ramindani431aad42022-02-01 21:44:29 +00002548 presentAndGetFence(ComposerClientWriter::kNoTimestamp);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002549 presentFence->waitForever(LOG_TAG);
2550
2551 std::this_thread::sleep_for(3s);
ramindani431aad42022-02-01 21:44:29 +00002552 if (vsyncIdleCount < mComposerClient->getVsyncIdleCount()) {
2553 EXPECT_GE(mComposerClient->getVsyncIdleTime(), earlyVsyncIdleTime);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002554 }
2555
ramindani431aad42022-02-01 21:44:29 +00002556 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002557}
2558
ramindani12423f52023-06-14 20:04:51 -07002559class GraphicsComposerAidlCommandV2Test : public GraphicsComposerAidlCommandTest {
2560 protected:
2561 void SetUp() override {
2562 GraphicsComposerAidlTest::SetUp();
2563 if (getInterfaceVersion() <= 1) {
2564 GTEST_SKIP() << "Device interface version is expected to be >= 2";
2565 }
ramindani17c71102023-03-20 10:51:14 -07002566 }
ramindani12423f52023-06-14 20:04:51 -07002567};
2568/**
2569 * Test Capability::SKIP_VALIDATE
2570 *
2571 * Capability::SKIP_VALIDATE has been deprecated and should not be enabled.
2572 */
2573TEST_P(GraphicsComposerAidlCommandV2Test, SkipValidateDeprecatedTest) {
2574 ASSERT_FALSE(hasCapability(Capability::SKIP_VALIDATE))
2575 << "Found Capability::SKIP_VALIDATE capability.";
2576}
2577
2578TEST_P(GraphicsComposerAidlCommandV2Test, SetLayerBufferSlotsToClear) {
2579 // Older HAL versions use a backwards compatible way of clearing buffer slots
2580 // HAL at version 1 or lower does not have LayerCommand::bufferSlotsToClear
2581 const auto& [layerStatus, layer] =
2582 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2583 EXPECT_TRUE(layerStatus.isOk());
2584 auto& writer = getWriter(getPrimaryDisplayId());
2585
2586 // setup 3 buffers in the buffer cache, with the last buffer being active
2587 // then emulate the Android platform code that clears all 3 buffer slots
2588
2589 const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2590 ASSERT_NE(nullptr, buffer1);
2591 const auto handle1 = buffer1->handle;
2592 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle1, /*acquireFence*/ -1);
2593 execute();
2594 ASSERT_TRUE(mReader.takeErrors().empty());
2595
2596 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2597 ASSERT_NE(nullptr, buffer2);
2598 const auto handle2 = buffer2->handle;
2599 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 1, handle2, /*acquireFence*/ -1);
2600 execute();
2601 ASSERT_TRUE(mReader.takeErrors().empty());
2602
2603 const auto buffer3 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2604 ASSERT_NE(nullptr, buffer3);
2605 const auto handle3 = buffer3->handle;
2606 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 2, handle3, /*acquireFence*/ -1);
2607 execute();
2608 ASSERT_TRUE(mReader.takeErrors().empty());
2609
2610 // Ensure we can clear all 3 buffer slots, even the active buffer - it is assumed the
2611 // current active buffer's slot will be cleared, but still remain the active buffer and no
2612 // errors will occur.
2613 writer.setLayerBufferSlotsToClear(getPrimaryDisplayId(), layer, {0, 1, 2});
2614 execute();
2615 ASSERT_TRUE(mReader.takeErrors().empty());
2616}
2617
2618TEST_P(GraphicsComposerAidlCommandV2Test, SetRefreshRateChangedCallbackDebug_Unsupported) {
ramindani9dd8c482023-02-21 18:07:56 -08002619 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2620 auto status = mComposerClient->setRefreshRateChangedCallbackDebugEnabled(
2621 getPrimaryDisplayId(), /*enabled*/ true);
2622 EXPECT_FALSE(status.isOk());
2623 EXPECT_NO_FATAL_FAILURE(
2624 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
2625
2626 status = mComposerClient->setRefreshRateChangedCallbackDebugEnabled(getPrimaryDisplayId(),
2627 /*enabled*/ false);
2628 EXPECT_FALSE(status.isOk());
2629 EXPECT_NO_FATAL_FAILURE(
2630 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
2631 }
2632}
2633
ramindani12423f52023-06-14 20:04:51 -07002634TEST_P(GraphicsComposerAidlCommandV2Test, SetRefreshRateChangedCallbackDebug_Enabled) {
ramindani9dd8c482023-02-21 18:07:56 -08002635 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2636 GTEST_SUCCEED() << "Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG is not supported";
2637 return;
2638 }
2639
2640 const auto displayId = getPrimaryDisplayId();
2641 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2642 // Enable the callback
2643 ASSERT_TRUE(mComposerClient
2644 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2645 /*enabled*/ true)
2646 .isOk());
2647 std::this_thread::sleep_for(100ms);
2648
ramindani91518892023-03-03 16:55:09 +00002649 const auto displayFilter = [displayId](auto refreshRateChangedDebugData) {
2650 return displayId == refreshRateChangedDebugData.display;
2651 };
ramindani9dd8c482023-02-21 18:07:56 -08002652
2653 // Check that we immediately got a callback
ramindani91518892023-03-03 16:55:09 +00002654 EXPECT_TRUE(checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter));
ramindani9dd8c482023-02-21 18:07:56 -08002655
2656 ASSERT_TRUE(mComposerClient
2657 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2658 /*enabled*/ false)
2659 .isOk());
2660}
2661
ramindani12423f52023-06-14 20:04:51 -07002662TEST_P(GraphicsComposerAidlCommandV2Test,
ramindani9dd8c482023-02-21 18:07:56 -08002663 SetRefreshRateChangedCallbackDebugEnabled_noCallbackWhenIdle) {
2664 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2665 GTEST_SUCCEED() << "Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG is not supported";
2666 return;
2667 }
2668
2669 auto display = getEditablePrimaryDisplay();
2670 const auto displayId = display.getDisplayId();
2671
2672 if (!hasDisplayCapability(displayId, DisplayCapability::DISPLAY_IDLE_TIMER)) {
2673 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2674 return;
2675 }
2676
2677 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2678 EXPECT_TRUE(mComposerClient->setPeakRefreshRateConfig(&display).isOk());
2679
2680 ASSERT_TRUE(mComposerClient->setIdleTimerEnabled(displayId, /*timeoutMs*/ 500).isOk());
2681 // Enable the callback
2682 ASSERT_TRUE(mComposerClient
2683 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2684 /*enabled*/ true)
2685 .isOk());
2686
ramindani91518892023-03-03 16:55:09 +00002687 const auto displayFilter = [displayId](auto refreshRateChangedDebugData) {
2688 return displayId == refreshRateChangedDebugData.display;
2689 };
ramindani9dd8c482023-02-21 18:07:56 -08002690
2691 int retryCount = 3;
2692 do {
2693 // Wait for 1s so that we enter the idle state
2694 std::this_thread::sleep_for(1s);
ramindani91518892023-03-03 16:55:09 +00002695 if (!checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter)) {
ramindani9dd8c482023-02-21 18:07:56 -08002696 // DID NOT receive a callback, we are in the idle state.
2697 break;
2698 }
2699 } while (--retryCount > 0);
2700
2701 if (retryCount == 0) {
2702 GTEST_SUCCEED() << "Unable to enter the idle mode";
2703 return;
2704 }
2705
2706 // Send the REFRESH_RATE_INDICATOR update
2707 ASSERT_NO_FATAL_FAILURE(
2708 sendBufferUpdate(createOnScreenLayer(Composition::REFRESH_RATE_INDICATOR)));
2709 std::this_thread::sleep_for(1s);
ramindani91518892023-03-03 16:55:09 +00002710 EXPECT_FALSE(checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter))
ramindani9dd8c482023-02-21 18:07:56 -08002711 << "A callback should not be received for REFRESH_RATE_INDICATOR";
2712
2713 EXPECT_TRUE(mComposerClient
2714 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2715 /*enabled*/ false)
2716 .isOk());
2717}
2718
ramindani12423f52023-06-14 20:04:51 -07002719TEST_P(GraphicsComposerAidlCommandV2Test,
ramindani9dd8c482023-02-21 18:07:56 -08002720 SetRefreshRateChangedCallbackDebugEnabled_SetActiveConfigWithConstraints) {
2721 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2722 GTEST_SUCCEED() << "Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG is not supported";
2723 return;
2724 }
2725
2726 VsyncPeriodChangeConstraints constraints;
2727 constraints.seamlessRequired = false;
2728 constraints.desiredTimeNanos = systemTime();
2729
2730 for (VtsDisplay& display : mDisplays) {
2731 const auto displayId = display.getDisplayId();
2732 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2733
2734 // Enable the callback
2735 ASSERT_TRUE(mComposerClient
2736 ->setRefreshRateChangedCallbackDebugEnabled(displayId, /*enabled*/ true)
2737 .isOk());
2738
2739 forEachTwoConfigs(displayId, [&](int32_t config1, int32_t config2) {
2740 const int32_t vsyncPeriod1 = display.getDisplayConfig(config1).vsyncPeriod;
2741 const int32_t vsyncPeriod2 = display.getDisplayConfig(config2).vsyncPeriod;
2742
2743 if (vsyncPeriod1 == vsyncPeriod2) {
2744 return; // continue
2745 }
2746
2747 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
2748 sendRefreshFrame(display, nullptr);
2749
2750 const auto& [status, timeline] =
2751 mComposerClient->setActiveConfigWithConstraints(&display, config2, constraints);
2752 EXPECT_TRUE(status.isOk());
2753
2754 if (timeline.refreshRequired) {
2755 sendRefreshFrame(display, &timeline);
2756 }
2757
ramindani91518892023-03-03 16:55:09 +00002758 const auto callbackFilter = [displayId,
2759 vsyncPeriod2](auto refreshRateChangedDebugData) {
2760 constexpr int kVsyncThreshold = 1000;
2761 return displayId == refreshRateChangedDebugData.display &&
2762 std::abs(vsyncPeriod2 - refreshRateChangedDebugData.vsyncPeriodNanos) <=
2763 kVsyncThreshold;
2764 };
ramindani9dd8c482023-02-21 18:07:56 -08002765
2766 int retryCount = 3;
2767 do {
2768 std::this_thread::sleep_for(100ms);
ramindani91518892023-03-03 16:55:09 +00002769 if (checkIfCallbackRefreshRateChangedDebugEnabledReceived(callbackFilter)) {
ramindani9dd8c482023-02-21 18:07:56 -08002770 GTEST_SUCCEED() << "Received a callback successfully";
2771 break;
2772 }
2773 } while (--retryCount > 0);
2774
2775 if (retryCount == 0) {
2776 GTEST_FAIL() << "failed to get a callback for the display " << displayId
2777 << " with config " << config2;
2778 }
2779 });
2780
2781 EXPECT_TRUE(
2782 mComposerClient
2783 ->setRefreshRateChangedCallbackDebugEnabled(displayId, /*enabled*/ false)
2784 .isOk());
2785 }
2786}
2787
ramindanidcfe3a82021-11-29 17:00:31 +00002788GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlCommandTest);
2789INSTANTIATE_TEST_SUITE_P(
2790 PerInstance, GraphicsComposerAidlCommandTest,
2791 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
2792 ::android::PrintInstanceNameToString);
ramindanid32ae8e2021-10-01 18:48:39 +00002793GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlTest);
2794INSTANTIATE_TEST_SUITE_P(
2795 PerInstance, GraphicsComposerAidlTest,
2796 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
2797 ::android::PrintInstanceNameToString);
ramindani12423f52023-06-14 20:04:51 -07002798GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlV2Test);
2799INSTANTIATE_TEST_SUITE_P(
2800 PerInstance, GraphicsComposerAidlV2Test,
2801 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
2802 ::android::PrintInstanceNameToString);
ramindani02fe4772023-06-30 18:04:41 -07002803GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlV3Test);
2804INSTANTIATE_TEST_SUITE_P(
2805 PerInstance, GraphicsComposerAidlV3Test,
2806 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
2807 ::android::PrintInstanceNameToString);
ramindani12423f52023-06-14 20:04:51 -07002808GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlCommandV2Test);
2809INSTANTIATE_TEST_SUITE_P(
2810 PerInstance, GraphicsComposerAidlCommandV2Test,
2811 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
2812 ::android::PrintInstanceNameToString);
2813
ramindanid32ae8e2021-10-01 18:48:39 +00002814} // namespace aidl::android::hardware::graphics::composer3::vts
2815
2816int main(int argc, char** argv) {
2817 ::testing::InitGoogleTest(&argc, argv);
2818
2819 using namespace std::chrono_literals;
2820 if (!android::base::WaitForProperty("init.svc.surfaceflinger", "stopped", 10s)) {
2821 ALOGE("Failed to stop init.svc.surfaceflinger");
2822 return -1;
2823 }
ramindanibeea10e2021-12-07 21:02:49 +00002824
2825 android::ProcessState::self()->setThreadPoolMaxThreadCount(4);
2826
2827 // The binder threadpool we start will inherit sched policy and priority
2828 // of (this) creating thread. We want the binder thread pool to have
2829 // SCHED_FIFO policy and priority 1 (lowest RT priority)
2830 // Once the pool is created we reset this thread's priority back to
2831 // original.
2832 // This thread policy is based on what we do in the SurfaceFlinger while starting
2833 // the thread pool and we need to replicate that for the VTS tests.
2834 int newPriority = 0;
2835 int origPolicy = sched_getscheduler(0);
2836 struct sched_param origSchedParam;
2837
2838 int errorInPriorityModification = sched_getparam(0, &origSchedParam);
2839 if (errorInPriorityModification == 0) {
2840 int policy = SCHED_FIFO;
2841 newPriority = sched_get_priority_min(policy);
2842
2843 struct sched_param param;
2844 param.sched_priority = newPriority;
2845
2846 errorInPriorityModification = sched_setscheduler(0, policy, &param);
2847 }
2848
2849 // start the thread pool
2850 android::ProcessState::self()->startThreadPool();
2851
2852 // Reset current thread's policy and priority
2853 if (errorInPriorityModification == 0) {
2854 errorInPriorityModification = sched_setscheduler(0, origPolicy, &origSchedParam);
2855 } else {
2856 ALOGE("Failed to set VtsHalGraphicsComposer3_TargetTest binder threadpool priority to "
2857 "SCHED_FIFO");
2858 }
2859
ramindanid32ae8e2021-10-01 18:48:39 +00002860 return RUN_ALL_TESTS();
Leon Scroggins III45095052023-03-23 18:23:15 -04002861}