ed2bb4e8f8
Test: make vts succeed, vts kernel tests and nfc hal tests passed Change-Id: I95f10ad7a66f261c9030357edd411fe6d94150e8
300 lines
9.9 KiB
C++
300 lines
9.9 KiB
C++
/*
|
|
* Copyright (C) 2017 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include <VtsHalHidlTargetTestBase.h>
|
|
|
|
#include "VtsHalGraphicsComposerTestUtils.h"
|
|
|
|
namespace android {
|
|
namespace hardware {
|
|
namespace graphics {
|
|
namespace composer {
|
|
namespace V2_1 {
|
|
namespace tests {
|
|
|
|
Composer::Composer() { init(); }
|
|
|
|
void Composer::init() {
|
|
mComposer = ::testing::VtsHalHidlTargetTestBase::getService<IComposer>();
|
|
ASSERT_NE(nullptr, mComposer.get()) << "failed to get composer service";
|
|
|
|
std::vector<IComposer::Capability> capabilities = getCapabilities();
|
|
mCapabilities.insert(capabilities.begin(), capabilities.end());
|
|
}
|
|
|
|
sp<IComposer> Composer::getRaw() const { return mComposer; }
|
|
|
|
bool Composer::hasCapability(IComposer::Capability capability) const {
|
|
return mCapabilities.count(capability) > 0;
|
|
}
|
|
|
|
std::vector<IComposer::Capability> Composer::getCapabilities() {
|
|
std::vector<IComposer::Capability> capabilities;
|
|
mComposer->getCapabilities(
|
|
[&](const auto& tmpCapabilities) { capabilities = tmpCapabilities; });
|
|
|
|
return capabilities;
|
|
}
|
|
|
|
std::string Composer::dumpDebugInfo() {
|
|
std::string debugInfo;
|
|
mComposer->dumpDebugInfo(
|
|
[&](const auto& tmpDebugInfo) { debugInfo = tmpDebugInfo.c_str(); });
|
|
|
|
return debugInfo;
|
|
}
|
|
|
|
std::unique_ptr<ComposerClient> Composer::createClient() {
|
|
std::unique_ptr<ComposerClient> client;
|
|
mComposer->createClient([&](const auto& tmpError, const auto& tmpClient) {
|
|
ASSERT_EQ(Error::NONE, tmpError) << "failed to create client";
|
|
client = std::make_unique<ComposerClient>(tmpClient);
|
|
});
|
|
|
|
return client;
|
|
}
|
|
|
|
ComposerClient::ComposerClient(const sp<IComposerClient>& client)
|
|
: mClient(client) {}
|
|
|
|
ComposerClient::~ComposerClient() {
|
|
for (auto it : mDisplayResources) {
|
|
Display display = it.first;
|
|
DisplayResource& resource = it.second;
|
|
|
|
for (auto layer : resource.layers) {
|
|
EXPECT_EQ(Error::NONE, mClient->destroyLayer(display, layer))
|
|
<< "failed to destroy layer " << layer;
|
|
}
|
|
|
|
if (resource.isVirtual) {
|
|
EXPECT_EQ(Error::NONE, mClient->destroyVirtualDisplay(display))
|
|
<< "failed to destroy virtual display " << display;
|
|
}
|
|
}
|
|
mDisplayResources.clear();
|
|
}
|
|
|
|
sp<IComposerClient> ComposerClient::getRaw() const { return mClient; }
|
|
|
|
void ComposerClient::registerCallback(const sp<IComposerCallback>& callback) {
|
|
mClient->registerCallback(callback);
|
|
}
|
|
|
|
uint32_t ComposerClient::getMaxVirtualDisplayCount() {
|
|
return mClient->getMaxVirtualDisplayCount();
|
|
}
|
|
|
|
Display ComposerClient::createVirtualDisplay(uint32_t width, uint32_t height,
|
|
PixelFormat formatHint,
|
|
uint32_t outputBufferSlotCount,
|
|
PixelFormat* outFormat) {
|
|
Display display = 0;
|
|
mClient->createVirtualDisplay(
|
|
width, height, formatHint, outputBufferSlotCount,
|
|
[&](const auto& tmpError, const auto& tmpDisplay, const auto& tmpFormat) {
|
|
ASSERT_EQ(Error::NONE, tmpError) << "failed to create virtual display";
|
|
display = tmpDisplay;
|
|
*outFormat = tmpFormat;
|
|
|
|
ASSERT_TRUE(
|
|
mDisplayResources.insert({display, DisplayResource(true)}).second)
|
|
<< "duplicated virtual display id " << display;
|
|
});
|
|
|
|
return display;
|
|
}
|
|
|
|
void ComposerClient::destroyVirtualDisplay(Display display) {
|
|
Error error = mClient->destroyVirtualDisplay(display);
|
|
ASSERT_EQ(Error::NONE, error)
|
|
<< "failed to destroy virtual display " << display;
|
|
|
|
mDisplayResources.erase(display);
|
|
}
|
|
|
|
Layer ComposerClient::createLayer(Display display, uint32_t bufferSlotCount) {
|
|
Layer layer = 0;
|
|
mClient->createLayer(
|
|
display, bufferSlotCount,
|
|
[&](const auto& tmpError, const auto& tmpLayer) {
|
|
ASSERT_EQ(Error::NONE, tmpError) << "failed to create layer";
|
|
layer = tmpLayer;
|
|
|
|
auto resourceIt = mDisplayResources.find(display);
|
|
if (resourceIt == mDisplayResources.end()) {
|
|
resourceIt =
|
|
mDisplayResources.insert({display, DisplayResource(false)}).first;
|
|
}
|
|
|
|
ASSERT_TRUE(resourceIt->second.layers.insert(layer).second)
|
|
<< "duplicated layer id " << layer;
|
|
});
|
|
|
|
return layer;
|
|
}
|
|
|
|
void ComposerClient::destroyLayer(Display display, Layer layer) {
|
|
Error error = mClient->destroyLayer(display, layer);
|
|
ASSERT_EQ(Error::NONE, error) << "failed to destroy layer " << layer;
|
|
|
|
auto resourceIt = mDisplayResources.find(display);
|
|
ASSERT_NE(mDisplayResources.end(), resourceIt);
|
|
resourceIt->second.layers.erase(layer);
|
|
}
|
|
|
|
Config ComposerClient::getActiveConfig(Display display) {
|
|
Config config = 0;
|
|
mClient->getActiveConfig(
|
|
display, [&](const auto& tmpError, const auto& tmpConfig) {
|
|
ASSERT_EQ(Error::NONE, tmpError) << "failed to get active config";
|
|
config = tmpConfig;
|
|
});
|
|
|
|
return config;
|
|
}
|
|
|
|
bool ComposerClient::getClientTargetSupport(Display display, uint32_t width,
|
|
uint32_t height, PixelFormat format,
|
|
Dataspace dataspace) {
|
|
Error error = mClient->getClientTargetSupport(display, width, height, format,
|
|
dataspace);
|
|
return error == Error::NONE;
|
|
}
|
|
|
|
std::vector<ColorMode> ComposerClient::getColorModes(Display display) {
|
|
std::vector<ColorMode> modes;
|
|
mClient->getColorModes(
|
|
display, [&](const auto& tmpError, const auto& tmpMode) {
|
|
ASSERT_EQ(Error::NONE, tmpError) << "failed to get color mode";
|
|
modes = tmpMode;
|
|
});
|
|
|
|
return modes;
|
|
}
|
|
|
|
int32_t ComposerClient::getDisplayAttribute(
|
|
Display display, Config config, IComposerClient::Attribute attribute) {
|
|
int32_t value = 0;
|
|
mClient->getDisplayAttribute(display, config, attribute,
|
|
[&](const auto& tmpError, const auto& tmpValue) {
|
|
ASSERT_EQ(Error::NONE, tmpError)
|
|
<< "failed to get display attribute";
|
|
value = tmpValue;
|
|
});
|
|
|
|
return value;
|
|
}
|
|
|
|
std::vector<Config> ComposerClient::getDisplayConfigs(Display display) {
|
|
std::vector<Config> configs;
|
|
mClient->getDisplayConfigs(
|
|
display, [&](const auto& tmpError, const auto& tmpConfigs) {
|
|
ASSERT_EQ(Error::NONE, tmpError) << "failed to get display configs";
|
|
configs = tmpConfigs;
|
|
});
|
|
|
|
return configs;
|
|
}
|
|
|
|
std::string ComposerClient::getDisplayName(Display display) {
|
|
std::string name;
|
|
mClient->getDisplayName(
|
|
display, [&](const auto& tmpError, const auto& tmpName) {
|
|
ASSERT_EQ(Error::NONE, tmpError) << "failed to get display name";
|
|
name = tmpName.c_str();
|
|
});
|
|
|
|
return name;
|
|
}
|
|
|
|
IComposerClient::DisplayType ComposerClient::getDisplayType(Display display) {
|
|
IComposerClient::DisplayType type = IComposerClient::DisplayType::INVALID;
|
|
mClient->getDisplayType(
|
|
display, [&](const auto& tmpError, const auto& tmpType) {
|
|
ASSERT_EQ(Error::NONE, tmpError) << "failed to get display type";
|
|
type = tmpType;
|
|
});
|
|
|
|
return type;
|
|
}
|
|
|
|
bool ComposerClient::getDozeSupport(Display display) {
|
|
bool support = false;
|
|
mClient->getDozeSupport(
|
|
display, [&](const auto& tmpError, const auto& tmpSupport) {
|
|
ASSERT_EQ(Error::NONE, tmpError) << "failed to get doze support";
|
|
support = tmpSupport;
|
|
});
|
|
|
|
return support;
|
|
}
|
|
|
|
std::vector<Hdr> ComposerClient::getHdrCapabilities(
|
|
Display display, float* outMaxLuminance, float* outMaxAverageLuminance,
|
|
float* outMinLuminance) {
|
|
std::vector<Hdr> types;
|
|
mClient->getHdrCapabilities(
|
|
display,
|
|
[&](const auto& tmpError, const auto& tmpTypes,
|
|
const auto& tmpMaxLuminance, const auto& tmpMaxAverageLuminance,
|
|
const auto& tmpMinLuminance) {
|
|
ASSERT_EQ(Error::NONE, tmpError) << "failed to get HDR capabilities";
|
|
types = tmpTypes;
|
|
*outMaxLuminance = tmpMaxLuminance;
|
|
*outMaxAverageLuminance = tmpMaxAverageLuminance;
|
|
*outMinLuminance = tmpMinLuminance;
|
|
});
|
|
|
|
return types;
|
|
}
|
|
|
|
void ComposerClient::setClientTargetSlotCount(Display display,
|
|
uint32_t clientTargetSlotCount) {
|
|
Error error =
|
|
mClient->setClientTargetSlotCount(display, clientTargetSlotCount);
|
|
ASSERT_EQ(Error::NONE, error) << "failed to set client target slot count";
|
|
}
|
|
|
|
void ComposerClient::setActiveConfig(Display display, Config config) {
|
|
Error error = mClient->setActiveConfig(display, config);
|
|
ASSERT_EQ(Error::NONE, error) << "failed to set active config";
|
|
}
|
|
|
|
void ComposerClient::setColorMode(Display display, ColorMode mode) {
|
|
Error error = mClient->setColorMode(display, mode);
|
|
ASSERT_EQ(Error::NONE, error) << "failed to set color mode";
|
|
}
|
|
|
|
void ComposerClient::setPowerMode(Display display,
|
|
IComposerClient::PowerMode mode) {
|
|
Error error = mClient->setPowerMode(display, mode);
|
|
ASSERT_EQ(Error::NONE, error) << "failed to set power mode";
|
|
}
|
|
|
|
void ComposerClient::setVsyncEnabled(Display display, bool enabled) {
|
|
IComposerClient::Vsync vsync = (enabled) ? IComposerClient::Vsync::ENABLE
|
|
: IComposerClient::Vsync::DISABLE;
|
|
Error error = mClient->setVsyncEnabled(display, vsync);
|
|
ASSERT_EQ(Error::NONE, error) << "failed to set vsync mode";
|
|
}
|
|
|
|
} // namespace tests
|
|
} // namespace V2_1
|
|
} // namespace composer
|
|
} // namespace graphics
|
|
} // namespace hardware
|
|
} // namespace android
|