1 /*
2 * Copyright (C) 2017 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 */
16
17 #include <VtsHalHidlTargetTestBase.h>
18
19 #include "VtsHalGraphicsComposerTestUtils.h"
20
21 namespace android {
22 namespace hardware {
23 namespace graphics {
24 namespace composer {
25 namespace V2_1 {
26 namespace tests {
27
Composer()28 Composer::Composer() { init(); }
29
init()30 void Composer::init() {
31 mComposer = ::testing::VtsHalHidlTargetTestBase::getService<IComposer>();
32 ASSERT_NE(nullptr, mComposer.get()) << "failed to get composer service";
33
34 std::vector<IComposer::Capability> capabilities = getCapabilities();
35 mCapabilities.insert(capabilities.begin(), capabilities.end());
36 }
37
getRaw() const38 sp<IComposer> Composer::getRaw() const { return mComposer; }
39
hasCapability(IComposer::Capability capability) const40 bool Composer::hasCapability(IComposer::Capability capability) const {
41 return mCapabilities.count(capability) > 0;
42 }
43
getCapabilities()44 std::vector<IComposer::Capability> Composer::getCapabilities() {
45 std::vector<IComposer::Capability> capabilities;
46 mComposer->getCapabilities(
47 [&](const auto& tmpCapabilities) { capabilities = tmpCapabilities; });
48
49 return capabilities;
50 }
51
dumpDebugInfo()52 std::string Composer::dumpDebugInfo() {
53 std::string debugInfo;
54 mComposer->dumpDebugInfo(
55 [&](const auto& tmpDebugInfo) { debugInfo = tmpDebugInfo.c_str(); });
56
57 return debugInfo;
58 }
59
createClient()60 std::unique_ptr<ComposerClient> Composer::createClient() {
61 std::unique_ptr<ComposerClient> client;
62 mComposer->createClient([&](const auto& tmpError, const auto& tmpClient) {
63 ASSERT_EQ(Error::NONE, tmpError) << "failed to create client";
64 client = std::make_unique<ComposerClient>(tmpClient);
65 });
66
67 return client;
68 }
69
ComposerClient(const sp<IComposerClient> & client)70 ComposerClient::ComposerClient(const sp<IComposerClient>& client)
71 : mClient(client) {}
72
~ComposerClient()73 ComposerClient::~ComposerClient() {
74 for (auto it : mDisplayResources) {
75 Display display = it.first;
76 DisplayResource& resource = it.second;
77
78 for (auto layer : resource.layers) {
79 EXPECT_EQ(Error::NONE, mClient->destroyLayer(display, layer))
80 << "failed to destroy layer " << layer;
81 }
82
83 if (resource.isVirtual) {
84 EXPECT_EQ(Error::NONE, mClient->destroyVirtualDisplay(display))
85 << "failed to destroy virtual display " << display;
86 }
87 }
88 mDisplayResources.clear();
89 }
90
getRaw() const91 sp<IComposerClient> ComposerClient::getRaw() const { return mClient; }
92
registerCallback(const sp<IComposerCallback> & callback)93 void ComposerClient::registerCallback(const sp<IComposerCallback>& callback) {
94 mClient->registerCallback(callback);
95 }
96
getMaxVirtualDisplayCount()97 uint32_t ComposerClient::getMaxVirtualDisplayCount() {
98 return mClient->getMaxVirtualDisplayCount();
99 }
100
createVirtualDisplay(uint32_t width,uint32_t height,PixelFormat formatHint,uint32_t outputBufferSlotCount,PixelFormat * outFormat)101 Display ComposerClient::createVirtualDisplay(uint32_t width, uint32_t height,
102 PixelFormat formatHint,
103 uint32_t outputBufferSlotCount,
104 PixelFormat* outFormat) {
105 Display display = 0;
106 mClient->createVirtualDisplay(
107 width, height, formatHint, outputBufferSlotCount,
108 [&](const auto& tmpError, const auto& tmpDisplay, const auto& tmpFormat) {
109 ASSERT_EQ(Error::NONE, tmpError) << "failed to create virtual display";
110 display = tmpDisplay;
111 *outFormat = tmpFormat;
112
113 ASSERT_TRUE(
114 mDisplayResources.insert({display, DisplayResource(true)}).second)
115 << "duplicated virtual display id " << display;
116 });
117
118 return display;
119 }
120
destroyVirtualDisplay(Display display)121 void ComposerClient::destroyVirtualDisplay(Display display) {
122 Error error = mClient->destroyVirtualDisplay(display);
123 ASSERT_EQ(Error::NONE, error)
124 << "failed to destroy virtual display " << display;
125
126 mDisplayResources.erase(display);
127 }
128
createLayer(Display display,uint32_t bufferSlotCount)129 Layer ComposerClient::createLayer(Display display, uint32_t bufferSlotCount) {
130 Layer layer = 0;
131 mClient->createLayer(
132 display, bufferSlotCount,
133 [&](const auto& tmpError, const auto& tmpLayer) {
134 ASSERT_EQ(Error::NONE, tmpError) << "failed to create layer";
135 layer = tmpLayer;
136
137 auto resourceIt = mDisplayResources.find(display);
138 if (resourceIt == mDisplayResources.end()) {
139 resourceIt =
140 mDisplayResources.insert({display, DisplayResource(false)}).first;
141 }
142
143 ASSERT_TRUE(resourceIt->second.layers.insert(layer).second)
144 << "duplicated layer id " << layer;
145 });
146
147 return layer;
148 }
149
destroyLayer(Display display,Layer layer)150 void ComposerClient::destroyLayer(Display display, Layer layer) {
151 Error error = mClient->destroyLayer(display, layer);
152 ASSERT_EQ(Error::NONE, error) << "failed to destroy layer " << layer;
153
154 auto resourceIt = mDisplayResources.find(display);
155 ASSERT_NE(mDisplayResources.end(), resourceIt);
156 resourceIt->second.layers.erase(layer);
157 }
158
getActiveConfig(Display display)159 Config ComposerClient::getActiveConfig(Display display) {
160 Config config = 0;
161 mClient->getActiveConfig(
162 display, [&](const auto& tmpError, const auto& tmpConfig) {
163 ASSERT_EQ(Error::NONE, tmpError) << "failed to get active config";
164 config = tmpConfig;
165 });
166
167 return config;
168 }
169
getClientTargetSupport(Display display,uint32_t width,uint32_t height,PixelFormat format,Dataspace dataspace)170 bool ComposerClient::getClientTargetSupport(Display display, uint32_t width,
171 uint32_t height, PixelFormat format,
172 Dataspace dataspace) {
173 Error error = mClient->getClientTargetSupport(display, width, height, format,
174 dataspace);
175 return error == Error::NONE;
176 }
177
getColorModes(Display display)178 std::vector<ColorMode> ComposerClient::getColorModes(Display display) {
179 std::vector<ColorMode> modes;
180 mClient->getColorModes(
181 display, [&](const auto& tmpError, const auto& tmpMode) {
182 ASSERT_EQ(Error::NONE, tmpError) << "failed to get color mode";
183 modes = tmpMode;
184 });
185
186 return modes;
187 }
188
getDisplayAttribute(Display display,Config config,IComposerClient::Attribute attribute)189 int32_t ComposerClient::getDisplayAttribute(
190 Display display, Config config, IComposerClient::Attribute attribute) {
191 int32_t value = 0;
192 mClient->getDisplayAttribute(display, config, attribute,
193 [&](const auto& tmpError, const auto& tmpValue) {
194 ASSERT_EQ(Error::NONE, tmpError)
195 << "failed to get display attribute";
196 value = tmpValue;
197 });
198
199 return value;
200 }
201
getDisplayConfigs(Display display)202 std::vector<Config> ComposerClient::getDisplayConfigs(Display display) {
203 std::vector<Config> configs;
204 mClient->getDisplayConfigs(
205 display, [&](const auto& tmpError, const auto& tmpConfigs) {
206 ASSERT_EQ(Error::NONE, tmpError) << "failed to get display configs";
207 configs = tmpConfigs;
208 });
209
210 return configs;
211 }
212
getDisplayName(Display display)213 std::string ComposerClient::getDisplayName(Display display) {
214 std::string name;
215 mClient->getDisplayName(
216 display, [&](const auto& tmpError, const auto& tmpName) {
217 ASSERT_EQ(Error::NONE, tmpError) << "failed to get display name";
218 name = tmpName.c_str();
219 });
220
221 return name;
222 }
223
getDisplayType(Display display)224 IComposerClient::DisplayType ComposerClient::getDisplayType(Display display) {
225 IComposerClient::DisplayType type = IComposerClient::DisplayType::INVALID;
226 mClient->getDisplayType(
227 display, [&](const auto& tmpError, const auto& tmpType) {
228 ASSERT_EQ(Error::NONE, tmpError) << "failed to get display type";
229 type = tmpType;
230 });
231
232 return type;
233 }
234
getDozeSupport(Display display)235 bool ComposerClient::getDozeSupport(Display display) {
236 bool support = false;
237 mClient->getDozeSupport(
238 display, [&](const auto& tmpError, const auto& tmpSupport) {
239 ASSERT_EQ(Error::NONE, tmpError) << "failed to get doze support";
240 support = tmpSupport;
241 });
242
243 return support;
244 }
245
getHdrCapabilities(Display display,float * outMaxLuminance,float * outMaxAverageLuminance,float * outMinLuminance)246 std::vector<Hdr> ComposerClient::getHdrCapabilities(
247 Display display, float* outMaxLuminance, float* outMaxAverageLuminance,
248 float* outMinLuminance) {
249 std::vector<Hdr> types;
250 mClient->getHdrCapabilities(
251 display,
252 [&](const auto& tmpError, const auto& tmpTypes,
253 const auto& tmpMaxLuminance, const auto& tmpMaxAverageLuminance,
254 const auto& tmpMinLuminance) {
255 ASSERT_EQ(Error::NONE, tmpError) << "failed to get HDR capabilities";
256 types = tmpTypes;
257 *outMaxLuminance = tmpMaxLuminance;
258 *outMaxAverageLuminance = tmpMaxAverageLuminance;
259 *outMinLuminance = tmpMinLuminance;
260 });
261
262 return types;
263 }
264
setClientTargetSlotCount(Display display,uint32_t clientTargetSlotCount)265 void ComposerClient::setClientTargetSlotCount(Display display,
266 uint32_t clientTargetSlotCount) {
267 Error error =
268 mClient->setClientTargetSlotCount(display, clientTargetSlotCount);
269 ASSERT_EQ(Error::NONE, error) << "failed to set client target slot count";
270 }
271
setActiveConfig(Display display,Config config)272 void ComposerClient::setActiveConfig(Display display, Config config) {
273 Error error = mClient->setActiveConfig(display, config);
274 ASSERT_EQ(Error::NONE, error) << "failed to set active config";
275 }
276
setColorMode(Display display,ColorMode mode)277 void ComposerClient::setColorMode(Display display, ColorMode mode) {
278 Error error = mClient->setColorMode(display, mode);
279 ASSERT_EQ(Error::NONE, error) << "failed to set color mode";
280 }
281
setPowerMode(Display display,IComposerClient::PowerMode mode)282 void ComposerClient::setPowerMode(Display display,
283 IComposerClient::PowerMode mode) {
284 Error error = mClient->setPowerMode(display, mode);
285 ASSERT_EQ(Error::NONE, error) << "failed to set power mode";
286 }
287
setVsyncEnabled(Display display,bool enabled)288 void ComposerClient::setVsyncEnabled(Display display, bool enabled) {
289 IComposerClient::Vsync vsync = (enabled) ? IComposerClient::Vsync::ENABLE
290 : IComposerClient::Vsync::DISABLE;
291 Error error = mClient->setVsyncEnabled(display, vsync);
292 ASSERT_EQ(Error::NONE, error) << "failed to set vsync mode";
293 }
294
295 } // namespace tests
296 } // namespace V2_1
297 } // namespace composer
298 } // namespace graphics
299 } // namespace hardware
300 } // namespace android
301