blob: bbcd36ff7bbb161b32f92f8b4e2016d771dd9063 [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
ramindanidcfe3a82021-11-29 17:00:31 +00001211// Tests for Command.
1212class GraphicsComposerAidlCommandTest : public GraphicsComposerAidlTest {
1213 protected:
ramindanidcfe3a82021-11-29 17:00:31 +00001214 void TearDown() override {
Ady Abraham3192f3d2021-12-03 16:08:56 -08001215 const auto errors = mReader.takeErrors();
1216 ASSERT_TRUE(mReader.takeErrors().empty());
ramindani431aad42022-02-01 21:44:29 +00001217 ASSERT_TRUE(mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty());
Ady Abraham3192f3d2021-12-03 16:08:56 -08001218
ramindanidcfe3a82021-11-29 17:00:31 +00001219 ASSERT_NO_FATAL_FAILURE(GraphicsComposerAidlTest::TearDown());
1220 }
1221
1222 void execute() {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001223 std::vector<CommandResultPayload> payloads;
1224 for (auto& [_, writer] : mWriters) {
Huihong Luo651806f2023-04-21 18:48:48 +00001225 auto commands = writer.takePendingCommands();
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001226 if (commands.empty()) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001227 continue;
1228 }
1229
1230 auto [status, results] = mComposerClient->executeCommands(commands);
1231 ASSERT_TRUE(status.isOk()) << "executeCommands failed " << status.getDescription();
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001232
1233 payloads.reserve(payloads.size() + results.size());
1234 payloads.insert(payloads.end(), std::make_move_iterator(results.begin()),
1235 std::make_move_iterator(results.end()));
ramindanidcfe3a82021-11-29 17:00:31 +00001236 }
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001237 mReader.parse(std::move(payloads));
ramindanidcfe3a82021-11-29 17:00:31 +00001238 }
1239
1240 static inline auto toTimePoint(nsecs_t time) {
1241 return std::chrono::time_point<std::chrono::steady_clock>(std::chrono::nanoseconds(time));
1242 }
1243
ramindanidcfe3a82021-11-29 17:00:31 +00001244 void forEachTwoConfigs(int64_t display, std::function<void(int32_t, int32_t)> func) {
ramindani431aad42022-02-01 21:44:29 +00001245 const auto& [status, displayConfigs] = mComposerClient->getDisplayConfigs(display);
1246 ASSERT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001247 for (const int32_t config1 : displayConfigs) {
1248 for (const int32_t config2 : displayConfigs) {
1249 if (config1 != config2) {
1250 func(config1, config2);
1251 }
1252 }
1253 }
1254 }
1255
1256 void waitForVsyncPeriodChange(int64_t display, const VsyncPeriodChangeTimeline& timeline,
1257 int64_t desiredTimeNanos, int64_t oldPeriodNanos,
1258 int64_t newPeriodNanos) {
1259 const auto kChangeDeadline = toTimePoint(timeline.newVsyncAppliedTimeNanos) + 100ms;
1260 while (std::chrono::steady_clock::now() <= kChangeDeadline) {
ramindani431aad42022-02-01 21:44:29 +00001261 const auto& [status, vsyncPeriodNanos] =
1262 mComposerClient->getDisplayVsyncPeriod(display);
1263 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001264 if (systemTime() <= desiredTimeNanos) {
1265 EXPECT_EQ(vsyncPeriodNanos, oldPeriodNanos);
1266 } else if (vsyncPeriodNanos == newPeriodNanos) {
1267 break;
1268 }
1269 std::this_thread::sleep_for(std::chrono::nanoseconds(oldPeriodNanos));
1270 }
1271 }
1272
ramindani9dd8c482023-02-21 18:07:56 -08001273 bool checkIfCallbackRefreshRateChangedDebugEnabledReceived(
1274 std::function<bool(RefreshRateChangedDebugData)> filter) {
1275 const auto list = mComposerClient->takeListOfRefreshRateChangedDebugData();
1276 return std::any_of(list.begin(), list.end(), [&](auto refreshRateChangedDebugData) {
1277 return filter(refreshRateChangedDebugData);
1278 });
1279 }
1280
Brian Lindahl25e0d092022-12-09 00:32:11 -07001281 sp<GraphicBuffer> allocate(uint32_t width, uint32_t height,
1282 ::android::PixelFormat pixelFormat) {
Brian Lindahl14bd07b2023-01-17 14:54:39 -07001283 return sp<GraphicBuffer>::make(
Brian Lindahl25e0d092022-12-09 00:32:11 -07001284 width, height, pixelFormat, /*layerCount*/ 1U,
1285 static_cast<uint64_t>(common::BufferUsage::CPU_WRITE_OFTEN) |
1286 static_cast<uint64_t>(common::BufferUsage::CPU_READ_OFTEN) |
1287 static_cast<uint64_t>(common::BufferUsage::COMPOSER_OVERLAY),
Brian Lindahl14bd07b2023-01-17 14:54:39 -07001288 "VtsHalGraphicsComposer3_TargetTest");
Brian Lindahlca3eef22022-12-09 00:32:11 -07001289 }
1290
Brian Lindahl25e0d092022-12-09 00:32:11 -07001291 sp<GraphicBuffer> allocate(::android::PixelFormat pixelFormat) {
1292 return allocate(static_cast<uint32_t>(getPrimaryDisplay().getDisplayWidth()),
1293 static_cast<uint32_t>(getPrimaryDisplay().getDisplayHeight()), pixelFormat);
1294 }
1295
ramindanidcfe3a82021-11-29 17:00:31 +00001296 void sendRefreshFrame(const VtsDisplay& display, const VsyncPeriodChangeTimeline* timeline) {
1297 if (timeline != nullptr) {
1298 // Refresh time should be before newVsyncAppliedTimeNanos
1299 EXPECT_LT(timeline->refreshTimeNanos, timeline->newVsyncAppliedTimeNanos);
1300
1301 std::this_thread::sleep_until(toTimePoint(timeline->refreshTimeNanos));
1302 }
1303
ramindani431aad42022-02-01 21:44:29 +00001304 EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::ON).isOk());
1305 EXPECT_TRUE(mComposerClient
1306 ->setColorMode(display.getDisplayId(), ColorMode::NATIVE,
1307 RenderIntent::COLORIMETRIC)
1308 .isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001309
ramindani431aad42022-02-01 21:44:29 +00001310 const auto& [status, layer] =
1311 mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount);
1312 EXPECT_TRUE(status.isOk());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001313 auto& writer = getWriter(display.getDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001314 {
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001315 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindanidcfe3a82021-11-29 17:00:31 +00001316 ASSERT_NE(nullptr, buffer);
1317 ASSERT_EQ(::android::OK, buffer->initCheck());
1318 ASSERT_NE(nullptr, buffer->handle);
1319
ramindani431aad42022-02-01 21:44:29 +00001320 configureLayer(display, layer, Composition::DEVICE, display.getFrameRect(),
1321 display.getCrop());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001322 writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, buffer->handle,
1323 /*acquireFence*/ -1);
1324 writer.setLayerDataspace(display.getDisplayId(), layer, common::Dataspace::UNKNOWN);
ramindanidcfe3a82021-11-29 17:00:31 +00001325
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001326 writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp);
ramindanidcfe3a82021-11-29 17:00:31 +00001327 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001328 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001329
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001330 writer.presentDisplay(display.getDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001331 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001332 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001333 }
1334
1335 {
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001336 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindanidcfe3a82021-11-29 17:00:31 +00001337 ASSERT_NE(nullptr, buffer->handle);
1338
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001339 writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, buffer->handle,
1340 /*acquireFence*/ -1);
1341 writer.setLayerSurfaceDamage(display.getDisplayId(), layer,
1342 std::vector<Rect>(1, {0, 0, 10, 10}));
1343 writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp);
ramindanidcfe3a82021-11-29 17:00:31 +00001344 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001345 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001346
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001347 writer.presentDisplay(display.getDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001348 execute();
1349 }
1350
ramindani431aad42022-02-01 21:44:29 +00001351 EXPECT_TRUE(mComposerClient->destroyLayer(display.getDisplayId(), layer).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001352 }
1353
Ady Abraham72c5b502021-12-10 17:23:39 -08001354 sp<::android::Fence> presentAndGetFence(
1355 std::optional<ClockMonotonicTimestamp> expectedPresentTime) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001356 auto& writer = getWriter(getPrimaryDisplayId());
1357 writer.validateDisplay(getPrimaryDisplayId(), expectedPresentTime);
Ady Abraham72c5b502021-12-10 17:23:39 -08001358 execute();
1359 EXPECT_TRUE(mReader.takeErrors().empty());
1360
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001361 writer.presentDisplay(getPrimaryDisplayId());
Ady Abraham72c5b502021-12-10 17:23:39 -08001362 execute();
1363 EXPECT_TRUE(mReader.takeErrors().empty());
1364
ramindani431aad42022-02-01 21:44:29 +00001365 auto presentFence = mReader.takePresentFence(getPrimaryDisplayId());
Ady Abraham46219f52021-12-20 09:44:31 -08001366 // take ownership
1367 const int fenceOwner = presentFence.get();
1368 *presentFence.getR() = -1;
1369 EXPECT_NE(-1, fenceOwner);
1370 return sp<::android::Fence>::make(fenceOwner);
Ady Abraham72c5b502021-12-10 17:23:39 -08001371 }
1372
1373 int32_t getVsyncPeriod() {
ramindani431aad42022-02-01 21:44:29 +00001374 const auto& [status, activeConfig] =
1375 mComposerClient->getActiveConfig(getPrimaryDisplayId());
1376 EXPECT_TRUE(status.isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001377
ramindani431aad42022-02-01 21:44:29 +00001378 const auto& [vsyncPeriodStatus, vsyncPeriod] = mComposerClient->getDisplayAttribute(
1379 getPrimaryDisplayId(), activeConfig, DisplayAttribute::VSYNC_PERIOD);
1380 EXPECT_TRUE(vsyncPeriodStatus.isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001381 return vsyncPeriod;
1382 }
1383
ramindani9dd8c482023-02-21 18:07:56 -08001384 int64_t createOnScreenLayer(Composition composition = Composition::DEVICE) {
ramindani431aad42022-02-01 21:44:29 +00001385 const auto& [status, layer] =
1386 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1387 EXPECT_TRUE(status.isOk());
1388 Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
1389 getPrimaryDisplay().getDisplayHeight()};
1390 FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
1391 (float)getPrimaryDisplay().getDisplayHeight()};
ramindani9dd8c482023-02-21 18:07:56 -08001392 configureLayer(getPrimaryDisplay(), layer, composition, displayFrame, cropRect);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001393 auto& writer = getWriter(getPrimaryDisplayId());
1394 writer.setLayerDataspace(getPrimaryDisplayId(), layer, common::Dataspace::UNKNOWN);
Ady Abraham72c5b502021-12-10 17:23:39 -08001395 return layer;
1396 }
1397
ramindani9dd8c482023-02-21 18:07:56 -08001398 void sendBufferUpdate(int64_t layer) {
1399 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1400 ASSERT_NE(nullptr, buffer->handle);
1401
1402 auto& writer = getWriter(getPrimaryDisplayId());
1403 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer->handle,
1404 /*acquireFence*/ -1);
1405
1406 const sp<::android::Fence> presentFence =
1407 presentAndGetFence(ComposerClientWriter::kNoTimestamp);
1408 presentFence->waitForever(LOG_TAG);
1409 }
1410
Midas Chiena0b56bd2022-01-13 23:27:33 +08001411 bool hasDisplayCapability(int64_t display, DisplayCapability cap) {
ramindani431aad42022-02-01 21:44:29 +00001412 const auto& [status, capabilities] = mComposerClient->getDisplayCapabilities(display);
1413 EXPECT_TRUE(status.isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08001414
1415 return std::find(capabilities.begin(), capabilities.end(), cap) != capabilities.end();
1416 }
1417
ramindanidcfe3a82021-11-29 17:00:31 +00001418 void Test_setActiveConfigWithConstraints(const TestParameters& params) {
1419 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +00001420 forEachTwoConfigs(display.getDisplayId(), [&](int32_t config1, int32_t config2) {
1421 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001422 sendRefreshFrame(display, nullptr);
1423
ramindani431aad42022-02-01 21:44:29 +00001424 const auto displayConfigGroup1 = display.getDisplayConfig(config1);
1425 int32_t vsyncPeriod1 = displayConfigGroup1.vsyncPeriod;
1426 int32_t configGroup1 = displayConfigGroup1.configGroup;
1427
1428 const auto displayConfigGroup2 = display.getDisplayConfig(config2);
1429 int32_t vsyncPeriod2 = displayConfigGroup2.vsyncPeriod;
1430 int32_t configGroup2 = displayConfigGroup2.configGroup;
ramindanidcfe3a82021-11-29 17:00:31 +00001431
1432 if (vsyncPeriod1 == vsyncPeriod2) {
1433 return; // continue
1434 }
1435
1436 // We don't allow delayed change when changing config groups
1437 if (params.delayForChange > 0 && configGroup1 != configGroup2) {
1438 return; // continue
1439 }
1440
ramindanidcfe3a82021-11-29 17:00:31 +00001441 VsyncPeriodChangeConstraints constraints = {
1442 .desiredTimeNanos = systemTime() + params.delayForChange,
1443 .seamlessRequired = false};
ramindani431aad42022-02-01 21:44:29 +00001444 const auto& [status, timeline] = mComposerClient->setActiveConfigWithConstraints(
1445 &display, config2, constraints);
1446 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001447
1448 EXPECT_TRUE(timeline.newVsyncAppliedTimeNanos >= constraints.desiredTimeNanos);
1449 // Refresh rate should change within a reasonable time
1450 constexpr std::chrono::nanoseconds kReasonableTimeForChange = 1s; // 1 second
1451 EXPECT_TRUE(timeline.newVsyncAppliedTimeNanos - constraints.desiredTimeNanos <=
1452 kReasonableTimeForChange.count());
1453
1454 if (timeline.refreshRequired) {
1455 if (params.refreshMiss) {
1456 // Miss the refresh frame on purpose to make sure the implementation sends a
1457 // callback
1458 std::this_thread::sleep_until(toTimePoint(timeline.refreshTimeNanos) +
1459 100ms);
1460 }
1461 sendRefreshFrame(display, &timeline);
1462 }
ramindani431aad42022-02-01 21:44:29 +00001463 waitForVsyncPeriodChange(display.getDisplayId(), timeline,
1464 constraints.desiredTimeNanos, vsyncPeriod1, vsyncPeriod2);
ramindanidcfe3a82021-11-29 17:00:31 +00001465
1466 // At this point the refresh rate should have changed already, however in rare
1467 // cases the implementation might have missed the deadline. In this case a new
1468 // timeline should have been provided.
ramindani431aad42022-02-01 21:44:29 +00001469 auto newTimeline = mComposerClient->takeLastVsyncPeriodChangeTimeline();
ramindanidcfe3a82021-11-29 17:00:31 +00001470 if (timeline.refreshRequired && params.refreshMiss) {
1471 EXPECT_TRUE(newTimeline.has_value());
1472 }
1473
1474 if (newTimeline.has_value()) {
1475 if (newTimeline->refreshRequired) {
1476 sendRefreshFrame(display, &newTimeline.value());
1477 }
ramindani431aad42022-02-01 21:44:29 +00001478 waitForVsyncPeriodChange(display.getDisplayId(), newTimeline.value(),
ramindanidcfe3a82021-11-29 17:00:31 +00001479 constraints.desiredTimeNanos, vsyncPeriod1,
1480 vsyncPeriod2);
1481 }
1482
ramindani431aad42022-02-01 21:44:29 +00001483 const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanos] =
1484 mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
1485 EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001486 EXPECT_EQ(vsyncPeriodNanos, vsyncPeriod2);
1487 });
1488 }
1489 }
1490
Ady Abraham72c5b502021-12-10 17:23:39 -08001491 void Test_expectedPresentTime(std::optional<int> framesDelay) {
Jason Macnak325e8232022-01-24 14:48:55 -08001492 if (hasCapability(Capability::PRESENT_FENCE_IS_NOT_RELIABLE)) {
1493 GTEST_SUCCEED() << "Device has unreliable present fences capability, skipping";
1494 return;
1495 }
1496
ramindani431aad42022-02-01 21:44:29 +00001497 ASSERT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001498
1499 const auto vsyncPeriod = getVsyncPeriod();
1500
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001501 const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1502 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
Ady Abraham72c5b502021-12-10 17:23:39 -08001503 ASSERT_NE(nullptr, buffer1);
1504 ASSERT_NE(nullptr, buffer2);
1505
1506 const auto layer = createOnScreenLayer();
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001507 auto& writer = getWriter(getPrimaryDisplayId());
1508 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer1->handle,
1509 /*acquireFence*/ -1);
Ady Abraham72c5b502021-12-10 17:23:39 -08001510 const sp<::android::Fence> presentFence1 =
1511 presentAndGetFence(ComposerClientWriter::kNoTimestamp);
1512 presentFence1->waitForever(LOG_TAG);
1513
1514 auto expectedPresentTime = presentFence1->getSignalTime() + vsyncPeriod;
1515 if (framesDelay.has_value()) {
1516 expectedPresentTime += *framesDelay * vsyncPeriod;
1517 }
1518
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001519 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer2->handle,
1520 /*acquireFence*/ -1);
Ady Abraham72c5b502021-12-10 17:23:39 -08001521 const auto setExpectedPresentTime = [&]() -> std::optional<ClockMonotonicTimestamp> {
1522 if (!framesDelay.has_value()) {
1523 return ComposerClientWriter::kNoTimestamp;
1524 } else if (*framesDelay == 0) {
1525 return ClockMonotonicTimestamp{0};
1526 }
1527 return ClockMonotonicTimestamp{expectedPresentTime};
1528 }();
1529
1530 const sp<::android::Fence> presentFence2 = presentAndGetFence(setExpectedPresentTime);
1531 presentFence2->waitForever(LOG_TAG);
1532
1533 const auto actualPresentTime = presentFence2->getSignalTime();
Ady Abrahamdf084f32022-01-10 14:10:23 -08001534 EXPECT_GE(actualPresentTime, expectedPresentTime - vsyncPeriod / 2);
Ady Abraham72c5b502021-12-10 17:23:39 -08001535
ramindani431aad42022-02-01 21:44:29 +00001536 ASSERT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
Ady Abraham72c5b502021-12-10 17:23:39 -08001537 }
1538
ramindani431aad42022-02-01 21:44:29 +00001539 void configureLayer(const VtsDisplay& display, int64_t layer, Composition composition,
1540 const Rect& displayFrame, const FRect& cropRect) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001541 auto& writer = getWriter(display.getDisplayId());
1542 writer.setLayerCompositionType(display.getDisplayId(), layer, composition);
1543 writer.setLayerDisplayFrame(display.getDisplayId(), layer, displayFrame);
1544 writer.setLayerPlaneAlpha(display.getDisplayId(), layer, /*alpha*/ 1);
1545 writer.setLayerSourceCrop(display.getDisplayId(), layer, cropRect);
1546 writer.setLayerTransform(display.getDisplayId(), layer, static_cast<Transform>(0));
1547 writer.setLayerVisibleRegion(display.getDisplayId(), layer,
1548 std::vector<Rect>(1, displayFrame));
1549 writer.setLayerZOrder(display.getDisplayId(), layer, /*z*/ 10);
1550 writer.setLayerBlendMode(display.getDisplayId(), layer, BlendMode::NONE);
1551 writer.setLayerSurfaceDamage(display.getDisplayId(), layer,
1552 std::vector<Rect>(1, displayFrame));
ramindani431aad42022-02-01 21:44:29 +00001553 }
ramindanidcfe3a82021-11-29 17:00:31 +00001554 // clang-format off
1555 const std::array<float, 16> kIdentity = {{
1556 1.0f, 0.0f, 0.0f, 0.0f,
1557 0.0f, 1.0f, 0.0f, 0.0f,
1558 0.0f, 0.0f, 1.0f, 0.0f,
1559 0.0f, 0.0f, 0.0f, 1.0f,
1560 }};
1561 // clang-format on
1562
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001563 ComposerClientWriter& getWriter(int64_t display) {
1564 auto [it, _] = mWriters.try_emplace(display, display);
1565 return it->second;
1566 }
1567
Ady Abraham91c9d1a2021-12-15 18:14:45 -08001568 ComposerClientReader mReader;
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001569
1570 private:
1571 std::unordered_map<int64_t, ComposerClientWriter> mWriters;
ramindanidcfe3a82021-11-29 17:00:31 +00001572};
1573
ramindani431aad42022-02-01 21:44:29 +00001574TEST_P(GraphicsComposerAidlCommandTest, SetColorTransform) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001575 auto& writer = getWriter(getPrimaryDisplayId());
1576 writer.setColorTransform(getPrimaryDisplayId(), kIdentity.data());
ramindanidcfe3a82021-11-29 17:00:31 +00001577 execute();
1578}
1579
1580TEST_P(GraphicsComposerAidlCommandTest, SetLayerColorTransform) {
ramindani431aad42022-02-01 21:44:29 +00001581 const auto& [status, layer] =
1582 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1583 EXPECT_TRUE(status.isOk());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001584 auto& writer = getWriter(getPrimaryDisplayId());
1585 writer.setLayerColorTransform(getPrimaryDisplayId(), layer, kIdentity.data());
ramindanidcfe3a82021-11-29 17:00:31 +00001586 execute();
1587
Ady Abraham3192f3d2021-12-03 16:08:56 -08001588 const auto errors = mReader.takeErrors();
Jason Macnak062bc9a2022-01-20 15:00:09 -08001589 if (errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_UNSUPPORTED) {
ramindanidcfe3a82021-11-29 17:00:31 +00001590 GTEST_SUCCEED() << "setLayerColorTransform is not supported";
1591 return;
1592 }
1593}
1594
Alec Mouri60564e12021-12-09 18:48:20 -08001595TEST_P(GraphicsComposerAidlCommandTest, SetDisplayBrightness) {
ramindani431aad42022-02-01 21:44:29 +00001596 const auto& [status, capabilities] =
1597 mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
1598 ASSERT_TRUE(status.isOk());
Alec Mouri60564e12021-12-09 18:48:20 -08001599 bool brightnessSupport = std::find(capabilities.begin(), capabilities.end(),
1600 DisplayCapability::BRIGHTNESS) != capabilities.end();
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001601 auto& writer = getWriter(getPrimaryDisplayId());
Alec Mouri60564e12021-12-09 18:48:20 -08001602 if (!brightnessSupport) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001603 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.5f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001604 execute();
1605 const auto errors = mReader.takeErrors();
1606 EXPECT_EQ(1, errors.size());
Jason Macnak062bc9a2022-01-20 15:00:09 -08001607 EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, errors[0].errorCode);
Alec Mouri60564e12021-12-09 18:48:20 -08001608 GTEST_SUCCEED() << "SetDisplayBrightness is not supported";
1609 return;
1610 }
1611
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001612 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001613 execute();
1614 EXPECT_TRUE(mReader.takeErrors().empty());
1615
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001616 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.5f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001617 execute();
1618 EXPECT_TRUE(mReader.takeErrors().empty());
1619
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001620 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 1.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001621 execute();
1622 EXPECT_TRUE(mReader.takeErrors().empty());
1623
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001624 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ -1.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001625 execute();
1626 EXPECT_TRUE(mReader.takeErrors().empty());
1627
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001628 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 2.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001629 execute();
1630 {
1631 const auto errors = mReader.takeErrors();
ramindanib3bdf052022-01-12 18:27:05 +00001632 ASSERT_EQ(1, errors.size());
Alec Mouri60564e12021-12-09 18:48:20 -08001633 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
1634 }
1635
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001636 writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ -2.0f, -1.f);
Alec Mouri60564e12021-12-09 18:48:20 -08001637 execute();
1638 {
1639 const auto errors = mReader.takeErrors();
ramindanib3bdf052022-01-12 18:27:05 +00001640 ASSERT_EQ(1, errors.size());
Alec Mouri60564e12021-12-09 18:48:20 -08001641 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
1642 }
1643}
1644
ramindani431aad42022-02-01 21:44:29 +00001645TEST_P(GraphicsComposerAidlCommandTest, SetClientTarget) {
1646 EXPECT_TRUE(mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kBufferSlotCount)
1647 .isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001648
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001649 auto& writer = getWriter(getPrimaryDisplayId());
1650 writer.setClientTarget(getPrimaryDisplayId(), /*slot*/ 0, nullptr, /*acquireFence*/ -1,
1651 Dataspace::UNKNOWN, std::vector<Rect>());
ramindanidcfe3a82021-11-29 17:00:31 +00001652
1653 execute();
1654}
1655
ramindani431aad42022-02-01 21:44:29 +00001656TEST_P(GraphicsComposerAidlCommandTest, SetOutputBuffer) {
1657 const auto& [status, virtualDisplayCount] = mComposerClient->getMaxVirtualDisplayCount();
1658 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001659 if (virtualDisplayCount == 0) {
1660 GTEST_SUCCEED() << "no virtual display support";
1661 return;
1662 }
1663
ramindani431aad42022-02-01 21:44:29 +00001664 const auto& [displayStatus, display] = mComposerClient->createVirtualDisplay(
1665 /*width*/ 64, /*height*/ 64, common::PixelFormat::IMPLEMENTATION_DEFINED,
1666 kBufferSlotCount);
1667 EXPECT_TRUE(displayStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001668
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001669 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001670 const auto handle = buffer->handle;
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001671 auto& writer = getWriter(display.display);
1672 writer.setOutputBuffer(display.display, /*slot*/ 0, handle, /*releaseFence*/ -1);
ramindanidcfe3a82021-11-29 17:00:31 +00001673 execute();
1674}
1675
ramindani431aad42022-02-01 21:44:29 +00001676TEST_P(GraphicsComposerAidlCommandTest, ValidDisplay) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001677 auto& writer = getWriter(getPrimaryDisplayId());
1678 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
ramindanidcfe3a82021-11-29 17:00:31 +00001679 execute();
1680}
1681
ramindani431aad42022-02-01 21:44:29 +00001682TEST_P(GraphicsComposerAidlCommandTest, AcceptDisplayChanges) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001683 auto& writer = getWriter(getPrimaryDisplayId());
1684 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
1685 writer.acceptDisplayChanges(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001686 execute();
1687}
1688
ramindani431aad42022-02-01 21:44:29 +00001689TEST_P(GraphicsComposerAidlCommandTest, PresentDisplay) {
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001690 auto& writer = getWriter(getPrimaryDisplayId());
1691 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
1692 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001693 execute();
1694}
1695
1696/**
1697 * Test IComposerClient::Command::PRESENT_DISPLAY
1698 *
1699 * Test that IComposerClient::Command::PRESENT_DISPLAY works without
1700 * additional call to validateDisplay when only the layer buffer handle and
1701 * surface damage have been set
1702 */
ramindani431aad42022-02-01 21:44:29 +00001703TEST_P(GraphicsComposerAidlCommandTest, PresentDisplayNoLayerStateChanges) {
Jason Macnak325e8232022-01-24 14:48:55 -08001704 if (!hasCapability(Capability::SKIP_VALIDATE)) {
ramindanidcfe3a82021-11-29 17:00:31 +00001705 GTEST_SUCCEED() << "Device does not have skip validate capability, skipping";
1706 return;
1707 }
ramindani431aad42022-02-01 21:44:29 +00001708 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001709
ramindani431aad42022-02-01 21:44:29 +00001710 const auto& [renderIntentsStatus, renderIntents] =
1711 mComposerClient->getRenderIntents(getPrimaryDisplayId(), ColorMode::NATIVE);
1712 EXPECT_TRUE(renderIntentsStatus.isOk());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001713 auto& writer = getWriter(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001714 for (auto intent : renderIntents) {
ramindani431aad42022-02-01 21:44:29 +00001715 EXPECT_TRUE(mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE, intent)
1716 .isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001717
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001718 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001719 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001720 ASSERT_NE(nullptr, handle);
1721
ramindani431aad42022-02-01 21:44:29 +00001722 const auto& [layerStatus, layer] =
1723 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1724 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001725
ramindani431aad42022-02-01 21:44:29 +00001726 Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
1727 getPrimaryDisplay().getDisplayHeight()};
1728 FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
1729 (float)getPrimaryDisplay().getDisplayHeight()};
1730 configureLayer(getPrimaryDisplay(), layer, Composition::CURSOR, displayFrame, cropRect);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001731 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle,
1732 /*acquireFence*/ -1);
1733 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
1734 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
ramindanidcfe3a82021-11-29 17:00:31 +00001735 execute();
ramindani431aad42022-02-01 21:44:29 +00001736 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
ramindanidcfe3a82021-11-29 17:00:31 +00001737 GTEST_SUCCEED() << "Composition change requested, skipping test";
1738 return;
1739 }
1740
Ady Abraham3192f3d2021-12-03 16:08:56 -08001741 ASSERT_TRUE(mReader.takeErrors().empty());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001742 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001743 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001744 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001745
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001746 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001747 const auto handle2 = buffer2->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001748 ASSERT_NE(nullptr, handle2);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001749 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle2,
1750 /*acquireFence*/ -1);
1751 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer,
1752 std::vector<Rect>(1, {0, 0, 10, 10}));
1753 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001754 execute();
1755 }
1756}
1757
ramindani431aad42022-02-01 21:44:29 +00001758TEST_P(GraphicsComposerAidlCommandTest, SetLayerCursorPosition) {
1759 const auto& [layerStatus, layer] =
1760 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1761 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001762
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001763 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001764 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001765 ASSERT_NE(nullptr, handle);
ramindanidcfe3a82021-11-29 17:00:31 +00001766
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001767 auto& writer = getWriter(getPrimaryDisplayId());
1768 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle, /*acquireFence*/ -1);
ramindani431aad42022-02-01 21:44:29 +00001769
1770 Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
1771 getPrimaryDisplay().getDisplayHeight()};
1772 FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
1773 (float)getPrimaryDisplay().getDisplayHeight()};
1774 configureLayer(getPrimaryDisplay(), layer, Composition::CURSOR, displayFrame, cropRect);
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001775 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
1776 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
ramindanidcfe3a82021-11-29 17:00:31 +00001777
1778 execute();
Ady Abraham46219f52021-12-20 09:44:31 -08001779
ramindani431aad42022-02-01 21:44:29 +00001780 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
ramindanidcfe3a82021-11-29 17:00:31 +00001781 GTEST_SUCCEED() << "Composition change requested, skipping test";
1782 return;
1783 }
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001784 writer.presentDisplay(getPrimaryDisplayId());
Ady Abraham3192f3d2021-12-03 16:08:56 -08001785 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001786
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001787 writer.setLayerCursorPosition(getPrimaryDisplayId(), layer, /*x*/ 1, /*y*/ 1);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001788 execute();
1789
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001790 writer.setLayerCursorPosition(getPrimaryDisplayId(), layer, /*x*/ 0, /*y*/ 0);
1791 writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
1792 writer.presentDisplay(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00001793 execute();
1794}
1795
ramindani431aad42022-02-01 21:44:29 +00001796TEST_P(GraphicsComposerAidlCommandTest, SetLayerBuffer) {
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001797 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00001798 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00001799 ASSERT_NE(nullptr, handle);
1800
ramindani431aad42022-02-01 21:44:29 +00001801 const auto& [layerStatus, layer] =
1802 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1803 EXPECT_TRUE(layerStatus.isOk());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001804 auto& writer = getWriter(getPrimaryDisplayId());
1805 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle, /*acquireFence*/ -1);
ramindanidcfe3a82021-11-29 17:00:31 +00001806 execute();
1807}
1808
Brian Lindahl25e0d092022-12-09 00:32:11 -07001809TEST_P(GraphicsComposerAidlCommandTest, SetLayerBufferMultipleTimes) {
1810 const auto& [layerStatus, layer] =
1811 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1812 EXPECT_TRUE(layerStatus.isOk());
1813 auto& writer = getWriter(getPrimaryDisplayId());
1814
1815 // Setup 3 buffers in the buffer cache, with the last buffer being active. Then, emulate the
1816 // Android platform code that clears all 3 buffer slots by setting all but the active buffer
1817 // slot to a placeholder buffer, and then restoring the active buffer.
1818
1819 // This is used on HALs that don't support setLayerBufferSlotsToClear (version <= 3.1).
1820
1821 const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1822 ASSERT_NE(nullptr, buffer1);
1823 const auto handle1 = buffer1->handle;
1824 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle1, /*acquireFence*/ -1);
1825 execute();
1826 ASSERT_TRUE(mReader.takeErrors().empty());
1827
1828 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1829 ASSERT_NE(nullptr, buffer2);
1830 const auto handle2 = buffer2->handle;
1831 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 1, handle2, /*acquireFence*/ -1);
1832 execute();
1833 ASSERT_TRUE(mReader.takeErrors().empty());
1834
1835 const auto buffer3 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
1836 ASSERT_NE(nullptr, buffer3);
1837 const auto handle3 = buffer3->handle;
1838 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 2, handle3, /*acquireFence*/ -1);
1839 execute();
1840 ASSERT_TRUE(mReader.takeErrors().empty());
1841
1842 // Older versions of the HAL clear all but the active buffer slot with a placeholder buffer,
1843 // and then restoring the current active buffer at the end
1844 auto clearSlotBuffer = allocate(1u, 1u, ::android::PIXEL_FORMAT_RGB_888);
1845 ASSERT_NE(nullptr, clearSlotBuffer);
1846 auto clearSlotBufferHandle = clearSlotBuffer->handle;
1847
1848 // clear buffer slots 0 and 1 with new layer commands... and then...
1849 writer.setLayerBufferWithNewCommand(getPrimaryDisplayId(), layer, /* slot */ 0,
1850 clearSlotBufferHandle, /*acquireFence*/ -1);
1851 writer.setLayerBufferWithNewCommand(getPrimaryDisplayId(), layer, /* slot */ 1,
1852 clearSlotBufferHandle, /*acquireFence*/ -1);
1853 // ...reset the layer buffer to the current active buffer slot with a final new command
1854 writer.setLayerBufferWithNewCommand(getPrimaryDisplayId(), layer, /*slot*/ 2, nullptr,
1855 /*acquireFence*/ -1);
1856 execute();
1857 ASSERT_TRUE(mReader.takeErrors().empty());
1858}
1859
ramindani431aad42022-02-01 21:44:29 +00001860TEST_P(GraphicsComposerAidlCommandTest, SetLayerSurfaceDamage) {
1861 const auto& [layerStatus, layer] =
1862 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1863 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001864
1865 Rect empty{0, 0, 0, 0};
1866 Rect unit{0, 0, 1, 1};
1867
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001868 auto& writer = getWriter(getPrimaryDisplayId());
1869 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
ramindanidcfe3a82021-11-29 17:00:31 +00001870 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001871 ASSERT_TRUE(mReader.takeErrors().empty());
1872
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001873 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
Ady Abraham3192f3d2021-12-03 16:08:56 -08001874 execute();
1875 ASSERT_TRUE(mReader.takeErrors().empty());
1876
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001877 writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>());
Ady Abraham3192f3d2021-12-03 16:08:56 -08001878 execute();
1879 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001880}
1881
ramindani431aad42022-02-01 21:44:29 +00001882TEST_P(GraphicsComposerAidlCommandTest, SetLayerBlockingRegion) {
1883 const auto& [layerStatus, layer] =
1884 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1885 EXPECT_TRUE(layerStatus.isOk());
Leon Scroggins III03318152022-01-13 12:24:19 -05001886
1887 Rect empty{0, 0, 0, 0};
1888 Rect unit{0, 0, 1, 1};
1889
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001890 auto& writer = getWriter(getPrimaryDisplayId());
1891 writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
Leon Scroggins III03318152022-01-13 12:24:19 -05001892 execute();
1893 ASSERT_TRUE(mReader.takeErrors().empty());
1894
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001895 writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
Leon Scroggins III03318152022-01-13 12:24:19 -05001896 execute();
1897 ASSERT_TRUE(mReader.takeErrors().empty());
1898
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001899 writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>());
Leon Scroggins III03318152022-01-13 12:24:19 -05001900 execute();
1901 ASSERT_TRUE(mReader.takeErrors().empty());
1902}
1903
ramindani431aad42022-02-01 21:44:29 +00001904TEST_P(GraphicsComposerAidlCommandTest, SetLayerBlendMode) {
1905 const auto& [layerStatus, layer] =
1906 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1907 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001908
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001909 auto& writer = getWriter(getPrimaryDisplayId());
1910 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::NONE);
ramindanidcfe3a82021-11-29 17:00:31 +00001911 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001912 ASSERT_TRUE(mReader.takeErrors().empty());
1913
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001914 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::PREMULTIPLIED);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001915 execute();
1916 ASSERT_TRUE(mReader.takeErrors().empty());
1917
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001918 writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::COVERAGE);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001919 execute();
1920 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001921}
1922
ramindani431aad42022-02-01 21:44:29 +00001923TEST_P(GraphicsComposerAidlCommandTest, SetLayerColor) {
1924 const auto& [layerStatus, layer] =
1925 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1926 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001927
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001928 auto& writer = getWriter(getPrimaryDisplayId());
1929 writer.setLayerColor(getPrimaryDisplayId(), layer, Color{1.0f, 1.0f, 1.0f, 1.0f});
ramindanidcfe3a82021-11-29 17:00:31 +00001930 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001931 ASSERT_TRUE(mReader.takeErrors().empty());
1932
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001933 writer.setLayerColor(getPrimaryDisplayId(), layer, Color{0.0f, 0.0f, 0.0f, 0.0f});
Ady Abraham3192f3d2021-12-03 16:08:56 -08001934 execute();
1935 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00001936}
1937
ramindani431aad42022-02-01 21:44:29 +00001938TEST_P(GraphicsComposerAidlCommandTest, SetLayerCompositionType) {
1939 const auto& [layerStatus, layer] =
1940 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
1941 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00001942
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001943 auto& writer = getWriter(getPrimaryDisplayId());
1944 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::CLIENT);
ramindanidcfe3a82021-11-29 17:00:31 +00001945 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08001946 ASSERT_TRUE(mReader.takeErrors().empty());
1947
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001948 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::DEVICE);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001949 execute();
1950 ASSERT_TRUE(mReader.takeErrors().empty());
1951
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001952 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::SOLID_COLOR);
Ady Abraham3192f3d2021-12-03 16:08:56 -08001953 execute();
1954 ASSERT_TRUE(mReader.takeErrors().empty());
1955
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001956 writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::CURSOR);
ramindani431aad42022-02-01 21:44:29 +00001957 execute();
1958}
1959
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001960TEST_P(GraphicsComposerAidlCommandTest, DisplayDecoration) {
1961 for (VtsDisplay& display : mDisplays) {
1962 const auto [layerStatus, layer] =
1963 mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount);
1964 EXPECT_TRUE(layerStatus.isOk());
1965
1966 const auto [error, support] =
1967 mComposerClient->getDisplayDecorationSupport(display.getDisplayId());
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001968
Leon Scroggins III91590872022-02-23 09:51:21 -05001969 const auto format = (error.isOk() && support) ? support->format
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001970 : aidl::android::hardware::graphics::common::PixelFormat::RGBA_8888;
1971 const auto decorBuffer = allocate(static_cast<::android::PixelFormat>(format));
1972 ASSERT_NE(nullptr, decorBuffer);
1973 if (::android::OK != decorBuffer->initCheck()) {
1974 if (support) {
1975 FAIL() << "Device advertised display decoration support with format "
1976 << aidl::android::hardware::graphics::common::toString(format)
1977 << " but failed to allocate it!";
1978 } else {
1979 FAIL() << "Device advertised NO display decoration support, but it should "
1980 << "still be able to allocate "
1981 << aidl::android::hardware::graphics::common::toString(format);
1982 }
1983 }
1984
Midas Chien7d55d422022-06-07 02:32:28 +08001985 configureLayer(display, layer, Composition::DISPLAY_DECORATION, display.getFrameRect(),
1986 display.getCrop());
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04001987 auto& writer = getWriter(display.getDisplayId());
1988 writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, decorBuffer->handle,
1989 /*acquireFence*/ -1);
1990 writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp);
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001991 execute();
1992 if (support) {
1993 ASSERT_TRUE(mReader.takeErrors().empty());
1994 } else {
1995 const auto errors = mReader.takeErrors();
1996 ASSERT_EQ(1, errors.size());
Leon Scroggins III6455e792022-02-24 12:18:58 -05001997 EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, errors[0].errorCode);
Leon Scroggins IIIde057582022-01-13 12:26:00 -05001998 }
1999 }
2000}
2001
ramindani431aad42022-02-01 21:44:29 +00002002TEST_P(GraphicsComposerAidlCommandTest, SetLayerDataspace) {
2003 const auto& [layerStatus, layer] =
2004 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2005 EXPECT_TRUE(layerStatus.isOk());
2006
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002007 auto& writer = getWriter(getPrimaryDisplayId());
2008 writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
ramindani431aad42022-02-01 21:44:29 +00002009 execute();
2010}
2011
2012TEST_P(GraphicsComposerAidlCommandTest, SetLayerDisplayFrame) {
2013 const auto& [layerStatus, layer] =
2014 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2015 EXPECT_TRUE(layerStatus.isOk());
2016
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002017 auto& writer = getWriter(getPrimaryDisplayId());
2018 writer.setLayerDisplayFrame(getPrimaryDisplayId(), layer, Rect{0, 0, 1, 1});
ramindani431aad42022-02-01 21:44:29 +00002019 execute();
2020}
2021
2022TEST_P(GraphicsComposerAidlCommandTest, SetLayerPlaneAlpha) {
2023 const auto& [layerStatus, layer] =
2024 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2025 EXPECT_TRUE(layerStatus.isOk());
2026
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002027 auto& writer = getWriter(getPrimaryDisplayId());
2028 writer.setLayerPlaneAlpha(getPrimaryDisplayId(), layer, /*alpha*/ 0.0f);
ramindani431aad42022-02-01 21:44:29 +00002029 execute();
2030 ASSERT_TRUE(mReader.takeErrors().empty());
2031
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002032 writer.setLayerPlaneAlpha(getPrimaryDisplayId(), layer, /*alpha*/ 1.0f);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002033 execute();
2034 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002035}
2036
ramindani431aad42022-02-01 21:44:29 +00002037TEST_P(GraphicsComposerAidlCommandTest, SetLayerSidebandStream) {
Jason Macnak325e8232022-01-24 14:48:55 -08002038 if (!hasCapability(Capability::SIDEBAND_STREAM)) {
ramindanidcfe3a82021-11-29 17:00:31 +00002039 GTEST_SUCCEED() << "no sideband stream support";
2040 return;
2041 }
2042
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002043 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
ramindani3d18f922021-12-13 20:24:47 +00002044 const auto handle = buffer->handle;
ramindanidcfe3a82021-11-29 17:00:31 +00002045 ASSERT_NE(nullptr, handle);
2046
ramindani431aad42022-02-01 21:44:29 +00002047 const auto& [layerStatus, layer] =
2048 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2049 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002050
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002051 auto& writer = getWriter(getPrimaryDisplayId());
2052 writer.setLayerSidebandStream(getPrimaryDisplayId(), layer, handle);
ramindanidcfe3a82021-11-29 17:00:31 +00002053 execute();
2054}
2055
ramindani431aad42022-02-01 21:44:29 +00002056TEST_P(GraphicsComposerAidlCommandTest, SetLayerSourceCrop) {
2057 const auto& [layerStatus, layer] =
2058 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2059 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002060
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002061 auto& writer = getWriter(getPrimaryDisplayId());
2062 writer.setLayerSourceCrop(getPrimaryDisplayId(), layer, FRect{0.0f, 0.0f, 1.0f, 1.0f});
ramindanidcfe3a82021-11-29 17:00:31 +00002063 execute();
2064}
2065
ramindani431aad42022-02-01 21:44:29 +00002066TEST_P(GraphicsComposerAidlCommandTest, SetLayerTransform) {
2067 const auto& [layerStatus, layer] =
2068 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2069 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002070
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002071 auto& writer = getWriter(getPrimaryDisplayId());
2072 writer.setLayerTransform(getPrimaryDisplayId(), layer, static_cast<Transform>(0));
ramindanidcfe3a82021-11-29 17:00:31 +00002073 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002074 ASSERT_TRUE(mReader.takeErrors().empty());
2075
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002076 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::FLIP_H);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002077 execute();
2078 ASSERT_TRUE(mReader.takeErrors().empty());
2079
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002080 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::FLIP_V);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002081 execute();
2082 ASSERT_TRUE(mReader.takeErrors().empty());
2083
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002084 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_90);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002085 execute();
2086 ASSERT_TRUE(mReader.takeErrors().empty());
2087
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002088 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_180);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002089 execute();
2090 ASSERT_TRUE(mReader.takeErrors().empty());
2091
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002092 writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_270);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002093 execute();
2094 ASSERT_TRUE(mReader.takeErrors().empty());
2095
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002096 writer.setLayerTransform(getPrimaryDisplayId(), layer,
2097 static_cast<Transform>(static_cast<int>(Transform::FLIP_H) |
2098 static_cast<int>(Transform::ROT_90)));
Ady Abraham3192f3d2021-12-03 16:08:56 -08002099 execute();
2100 ASSERT_TRUE(mReader.takeErrors().empty());
2101
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002102 writer.setLayerTransform(getPrimaryDisplayId(), layer,
2103 static_cast<Transform>(static_cast<int>(Transform::FLIP_V) |
2104 static_cast<int>(Transform::ROT_90)));
Ady Abraham3192f3d2021-12-03 16:08:56 -08002105 execute();
2106 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002107}
2108
ramindani431aad42022-02-01 21:44:29 +00002109TEST_P(GraphicsComposerAidlCommandTest, SetLayerVisibleRegion) {
2110 const auto& [layerStatus, layer] =
2111 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2112 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002113
2114 Rect empty{0, 0, 0, 0};
2115 Rect unit{0, 0, 1, 1};
2116
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002117 auto& writer = getWriter(getPrimaryDisplayId());
2118 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
ramindanidcfe3a82021-11-29 17:00:31 +00002119 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002120 ASSERT_TRUE(mReader.takeErrors().empty());
2121
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002122 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
Ady Abraham3192f3d2021-12-03 16:08:56 -08002123 execute();
2124 ASSERT_TRUE(mReader.takeErrors().empty());
2125
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002126 writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>());
Ady Abraham3192f3d2021-12-03 16:08:56 -08002127 execute();
2128 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002129}
2130
ramindani431aad42022-02-01 21:44:29 +00002131TEST_P(GraphicsComposerAidlCommandTest, SetLayerZOrder) {
2132 const auto& [layerStatus, layer] =
2133 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2134 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002135
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002136 auto& writer = getWriter(getPrimaryDisplayId());
2137 writer.setLayerZOrder(getPrimaryDisplayId(), layer, /*z*/ 10);
ramindanidcfe3a82021-11-29 17:00:31 +00002138 execute();
Ady Abraham3192f3d2021-12-03 16:08:56 -08002139 ASSERT_TRUE(mReader.takeErrors().empty());
2140
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002141 writer.setLayerZOrder(getPrimaryDisplayId(), layer, /*z*/ 0);
Ady Abraham3192f3d2021-12-03 16:08:56 -08002142 execute();
2143 ASSERT_TRUE(mReader.takeErrors().empty());
ramindanidcfe3a82021-11-29 17:00:31 +00002144}
2145
ramindani431aad42022-02-01 21:44:29 +00002146TEST_P(GraphicsComposerAidlCommandTest, SetLayerPerFrameMetadata) {
2147 const auto& [layerStatus, layer] =
2148 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2149 EXPECT_TRUE(layerStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002150
ramindanidcfe3a82021-11-29 17:00:31 +00002151 /**
2152 * DISPLAY_P3 is a color space that uses the DCI_P3 primaries,
2153 * the D65 white point and the SRGB transfer functions.
2154 * Rendering Intent: Colorimetric
2155 * Primaries:
2156 * x y
2157 * green 0.265 0.690
2158 * blue 0.150 0.060
2159 * red 0.680 0.320
2160 * white (D65) 0.3127 0.3290
2161 */
2162
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002163 auto& writer = getWriter(getPrimaryDisplayId());
ramindanidcfe3a82021-11-29 17:00:31 +00002164 std::vector<PerFrameMetadata> aidlMetadata;
2165 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X, 0.680f});
2166 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y, 0.320f});
2167 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X, 0.265f});
2168 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y, 0.690f});
2169 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X, 0.150f});
2170 aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y, 0.060f});
2171 aidlMetadata.push_back({PerFrameMetadataKey::WHITE_POINT_X, 0.3127f});
2172 aidlMetadata.push_back({PerFrameMetadataKey::WHITE_POINT_Y, 0.3290f});
2173 aidlMetadata.push_back({PerFrameMetadataKey::MAX_LUMINANCE, 100.0f});
2174 aidlMetadata.push_back({PerFrameMetadataKey::MIN_LUMINANCE, 0.1f});
2175 aidlMetadata.push_back({PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL, 78.0});
2176 aidlMetadata.push_back({PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL, 62.0});
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002177 writer.setLayerPerFrameMetadata(getPrimaryDisplayId(), layer, aidlMetadata);
ramindanidcfe3a82021-11-29 17:00:31 +00002178 execute();
2179
Ady Abraham3192f3d2021-12-03 16:08:56 -08002180 const auto errors = mReader.takeErrors();
2181 if (errors.size() == 1 && errors[0].errorCode == EX_UNSUPPORTED_OPERATION) {
ramindanidcfe3a82021-11-29 17:00:31 +00002182 GTEST_SUCCEED() << "SetLayerPerFrameMetadata is not supported";
ramindani431aad42022-02-01 21:44:29 +00002183 EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002184 return;
2185 }
2186
ramindani431aad42022-02-01 21:44:29 +00002187 EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002188}
2189
Alec Mourib1f16722022-02-07 13:03:44 -08002190TEST_P(GraphicsComposerAidlCommandTest, setLayerBrightness) {
ramindani431aad42022-02-01 21:44:29 +00002191 const auto& [layerStatus, layer] =
2192 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
Alec Mouri95e490b2022-01-06 13:46:58 -08002193
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002194 auto& writer = getWriter(getPrimaryDisplayId());
2195 writer.setLayerBrightness(getPrimaryDisplayId(), layer, 0.2f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002196 execute();
2197 ASSERT_TRUE(mReader.takeErrors().empty());
2198
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002199 writer.setLayerBrightness(getPrimaryDisplayId(), layer, 1.f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002200 execute();
2201 ASSERT_TRUE(mReader.takeErrors().empty());
2202
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002203 writer.setLayerBrightness(getPrimaryDisplayId(), layer, 0.f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002204 execute();
2205 ASSERT_TRUE(mReader.takeErrors().empty());
2206
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002207 writer.setLayerBrightness(getPrimaryDisplayId(), layer, -1.f);
Alec Mouri95e490b2022-01-06 13:46:58 -08002208 execute();
Alec Mourib1f16722022-02-07 13:03:44 -08002209 {
2210 const auto errors = mReader.takeErrors();
2211 ASSERT_EQ(1, errors.size());
2212 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
2213 }
2214
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002215 writer.setLayerBrightness(getPrimaryDisplayId(), layer, std::nanf(""));
Alec Mourib1f16722022-02-07 13:03:44 -08002216 execute();
2217 {
2218 const auto errors = mReader.takeErrors();
2219 ASSERT_EQ(1, errors.size());
2220 EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
2221 }
Alec Mouri95e490b2022-01-06 13:46:58 -08002222}
2223
ramindani431aad42022-02-01 21:44:29 +00002224TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints) {
ramindanidcfe3a82021-11-29 17:00:31 +00002225 Test_setActiveConfigWithConstraints({.delayForChange = 0, .refreshMiss = false});
2226}
2227
ramindani431aad42022-02-01 21:44:29 +00002228TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_Delayed) {
ramindanidcfe3a82021-11-29 17:00:31 +00002229 Test_setActiveConfigWithConstraints({.delayForChange = 300'000'000, // 300ms
2230 .refreshMiss = false});
2231}
2232
ramindani431aad42022-02-01 21:44:29 +00002233TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_MissRefresh) {
ramindanidcfe3a82021-11-29 17:00:31 +00002234 Test_setActiveConfigWithConstraints({.delayForChange = 0, .refreshMiss = true});
2235}
2236
ramindani431aad42022-02-01 21:44:29 +00002237TEST_P(GraphicsComposerAidlCommandTest, GetDisplayVsyncPeriod) {
ramindanidcfe3a82021-11-29 17:00:31 +00002238 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +00002239 const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
2240 EXPECT_TRUE(status.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002241
ramindani431aad42022-02-01 21:44:29 +00002242 for (int32_t config : configs) {
2243 int32_t expectedVsyncPeriodNanos = display.getDisplayConfig(config).vsyncPeriod;
2244
ramindanidcfe3a82021-11-29 17:00:31 +00002245 VsyncPeriodChangeConstraints constraints;
2246
2247 constraints.desiredTimeNanos = systemTime();
2248 constraints.seamlessRequired = false;
ramindani431aad42022-02-01 21:44:29 +00002249
2250 const auto& [timelineStatus, timeline] =
2251 mComposerClient->setActiveConfigWithConstraints(&display, config, constraints);
2252 EXPECT_TRUE(timelineStatus.isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002253
2254 if (timeline.refreshRequired) {
2255 sendRefreshFrame(display, &timeline);
2256 }
ramindani431aad42022-02-01 21:44:29 +00002257 waitForVsyncPeriodChange(display.getDisplayId(), timeline, constraints.desiredTimeNanos,
2258 /*odPeriodNanos*/ 0, expectedVsyncPeriodNanos);
ramindanidcfe3a82021-11-29 17:00:31 +00002259
2260 int32_t vsyncPeriodNanos;
2261 int retryCount = 100;
2262 do {
2263 std::this_thread::sleep_for(10ms);
ramindani431aad42022-02-01 21:44:29 +00002264 const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanosValue] =
2265 mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
2266
2267 EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
2268 vsyncPeriodNanos = vsyncPeriodNanosValue;
ramindanidcfe3a82021-11-29 17:00:31 +00002269 --retryCount;
2270 } while (vsyncPeriodNanos != expectedVsyncPeriodNanos && retryCount > 0);
2271
2272 EXPECT_EQ(vsyncPeriodNanos, expectedVsyncPeriodNanos);
2273
2274 // Make sure that the vsync period stays the same if the active config is not
2275 // changed.
2276 auto timeout = 1ms;
2277 for (int i = 0; i < 10; i++) {
2278 std::this_thread::sleep_for(timeout);
2279 timeout *= 2;
2280 vsyncPeriodNanos = 0;
ramindani431aad42022-02-01 21:44:29 +00002281 const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanosValue] =
2282 mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
2283
2284 EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
2285 vsyncPeriodNanos = vsyncPeriodNanosValue;
ramindanidcfe3a82021-11-29 17:00:31 +00002286 EXPECT_EQ(vsyncPeriodNanos, expectedVsyncPeriodNanos);
2287 }
2288 }
2289 }
2290}
2291
ramindani431aad42022-02-01 21:44:29 +00002292TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_SeamlessNotAllowed) {
ramindanidcfe3a82021-11-29 17:00:31 +00002293 VsyncPeriodChangeConstraints constraints;
ramindanidcfe3a82021-11-29 17:00:31 +00002294 constraints.seamlessRequired = true;
2295 constraints.desiredTimeNanos = systemTime();
2296
2297 for (VtsDisplay& display : mDisplays) {
ramindani431aad42022-02-01 21:44:29 +00002298 forEachTwoConfigs(display.getDisplayId(), [&](int32_t config1, int32_t config2) {
2299 int32_t configGroup1 = display.getDisplayConfig(config1).configGroup;
2300 int32_t configGroup2 = display.getDisplayConfig(config2).configGroup;
ramindanidcfe3a82021-11-29 17:00:31 +00002301 if (configGroup1 != configGroup2) {
ramindani431aad42022-02-01 21:44:29 +00002302 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
ramindanidcfe3a82021-11-29 17:00:31 +00002303 sendRefreshFrame(display, nullptr);
ramindani431aad42022-02-01 21:44:29 +00002304 const auto& [status, _] = mComposerClient->setActiveConfigWithConstraints(
2305 &display, config2, constraints);
2306 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00002307 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(
2308 status, IComposerClient::EX_SEAMLESS_NOT_ALLOWED));
ramindanidcfe3a82021-11-29 17:00:31 +00002309 }
2310 });
2311 }
2312}
2313
ramindani431aad42022-02-01 21:44:29 +00002314TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_NoTimestamp) {
2315 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ std::nullopt));
Ady Abraham72c5b502021-12-10 17:23:39 -08002316}
2317
ramindani431aad42022-02-01 21:44:29 +00002318TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_0) {
2319 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ 0));
Ady Abraham72c5b502021-12-10 17:23:39 -08002320}
2321
ramindani431aad42022-02-01 21:44:29 +00002322TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_5) {
2323 ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ 5));
Ady Abraham72c5b502021-12-10 17:23:39 -08002324}
2325
ramindani431aad42022-02-01 21:44:29 +00002326TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Unsupported) {
2327 const bool hasDisplayIdleTimerSupport =
2328 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002329 if (!hasDisplayIdleTimerSupport) {
ramindani431aad42022-02-01 21:44:29 +00002330 const auto& status =
2331 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0);
2332 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00002333 EXPECT_NO_FATAL_FAILURE(
2334 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
Midas Chiena0b56bd2022-01-13 23:27:33 +08002335 }
2336}
2337
ramindani431aad42022-02-01 21:44:29 +00002338TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_BadParameter) {
2339 const bool hasDisplayIdleTimerSupport =
2340 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002341 if (!hasDisplayIdleTimerSupport) {
2342 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2343 return;
2344 }
2345
ramindani431aad42022-02-01 21:44:29 +00002346 const auto& status =
2347 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ -1);
2348 EXPECT_FALSE(status.isOk());
ramindanid5751092022-04-22 22:30:20 +00002349 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
Midas Chiena0b56bd2022-01-13 23:27:33 +08002350}
2351
ramindani431aad42022-02-01 21:44:29 +00002352TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Disable) {
2353 const bool hasDisplayIdleTimerSupport =
2354 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002355 if (!hasDisplayIdleTimerSupport) {
2356 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2357 return;
2358 }
2359
ramindani431aad42022-02-01 21:44:29 +00002360 EXPECT_TRUE(mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002361 std::this_thread::sleep_for(1s);
ramindani431aad42022-02-01 21:44:29 +00002362 EXPECT_EQ(0, mComposerClient->getVsyncIdleCount());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002363}
2364
ramindani431aad42022-02-01 21:44:29 +00002365TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Timeout_2) {
2366 const bool hasDisplayIdleTimerSupport =
2367 hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002368 if (!hasDisplayIdleTimerSupport) {
2369 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2370 return;
2371 }
2372
ramindani431aad42022-02-01 21:44:29 +00002373 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
2374 EXPECT_TRUE(mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002375
Leon Scroggins IIIde057582022-01-13 12:26:00 -05002376 const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002377 ASSERT_NE(nullptr, buffer->handle);
2378
2379 const auto layer = createOnScreenLayer();
Leon Scroggins IIIc3d695d2022-09-16 15:34:59 -04002380 auto& writer = getWriter(getPrimaryDisplayId());
2381 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer->handle,
2382 /*acquireFence*/ -1);
ramindani431aad42022-02-01 21:44:29 +00002383 int32_t vsyncIdleCount = mComposerClient->getVsyncIdleCount();
Midas Chiena0b56bd2022-01-13 23:27:33 +08002384 auto earlyVsyncIdleTime = systemTime() + std::chrono::nanoseconds(2s).count();
ramindani431aad42022-02-01 21:44:29 +00002385 EXPECT_TRUE(
2386 mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 2000).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002387
2388 const sp<::android::Fence> presentFence =
ramindani431aad42022-02-01 21:44:29 +00002389 presentAndGetFence(ComposerClientWriter::kNoTimestamp);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002390 presentFence->waitForever(LOG_TAG);
2391
2392 std::this_thread::sleep_for(3s);
ramindani431aad42022-02-01 21:44:29 +00002393 if (vsyncIdleCount < mComposerClient->getVsyncIdleCount()) {
2394 EXPECT_GE(mComposerClient->getVsyncIdleTime(), earlyVsyncIdleTime);
Midas Chiena0b56bd2022-01-13 23:27:33 +08002395 }
2396
ramindani431aad42022-02-01 21:44:29 +00002397 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
Midas Chiena0b56bd2022-01-13 23:27:33 +08002398}
2399
ramindani12423f52023-06-14 20:04:51 -07002400class GraphicsComposerAidlCommandV2Test : public GraphicsComposerAidlCommandTest {
2401 protected:
2402 void SetUp() override {
2403 GraphicsComposerAidlTest::SetUp();
2404 if (getInterfaceVersion() <= 1) {
2405 GTEST_SKIP() << "Device interface version is expected to be >= 2";
2406 }
ramindani17c71102023-03-20 10:51:14 -07002407 }
ramindani12423f52023-06-14 20:04:51 -07002408};
2409/**
2410 * Test Capability::SKIP_VALIDATE
2411 *
2412 * Capability::SKIP_VALIDATE has been deprecated and should not be enabled.
2413 */
2414TEST_P(GraphicsComposerAidlCommandV2Test, SkipValidateDeprecatedTest) {
2415 ASSERT_FALSE(hasCapability(Capability::SKIP_VALIDATE))
2416 << "Found Capability::SKIP_VALIDATE capability.";
2417}
2418
2419TEST_P(GraphicsComposerAidlCommandV2Test, SetLayerBufferSlotsToClear) {
2420 // Older HAL versions use a backwards compatible way of clearing buffer slots
2421 // HAL at version 1 or lower does not have LayerCommand::bufferSlotsToClear
2422 const auto& [layerStatus, layer] =
2423 mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
2424 EXPECT_TRUE(layerStatus.isOk());
2425 auto& writer = getWriter(getPrimaryDisplayId());
2426
2427 // setup 3 buffers in the buffer cache, with the last buffer being active
2428 // then emulate the Android platform code that clears all 3 buffer slots
2429
2430 const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2431 ASSERT_NE(nullptr, buffer1);
2432 const auto handle1 = buffer1->handle;
2433 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle1, /*acquireFence*/ -1);
2434 execute();
2435 ASSERT_TRUE(mReader.takeErrors().empty());
2436
2437 const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2438 ASSERT_NE(nullptr, buffer2);
2439 const auto handle2 = buffer2->handle;
2440 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 1, handle2, /*acquireFence*/ -1);
2441 execute();
2442 ASSERT_TRUE(mReader.takeErrors().empty());
2443
2444 const auto buffer3 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
2445 ASSERT_NE(nullptr, buffer3);
2446 const auto handle3 = buffer3->handle;
2447 writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 2, handle3, /*acquireFence*/ -1);
2448 execute();
2449 ASSERT_TRUE(mReader.takeErrors().empty());
2450
2451 // Ensure we can clear all 3 buffer slots, even the active buffer - it is assumed the
2452 // current active buffer's slot will be cleared, but still remain the active buffer and no
2453 // errors will occur.
2454 writer.setLayerBufferSlotsToClear(getPrimaryDisplayId(), layer, {0, 1, 2});
2455 execute();
2456 ASSERT_TRUE(mReader.takeErrors().empty());
2457}
2458
2459TEST_P(GraphicsComposerAidlCommandV2Test, SetRefreshRateChangedCallbackDebug_Unsupported) {
ramindani9dd8c482023-02-21 18:07:56 -08002460 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2461 auto status = mComposerClient->setRefreshRateChangedCallbackDebugEnabled(
2462 getPrimaryDisplayId(), /*enabled*/ true);
2463 EXPECT_FALSE(status.isOk());
2464 EXPECT_NO_FATAL_FAILURE(
2465 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
2466
2467 status = mComposerClient->setRefreshRateChangedCallbackDebugEnabled(getPrimaryDisplayId(),
2468 /*enabled*/ false);
2469 EXPECT_FALSE(status.isOk());
2470 EXPECT_NO_FATAL_FAILURE(
2471 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
2472 }
2473}
2474
ramindani12423f52023-06-14 20:04:51 -07002475TEST_P(GraphicsComposerAidlCommandV2Test, SetRefreshRateChangedCallbackDebug_Enabled) {
ramindani9dd8c482023-02-21 18:07:56 -08002476 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2477 GTEST_SUCCEED() << "Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG is not supported";
2478 return;
2479 }
2480
2481 const auto displayId = getPrimaryDisplayId();
2482 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2483 // Enable the callback
2484 ASSERT_TRUE(mComposerClient
2485 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2486 /*enabled*/ true)
2487 .isOk());
2488 std::this_thread::sleep_for(100ms);
2489
ramindani91518892023-03-03 16:55:09 +00002490 const auto displayFilter = [displayId](auto refreshRateChangedDebugData) {
2491 return displayId == refreshRateChangedDebugData.display;
2492 };
ramindani9dd8c482023-02-21 18:07:56 -08002493
2494 // Check that we immediately got a callback
ramindani91518892023-03-03 16:55:09 +00002495 EXPECT_TRUE(checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter));
ramindani9dd8c482023-02-21 18:07:56 -08002496
2497 ASSERT_TRUE(mComposerClient
2498 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2499 /*enabled*/ false)
2500 .isOk());
2501}
2502
ramindani12423f52023-06-14 20:04:51 -07002503TEST_P(GraphicsComposerAidlCommandV2Test,
ramindani9dd8c482023-02-21 18:07:56 -08002504 SetRefreshRateChangedCallbackDebugEnabled_noCallbackWhenIdle) {
2505 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2506 GTEST_SUCCEED() << "Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG is not supported";
2507 return;
2508 }
2509
2510 auto display = getEditablePrimaryDisplay();
2511 const auto displayId = display.getDisplayId();
2512
2513 if (!hasDisplayCapability(displayId, DisplayCapability::DISPLAY_IDLE_TIMER)) {
2514 GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
2515 return;
2516 }
2517
2518 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2519 EXPECT_TRUE(mComposerClient->setPeakRefreshRateConfig(&display).isOk());
2520
2521 ASSERT_TRUE(mComposerClient->setIdleTimerEnabled(displayId, /*timeoutMs*/ 500).isOk());
2522 // Enable the callback
2523 ASSERT_TRUE(mComposerClient
2524 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2525 /*enabled*/ true)
2526 .isOk());
2527
ramindani91518892023-03-03 16:55:09 +00002528 const auto displayFilter = [displayId](auto refreshRateChangedDebugData) {
2529 return displayId == refreshRateChangedDebugData.display;
2530 };
ramindani9dd8c482023-02-21 18:07:56 -08002531
2532 int retryCount = 3;
2533 do {
2534 // Wait for 1s so that we enter the idle state
2535 std::this_thread::sleep_for(1s);
ramindani91518892023-03-03 16:55:09 +00002536 if (!checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter)) {
ramindani9dd8c482023-02-21 18:07:56 -08002537 // DID NOT receive a callback, we are in the idle state.
2538 break;
2539 }
2540 } while (--retryCount > 0);
2541
2542 if (retryCount == 0) {
2543 GTEST_SUCCEED() << "Unable to enter the idle mode";
2544 return;
2545 }
2546
2547 // Send the REFRESH_RATE_INDICATOR update
2548 ASSERT_NO_FATAL_FAILURE(
2549 sendBufferUpdate(createOnScreenLayer(Composition::REFRESH_RATE_INDICATOR)));
2550 std::this_thread::sleep_for(1s);
ramindani91518892023-03-03 16:55:09 +00002551 EXPECT_FALSE(checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter))
ramindani9dd8c482023-02-21 18:07:56 -08002552 << "A callback should not be received for REFRESH_RATE_INDICATOR";
2553
2554 EXPECT_TRUE(mComposerClient
2555 ->setRefreshRateChangedCallbackDebugEnabled(displayId,
2556 /*enabled*/ false)
2557 .isOk());
2558}
2559
ramindani12423f52023-06-14 20:04:51 -07002560TEST_P(GraphicsComposerAidlCommandV2Test,
ramindani9dd8c482023-02-21 18:07:56 -08002561 SetRefreshRateChangedCallbackDebugEnabled_SetActiveConfigWithConstraints) {
2562 if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
2563 GTEST_SUCCEED() << "Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG is not supported";
2564 return;
2565 }
2566
2567 VsyncPeriodChangeConstraints constraints;
2568 constraints.seamlessRequired = false;
2569 constraints.desiredTimeNanos = systemTime();
2570
2571 for (VtsDisplay& display : mDisplays) {
2572 const auto displayId = display.getDisplayId();
2573 EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
2574
2575 // Enable the callback
2576 ASSERT_TRUE(mComposerClient
2577 ->setRefreshRateChangedCallbackDebugEnabled(displayId, /*enabled*/ true)
2578 .isOk());
2579
2580 forEachTwoConfigs(displayId, [&](int32_t config1, int32_t config2) {
2581 const int32_t vsyncPeriod1 = display.getDisplayConfig(config1).vsyncPeriod;
2582 const int32_t vsyncPeriod2 = display.getDisplayConfig(config2).vsyncPeriod;
2583
2584 if (vsyncPeriod1 == vsyncPeriod2) {
2585 return; // continue
2586 }
2587
2588 EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
2589 sendRefreshFrame(display, nullptr);
2590
2591 const auto& [status, timeline] =
2592 mComposerClient->setActiveConfigWithConstraints(&display, config2, constraints);
2593 EXPECT_TRUE(status.isOk());
2594
2595 if (timeline.refreshRequired) {
2596 sendRefreshFrame(display, &timeline);
2597 }
2598
ramindani91518892023-03-03 16:55:09 +00002599 const auto callbackFilter = [displayId,
2600 vsyncPeriod2](auto refreshRateChangedDebugData) {
2601 constexpr int kVsyncThreshold = 1000;
2602 return displayId == refreshRateChangedDebugData.display &&
2603 std::abs(vsyncPeriod2 - refreshRateChangedDebugData.vsyncPeriodNanos) <=
2604 kVsyncThreshold;
2605 };
ramindani9dd8c482023-02-21 18:07:56 -08002606
2607 int retryCount = 3;
2608 do {
2609 std::this_thread::sleep_for(100ms);
ramindani91518892023-03-03 16:55:09 +00002610 if (checkIfCallbackRefreshRateChangedDebugEnabledReceived(callbackFilter)) {
ramindani9dd8c482023-02-21 18:07:56 -08002611 GTEST_SUCCEED() << "Received a callback successfully";
2612 break;
2613 }
2614 } while (--retryCount > 0);
2615
2616 if (retryCount == 0) {
2617 GTEST_FAIL() << "failed to get a callback for the display " << displayId
2618 << " with config " << config2;
2619 }
2620 });
2621
2622 EXPECT_TRUE(
2623 mComposerClient
2624 ->setRefreshRateChangedCallbackDebugEnabled(displayId, /*enabled*/ false)
2625 .isOk());
2626 }
2627}
2628
ramindanidcfe3a82021-11-29 17:00:31 +00002629GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlCommandTest);
2630INSTANTIATE_TEST_SUITE_P(
2631 PerInstance, GraphicsComposerAidlCommandTest,
2632 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
2633 ::android::PrintInstanceNameToString);
ramindanid32ae8e2021-10-01 18:48:39 +00002634GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlTest);
2635INSTANTIATE_TEST_SUITE_P(
2636 PerInstance, GraphicsComposerAidlTest,
2637 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
2638 ::android::PrintInstanceNameToString);
ramindani12423f52023-06-14 20:04:51 -07002639GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlV2Test);
2640INSTANTIATE_TEST_SUITE_P(
2641 PerInstance, GraphicsComposerAidlV2Test,
2642 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
2643 ::android::PrintInstanceNameToString);
2644GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlCommandV2Test);
2645INSTANTIATE_TEST_SUITE_P(
2646 PerInstance, GraphicsComposerAidlCommandV2Test,
2647 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
2648 ::android::PrintInstanceNameToString);
2649
ramindanid32ae8e2021-10-01 18:48:39 +00002650} // namespace aidl::android::hardware::graphics::composer3::vts
2651
2652int main(int argc, char** argv) {
2653 ::testing::InitGoogleTest(&argc, argv);
2654
2655 using namespace std::chrono_literals;
2656 if (!android::base::WaitForProperty("init.svc.surfaceflinger", "stopped", 10s)) {
2657 ALOGE("Failed to stop init.svc.surfaceflinger");
2658 return -1;
2659 }
ramindanibeea10e2021-12-07 21:02:49 +00002660
2661 android::ProcessState::self()->setThreadPoolMaxThreadCount(4);
2662
2663 // The binder threadpool we start will inherit sched policy and priority
2664 // of (this) creating thread. We want the binder thread pool to have
2665 // SCHED_FIFO policy and priority 1 (lowest RT priority)
2666 // Once the pool is created we reset this thread's priority back to
2667 // original.
2668 // This thread policy is based on what we do in the SurfaceFlinger while starting
2669 // the thread pool and we need to replicate that for the VTS tests.
2670 int newPriority = 0;
2671 int origPolicy = sched_getscheduler(0);
2672 struct sched_param origSchedParam;
2673
2674 int errorInPriorityModification = sched_getparam(0, &origSchedParam);
2675 if (errorInPriorityModification == 0) {
2676 int policy = SCHED_FIFO;
2677 newPriority = sched_get_priority_min(policy);
2678
2679 struct sched_param param;
2680 param.sched_priority = newPriority;
2681
2682 errorInPriorityModification = sched_setscheduler(0, policy, &param);
2683 }
2684
2685 // start the thread pool
2686 android::ProcessState::self()->startThreadPool();
2687
2688 // Reset current thread's policy and priority
2689 if (errorInPriorityModification == 0) {
2690 errorInPriorityModification = sched_setscheduler(0, origPolicy, &origSchedParam);
2691 } else {
2692 ALOGE("Failed to set VtsHalGraphicsComposer3_TargetTest binder threadpool priority to "
2693 "SCHED_FIFO");
2694 }
2695
ramindanid32ae8e2021-10-01 18:48:39 +00002696 return RUN_ALL_TESTS();
Leon Scroggins III45095052023-03-23 18:23:15 -04002697}