VTS: Create libhwc_aidl_test out of HWC VTS
[Why]
VTS tests targeting HWC depend on wrapper and helpers that are very
well done and beneficial to other tests outside of VTS that are also
targeting HWC.
Instead of rewriting all these helpers in a new effort to test HWC using
Cuttlefish, a common library for HWC AIDL tests would be beneficial.
[How]
Take out all the helpers out of the VTS directory and create a new
libhwc_aidl_test directory that other tests can reference.
Also, remove any mention of VTS out of them because they're not longer
directly related to VTS.
Bug: b/384710755 , b/383783834
Test: atest VtsHalGraphicsComposer3_TargetTest
Flag: TEST_ONLY
Change-Id: Icaff0c50186d7b016e1d1822e084bf12001fe5be
diff --git a/graphics/composer/aidl/libhwc_aidl_test/Android.bp b/graphics/composer/aidl/libhwc_aidl_test/Android.bp
new file mode 100644
index 0000000..1955fcf
--- /dev/null
+++ b/graphics/composer/aidl/libhwc_aidl_test/Android.bp
@@ -0,0 +1,71 @@
+/**
+ * Copyright (c) 2025, 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.
+ */
+
+package {
+ default_team: "trendy_team_android_core_graphics_stack",
+ // See: http://go/android-license-faq
+ // A large-scale-change added 'default_applicable_licenses' to import
+ // all of the 'license_kinds' from "hardware_interfaces_license"
+ // to get the below license kinds:
+ // SPDX-license-identifier-Apache-2.0
+}
+
+cc_library_static {
+ name: "libhwc_aidl_test",
+ export_include_dirs: ["include"],
+ defaults: [
+ "use_libaidlvintf_gtest_helper_static",
+ "librenderengine_deps",
+ "android.hardware.graphics.common-ndk_static",
+ "android.hardware.graphics.composer3-ndk_static",
+ ],
+ srcs: [
+ "ComposerClientWrapper.cpp",
+ "GraphicsComposerCallback.cpp",
+ "Readback.cpp",
+ "RenderEngine.cpp",
+ ],
+ shared_libs: [
+ "libEGL",
+ "libGLESv2",
+ "libbinder_ndk",
+ "libbinder",
+ "libfmq",
+ "libbase",
+ "libsync",
+ "libui",
+ "libgui",
+ ],
+ header_libs: [
+ "android.hardware.graphics.composer3-command-buffer",
+ ],
+ static_libs: [
+ "android.hardware.graphics.common@1.2",
+ "android.hardware.common-V2-ndk",
+ "android.hardware.common.fmq-V1-ndk",
+ "libaidlcommonsupport",
+ "libarect",
+ "libbase",
+ "libfmq",
+ "libgtest",
+ "librenderengine",
+ "libsync",
+ "libsurfaceflinger_common",
+ ],
+ cflags: [
+ "-Wconversion",
+ ],
+}
diff --git a/graphics/composer/aidl/vts/VtsComposerClient.cpp b/graphics/composer/aidl/libhwc_aidl_test/ComposerClientWrapper.cpp
similarity index 65%
rename from graphics/composer/aidl/vts/VtsComposerClient.cpp
rename to graphics/composer/aidl/libhwc_aidl_test/ComposerClientWrapper.cpp
index f09482c..8af1fc3 100644
--- a/graphics/composer/aidl/vts/VtsComposerClient.cpp
+++ b/graphics/composer/aidl/libhwc_aidl_test/ComposerClientWrapper.cpp
@@ -14,19 +14,19 @@
* limitations under the License.
*/
-#include "VtsComposerClient.h"
+#include "ComposerClientWrapper.h"
#include <aidlcommonsupport/NativeHandle.h>
#include <android-base/logging.h>
#include <log/log_main.h>
#undef LOG_TAG
-#define LOG_TAG "VtsComposerClient"
+#define LOG_TAG "ComposerClientWrapper"
using namespace std::chrono_literals;
-namespace aidl::android::hardware::graphics::composer3::vts {
+namespace aidl::android::hardware::graphics::composer3::libhwc_aidl_test {
-VtsComposerClient::VtsComposerClient(const std::string& name) {
+ComposerClientWrapper::ComposerClientWrapper(const std::string& name) {
SpAIBinder binder(AServiceManager_waitForService(name.c_str()));
ALOGE_IF(binder == nullptr, "Could not initialize the service binder");
if (binder != nullptr) {
@@ -43,7 +43,7 @@
}
}
-ScopedAStatus VtsComposerClient::createClient() {
+ScopedAStatus ComposerClientWrapper::createClient() {
if (mComposer == nullptr) {
ALOGE("IComposer not initialized");
return ScopedAStatus::fromServiceSpecificError(IComposerClient::INVALID_CONFIGURATION);
@@ -62,11 +62,11 @@
return mComposerClient->registerCallback(mComposerCallback);
}
-bool VtsComposerClient::tearDown(ComposerClientWriter* writer) {
+bool ComposerClientWrapper::tearDown(ComposerClientWriter* writer) {
return verifyComposerCallbackParams() && destroyAllLayers(writer);
}
-std::pair<ScopedAStatus, int32_t> VtsComposerClient::getInterfaceVersion() const {
+std::pair<ScopedAStatus, int32_t> ComposerClientWrapper::getInterfaceVersion() const {
int32_t version = 1;
if (!mComposerClient) {
return {ScopedAStatus{nullptr}, version};
@@ -75,7 +75,7 @@
return {std::move(status), version};
}
-std::pair<ScopedAStatus, VirtualDisplay> VtsComposerClient::createVirtualDisplay(
+std::pair<ScopedAStatus, VirtualDisplay> ComposerClientWrapper::createVirtualDisplay(
int32_t width, int32_t height, PixelFormat pixelFormat, int32_t bufferSlotCount) {
VirtualDisplay outVirtualDisplay;
auto status = mComposerClient->createVirtualDisplay(width, height, pixelFormat, bufferSlotCount,
@@ -87,7 +87,7 @@
outVirtualDisplay};
}
-ScopedAStatus VtsComposerClient::destroyVirtualDisplay(int64_t display) {
+ScopedAStatus ComposerClientWrapper::destroyVirtualDisplay(int64_t display) {
auto status = mComposerClient->destroyVirtualDisplay(display);
if (!status.isOk()) {
return status;
@@ -96,9 +96,9 @@
return status;
}
-std::pair<ScopedAStatus, int64_t> VtsComposerClient::createLayer(int64_t display,
- int32_t bufferSlotCount,
- ComposerClientWriter* writer) {
+std::pair<ScopedAStatus, int64_t> ComposerClientWrapper::createLayer(int64_t display,
+ int32_t bufferSlotCount,
+ ComposerClientWriter* writer) {
if (mSupportsBatchedCreateLayer) {
int64_t layer = mNextLayerHandle++;
writer->setLayerLifecycleBatchCommandType(display, layer,
@@ -116,8 +116,8 @@
return {addLayerToDisplayResources(display, outLayer), outLayer};
}
-ScopedAStatus VtsComposerClient::destroyLayer(int64_t display, int64_t layer,
- ComposerClientWriter* writer) {
+ScopedAStatus ComposerClientWrapper::destroyLayer(int64_t display, int64_t layer,
+ ComposerClientWriter* writer) {
if (mSupportsBatchedCreateLayer) {
writer->setLayerLifecycleBatchCommandType(display, layer,
LayerLifecycleBatchCommandType::DESTROY);
@@ -132,27 +132,27 @@
return ScopedAStatus::ok();
}
-std::pair<ScopedAStatus, int32_t> VtsComposerClient::getActiveConfig(int64_t display) {
+std::pair<ScopedAStatus, int32_t> ComposerClientWrapper::getActiveConfig(int64_t display) {
int32_t outConfig;
return {mComposerClient->getActiveConfig(display, &outConfig), outConfig};
}
-ScopedAStatus VtsComposerClient::setActiveConfig(VtsDisplay* vtsDisplay, int32_t config) {
- auto status = mComposerClient->setActiveConfig(vtsDisplay->getDisplayId(), config);
+ScopedAStatus ComposerClientWrapper::setActiveConfig(DisplayWrapper* display, int32_t config) {
+ auto status = mComposerClient->setActiveConfig(display->getDisplayId(), config);
if (!status.isOk()) {
return status;
}
- return updateDisplayProperties(vtsDisplay, config);
+ return updateDisplayProperties(display, config);
}
-ScopedAStatus VtsComposerClient::setPeakRefreshRateConfig(VtsDisplay* vtsDisplay) {
- const auto displayId = vtsDisplay->getDisplayId();
+ScopedAStatus ComposerClientWrapper::setPeakRefreshRateConfig(DisplayWrapper* display) {
+ const auto displayId = display->getDisplayId();
auto [activeStatus, activeConfig] = getActiveConfig(displayId);
EXPECT_TRUE(activeStatus.isOk());
- auto peakDisplayConfig = vtsDisplay->getDisplayConfig(activeConfig);
+ auto peakDisplayConfig = display->getDisplayConfig(activeConfig);
auto peakConfig = activeConfig;
- const auto displayConfigs = vtsDisplay->getDisplayConfigs();
+ const auto displayConfigs = display->getDisplayConfigs();
for (const auto [config, displayConfig] : displayConfigs) {
if (displayConfig.configGroup == peakDisplayConfig.configGroup &&
displayConfig.vsyncPeriod < peakDisplayConfig.vsyncPeriod) {
@@ -160,10 +160,10 @@
peakConfig = config;
}
}
- return setActiveConfig(vtsDisplay, peakConfig);
+ return setActiveConfig(display, peakConfig);
}
-std::pair<ScopedAStatus, int32_t> VtsComposerClient::getDisplayAttribute(
+std::pair<ScopedAStatus, int32_t> ComposerClientWrapper::getDisplayAttribute(
int64_t display, int32_t config, DisplayAttribute displayAttribute) {
int32_t outDisplayAttribute;
return {mComposerClient->getDisplayAttribute(display, config, displayAttribute,
@@ -171,58 +171,59 @@
outDisplayAttribute};
}
-ScopedAStatus VtsComposerClient::setPowerMode(int64_t display, PowerMode powerMode) {
+ScopedAStatus ComposerClientWrapper::setPowerMode(int64_t display, PowerMode powerMode) {
return mComposerClient->setPowerMode(display, powerMode);
}
-ScopedAStatus VtsComposerClient::setVsync(int64_t display, bool enable) {
+ScopedAStatus ComposerClientWrapper::setVsync(int64_t display, bool enable) {
return mComposerClient->setVsyncEnabled(display, enable);
}
-void VtsComposerClient::setVsyncAllowed(bool isAllowed) {
+void ComposerClientWrapper::setVsyncAllowed(bool isAllowed) {
mComposerCallback->setVsyncAllowed(isAllowed);
}
-std::pair<ScopedAStatus, std::vector<float>> VtsComposerClient::getDataspaceSaturationMatrix(
+std::pair<ScopedAStatus, std::vector<float>> ComposerClientWrapper::getDataspaceSaturationMatrix(
Dataspace dataspace) {
std::vector<float> outMatrix;
return {mComposerClient->getDataspaceSaturationMatrix(dataspace, &outMatrix), outMatrix};
}
-std::pair<ScopedAStatus, std::vector<CommandResultPayload>> VtsComposerClient::executeCommands(
+std::pair<ScopedAStatus, std::vector<CommandResultPayload>> ComposerClientWrapper::executeCommands(
const std::vector<DisplayCommand>& commands) {
std::vector<CommandResultPayload> outResultPayload;
return {mComposerClient->executeCommands(commands, &outResultPayload),
std::move(outResultPayload)};
}
-std::optional<VsyncPeriodChangeTimeline> VtsComposerClient::takeLastVsyncPeriodChangeTimeline() {
+std::optional<VsyncPeriodChangeTimeline>
+ComposerClientWrapper::takeLastVsyncPeriodChangeTimeline() {
return mComposerCallback->takeLastVsyncPeriodChangeTimeline();
}
-ScopedAStatus VtsComposerClient::setContentType(int64_t display, ContentType contentType) {
+ScopedAStatus ComposerClientWrapper::setContentType(int64_t display, ContentType contentType) {
return mComposerClient->setContentType(display, contentType);
}
std::pair<ScopedAStatus, VsyncPeriodChangeTimeline>
-VtsComposerClient::setActiveConfigWithConstraints(VtsDisplay* vtsDisplay, int32_t config,
- const VsyncPeriodChangeConstraints& constraints) {
+ComposerClientWrapper::setActiveConfigWithConstraints(
+ DisplayWrapper* display, int32_t config, const VsyncPeriodChangeConstraints& constraints) {
VsyncPeriodChangeTimeline outTimeline;
- auto status = mComposerClient->setActiveConfigWithConstraints(
- vtsDisplay->getDisplayId(), config, constraints, &outTimeline);
+ auto status = mComposerClient->setActiveConfigWithConstraints(display->getDisplayId(), config,
+ constraints, &outTimeline);
if (!status.isOk()) {
return {std::move(status), outTimeline};
}
- return {updateDisplayProperties(vtsDisplay, config), outTimeline};
+ return {updateDisplayProperties(display, config), outTimeline};
}
-std::pair<ScopedAStatus, std::vector<DisplayCapability>> VtsComposerClient::getDisplayCapabilities(
- int64_t display) {
+std::pair<ScopedAStatus, std::vector<DisplayCapability>>
+ComposerClientWrapper::getDisplayCapabilities(int64_t display) {
std::vector<DisplayCapability> outCapabilities;
return {mComposerClient->getDisplayCapabilities(display, &outCapabilities), outCapabilities};
}
-ScopedAStatus VtsComposerClient::dumpDebugInfo() {
+ScopedAStatus ComposerClientWrapper::dumpDebugInfo() {
int pipefds[2];
if (pipe(pipefds) < 0) {
return ScopedAStatus::fromServiceSpecificError(IComposer::EX_NO_RESOURCES);
@@ -234,76 +235,79 @@
return ScopedAStatus::fromStatus(status);
}
-std::pair<ScopedAStatus, DisplayIdentification> VtsComposerClient::getDisplayIdentificationData(
+std::pair<ScopedAStatus, DisplayIdentification> ComposerClientWrapper::getDisplayIdentificationData(
int64_t display) {
DisplayIdentification outDisplayIdentification;
return {mComposerClient->getDisplayIdentificationData(display, &outDisplayIdentification),
outDisplayIdentification};
}
-std::pair<ScopedAStatus, HdrCapabilities> VtsComposerClient::getHdrCapabilities(int64_t display) {
+std::pair<ScopedAStatus, HdrCapabilities> ComposerClientWrapper::getHdrCapabilities(
+ int64_t display) {
HdrCapabilities outHdrCapabilities;
return {mComposerClient->getHdrCapabilities(display, &outHdrCapabilities), outHdrCapabilities};
}
std::pair<ScopedAStatus, std::vector<PerFrameMetadataKey>>
-VtsComposerClient::getPerFrameMetadataKeys(int64_t display) {
+ComposerClientWrapper::getPerFrameMetadataKeys(int64_t display) {
std::vector<PerFrameMetadataKey> outPerFrameMetadataKeys;
return {mComposerClient->getPerFrameMetadataKeys(display, &outPerFrameMetadataKeys),
outPerFrameMetadataKeys};
}
-std::pair<ScopedAStatus, ReadbackBufferAttributes> VtsComposerClient::getReadbackBufferAttributes(
- int64_t display) {
+std::pair<ScopedAStatus, ReadbackBufferAttributes>
+ComposerClientWrapper::getReadbackBufferAttributes(int64_t display) {
ReadbackBufferAttributes outReadbackBufferAttributes;
return {mComposerClient->getReadbackBufferAttributes(display, &outReadbackBufferAttributes),
outReadbackBufferAttributes};
}
-ScopedAStatus VtsComposerClient::setReadbackBuffer(int64_t display, const native_handle_t* buffer,
- const ScopedFileDescriptor& releaseFence) {
+ScopedAStatus ComposerClientWrapper::setReadbackBuffer(int64_t display,
+ const native_handle_t* buffer,
+ const ScopedFileDescriptor& releaseFence) {
return mComposerClient->setReadbackBuffer(display, ::android::dupToAidl(buffer), releaseFence);
}
-std::pair<ScopedAStatus, ScopedFileDescriptor> VtsComposerClient::getReadbackBufferFence(
+std::pair<ScopedAStatus, ScopedFileDescriptor> ComposerClientWrapper::getReadbackBufferFence(
int64_t display) {
ScopedFileDescriptor outReleaseFence;
return {mComposerClient->getReadbackBufferFence(display, &outReleaseFence),
std::move(outReleaseFence)};
}
-std::pair<ScopedAStatus, std::vector<ColorMode>> VtsComposerClient::getColorModes(int64_t display) {
+std::pair<ScopedAStatus, std::vector<ColorMode>> ComposerClientWrapper::getColorModes(
+ int64_t display) {
std::vector<ColorMode> outColorModes;
return {mComposerClient->getColorModes(display, &outColorModes), outColorModes};
}
-std::pair<ScopedAStatus, std::vector<RenderIntent>> VtsComposerClient::getRenderIntents(
+std::pair<ScopedAStatus, std::vector<RenderIntent>> ComposerClientWrapper::getRenderIntents(
int64_t display, ColorMode colorMode) {
std::vector<RenderIntent> outRenderIntents;
return {mComposerClient->getRenderIntents(display, colorMode, &outRenderIntents),
outRenderIntents};
}
-ScopedAStatus VtsComposerClient::setColorMode(int64_t display, ColorMode colorMode,
- RenderIntent renderIntent) {
+ScopedAStatus ComposerClientWrapper::setColorMode(int64_t display, ColorMode colorMode,
+ RenderIntent renderIntent) {
return mComposerClient->setColorMode(display, colorMode, renderIntent);
}
std::pair<ScopedAStatus, DisplayContentSamplingAttributes>
-VtsComposerClient::getDisplayedContentSamplingAttributes(int64_t display) {
+ComposerClientWrapper::getDisplayedContentSamplingAttributes(int64_t display) {
DisplayContentSamplingAttributes outAttributes;
return {mComposerClient->getDisplayedContentSamplingAttributes(display, &outAttributes),
outAttributes};
}
-ScopedAStatus VtsComposerClient::setDisplayedContentSamplingEnabled(
+ScopedAStatus ComposerClientWrapper::setDisplayedContentSamplingEnabled(
int64_t display, bool isEnabled, FormatColorComponent formatColorComponent,
int64_t maxFrames) {
return mComposerClient->setDisplayedContentSamplingEnabled(display, isEnabled,
formatColorComponent, maxFrames);
}
-std::pair<ScopedAStatus, DisplayContentSample> VtsComposerClient::getDisplayedContentSample(
+std::pair<ScopedAStatus, DisplayContentSample> ComposerClientWrapper::getDisplayedContentSample(
int64_t display, int64_t maxFrames, int64_t timestamp) {
DisplayContentSample outDisplayContentSample;
return {mComposerClient->getDisplayedContentSample(display, maxFrames, timestamp,
@@ -311,14 +315,14 @@
outDisplayContentSample};
}
-std::pair<ScopedAStatus, DisplayConnectionType> VtsComposerClient::getDisplayConnectionType(
+std::pair<ScopedAStatus, DisplayConnectionType> ComposerClientWrapper::getDisplayConnectionType(
int64_t display) {
DisplayConnectionType outDisplayConnectionType;
return {mComposerClient->getDisplayConnectionType(display, &outDisplayConnectionType),
outDisplayConnectionType};
}
-std::pair<ScopedAStatus, std::vector<int32_t>> VtsComposerClient::getDisplayConfigs(
+std::pair<ScopedAStatus, std::vector<int32_t>> ComposerClientWrapper::getDisplayConfigs(
int64_t display) {
std::vector<int32_t> outConfigs;
if (!getDisplayConfigurationSupported()) {
@@ -336,132 +340,131 @@
}
std::pair<ScopedAStatus, std::vector<DisplayConfiguration>>
-VtsComposerClient::getDisplayConfigurations(int64_t display) {
+ComposerClientWrapper::getDisplayConfigurations(int64_t display) {
std::vector<DisplayConfiguration> outConfigs;
return {mComposerClient->getDisplayConfigurations(display, kMaxFrameIntervalNs, &outConfigs),
outConfigs};
}
-ScopedAStatus VtsComposerClient::notifyExpectedPresent(int64_t display,
- ClockMonotonicTimestamp expectedPresentTime,
- int frameIntervalNs) {
+ScopedAStatus ComposerClientWrapper::notifyExpectedPresent(
+ int64_t display, ClockMonotonicTimestamp expectedPresentTime, int frameIntervalNs) {
return mComposerClient->notifyExpectedPresent(display, expectedPresentTime, frameIntervalNs);
}
-std::pair<ScopedAStatus, int32_t> VtsComposerClient::getDisplayVsyncPeriod(int64_t display) {
+std::pair<ScopedAStatus, int32_t> ComposerClientWrapper::getDisplayVsyncPeriod(int64_t display) {
int32_t outVsyncPeriodNanos;
return {mComposerClient->getDisplayVsyncPeriod(display, &outVsyncPeriodNanos),
outVsyncPeriodNanos};
}
-ScopedAStatus VtsComposerClient::setAutoLowLatencyMode(int64_t display, bool isEnabled) {
+ScopedAStatus ComposerClientWrapper::setAutoLowLatencyMode(int64_t display, bool isEnabled) {
return mComposerClient->setAutoLowLatencyMode(display, isEnabled);
}
-std::pair<ScopedAStatus, std::vector<ContentType>> VtsComposerClient::getSupportedContentTypes(
+std::pair<ScopedAStatus, std::vector<ContentType>> ComposerClientWrapper::getSupportedContentTypes(
int64_t display) {
std::vector<ContentType> outContentTypes;
return {mComposerClient->getSupportedContentTypes(display, &outContentTypes), outContentTypes};
}
std::pair<ScopedAStatus, std::optional<DisplayDecorationSupport>>
-VtsComposerClient::getDisplayDecorationSupport(int64_t display) {
+ComposerClientWrapper::getDisplayDecorationSupport(int64_t display) {
std::optional<DisplayDecorationSupport> outSupport;
return {mComposerClient->getDisplayDecorationSupport(display, &outSupport), outSupport};
}
-std::pair<ScopedAStatus, int32_t> VtsComposerClient::getMaxVirtualDisplayCount() {
+std::pair<ScopedAStatus, int32_t> ComposerClientWrapper::getMaxVirtualDisplayCount() {
int32_t outMaxVirtualDisplayCount;
return {mComposerClient->getMaxVirtualDisplayCount(&outMaxVirtualDisplayCount),
outMaxVirtualDisplayCount};
}
-std::pair<ScopedAStatus, std::string> VtsComposerClient::getDisplayName(int64_t display) {
+std::pair<ScopedAStatus, std::string> ComposerClientWrapper::getDisplayName(int64_t display) {
std::string outDisplayName;
return {mComposerClient->getDisplayName(display, &outDisplayName), outDisplayName};
}
-ScopedAStatus VtsComposerClient::setClientTargetSlotCount(int64_t display,
- int32_t bufferSlotCount) {
+ScopedAStatus ComposerClientWrapper::setClientTargetSlotCount(int64_t display,
+ int32_t bufferSlotCount) {
return mComposerClient->setClientTargetSlotCount(display, bufferSlotCount);
}
-std::pair<ScopedAStatus, std::vector<Capability>> VtsComposerClient::getCapabilities() {
+std::pair<ScopedAStatus, std::vector<Capability>> ComposerClientWrapper::getCapabilities() {
std::vector<Capability> outCapabilities;
return {mComposer->getCapabilities(&outCapabilities), outCapabilities};
}
-ScopedAStatus VtsComposerClient::setBootDisplayConfig(int64_t display, int32_t config) {
+ScopedAStatus ComposerClientWrapper::setBootDisplayConfig(int64_t display, int32_t config) {
return mComposerClient->setBootDisplayConfig(display, config);
}
-ScopedAStatus VtsComposerClient::clearBootDisplayConfig(int64_t display) {
+ScopedAStatus ComposerClientWrapper::clearBootDisplayConfig(int64_t display) {
return mComposerClient->clearBootDisplayConfig(display);
}
-std::pair<ScopedAStatus, int32_t> VtsComposerClient::getPreferredBootDisplayConfig(
+std::pair<ScopedAStatus, int32_t> ComposerClientWrapper::getPreferredBootDisplayConfig(
int64_t display) {
int32_t outConfig;
return {mComposerClient->getPreferredBootDisplayConfig(display, &outConfig), outConfig};
}
std::pair<ScopedAStatus, std::vector<common::HdrConversionCapability>>
-VtsComposerClient::getHdrConversionCapabilities() {
+ComposerClientWrapper::getHdrConversionCapabilities() {
std::vector<common::HdrConversionCapability> hdrConversionCapability;
return {mComposerClient->getHdrConversionCapabilities(&hdrConversionCapability),
hdrConversionCapability};
}
-std::pair<ScopedAStatus, common::Hdr> VtsComposerClient::setHdrConversionStrategy(
+std::pair<ScopedAStatus, common::Hdr> ComposerClientWrapper::setHdrConversionStrategy(
const common::HdrConversionStrategy& conversionStrategy) {
common::Hdr preferredHdrOutputType;
return {mComposerClient->setHdrConversionStrategy(conversionStrategy, &preferredHdrOutputType),
preferredHdrOutputType};
}
-std::pair<ScopedAStatus, common::Transform> VtsComposerClient::getDisplayPhysicalOrientation(
+std::pair<ScopedAStatus, common::Transform> ComposerClientWrapper::getDisplayPhysicalOrientation(
int64_t display) {
common::Transform outDisplayOrientation;
return {mComposerClient->getDisplayPhysicalOrientation(display, &outDisplayOrientation),
outDisplayOrientation};
}
-std::pair<ScopedAStatus, composer3::OverlayProperties> VtsComposerClient::getOverlaySupport() {
+std::pair<ScopedAStatus, composer3::OverlayProperties> ComposerClientWrapper::getOverlaySupport() {
OverlayProperties properties;
return {mComposerClient->getOverlaySupport(&properties), properties};
}
-ScopedAStatus VtsComposerClient::setIdleTimerEnabled(int64_t display, int32_t timeoutMs) {
+ScopedAStatus ComposerClientWrapper::setIdleTimerEnabled(int64_t display, int32_t timeoutMs) {
return mComposerClient->setIdleTimerEnabled(display, timeoutMs);
}
-int32_t VtsComposerClient::getVsyncIdleCount() {
+int32_t ComposerClientWrapper::getVsyncIdleCount() {
return mComposerCallback->getVsyncIdleCount();
}
-int64_t VtsComposerClient::getVsyncIdleTime() {
+int64_t ComposerClientWrapper::getVsyncIdleTime() {
return mComposerCallback->getVsyncIdleTime();
}
-ndk::ScopedAStatus VtsComposerClient::setRefreshRateChangedCallbackDebugEnabled(int64_t display,
- bool enabled) {
+ndk::ScopedAStatus ComposerClientWrapper::setRefreshRateChangedCallbackDebugEnabled(int64_t display,
+ bool enabled) {
mComposerCallback->setRefreshRateChangedDebugDataEnabledCallbackAllowed(enabled);
return mComposerClient->setRefreshRateChangedCallbackDebugEnabled(display, enabled);
}
std::vector<RefreshRateChangedDebugData>
-VtsComposerClient::takeListOfRefreshRateChangedDebugData() {
+ComposerClientWrapper::takeListOfRefreshRateChangedDebugData() {
return mComposerCallback->takeListOfRefreshRateChangedDebugData();
}
-int64_t VtsComposerClient::getInvalidDisplayId() {
+int64_t ComposerClientWrapper::getInvalidDisplayId() {
// returns an invalid display id (one that has not been registered to a
// display. Currently assuming that a device will never have close to
// std::numeric_limit<uint64_t>::max() displays registered while running tests
int64_t id = std::numeric_limits<int64_t>::max();
- std::vector<int64_t> displays = mComposerCallback->getDisplays();
+ std::vector<int64_t> displayIds = mComposerCallback->getDisplays();
while (id > 0) {
- if (std::none_of(displays.begin(), displays.end(),
+ if (std::none_of(displayIds.begin(), displayIds.end(),
[id](const auto& display) { return id == display; })) {
return id;
}
@@ -475,86 +478,87 @@
return id;
}
-std::pair<ScopedAStatus, std::vector<VtsDisplay>> VtsComposerClient::getDisplays() {
+std::pair<ScopedAStatus, std::vector<DisplayWrapper>> ComposerClientWrapper::getDisplays() {
while (true) {
// Sleep for a small period of time to allow all built-in displays
// to post hotplug events
std::this_thread::sleep_for(5ms);
- std::vector<int64_t> displays = mComposerCallback->getDisplays();
- if (displays.empty()) {
+ std::vector<int64_t> displayIds = mComposerCallback->getDisplays();
+ if (displayIds.empty()) {
continue;
}
- std::vector<VtsDisplay> vtsDisplays;
- vtsDisplays.reserve(displays.size());
- for (int64_t display : displays) {
- auto vtsDisplay = VtsDisplay{display};
+ std::vector<DisplayWrapper> displays;
+ displays.reserve(displayIds.size());
+ for (int64_t displayId : displayIds) {
+ auto display = DisplayWrapper{displayId};
if (getDisplayConfigurationSupported()) {
- auto [status, configs] = getDisplayConfigurations(display);
+ auto [status, configs] = getDisplayConfigurations(displayId);
if (!status.isOk()) {
ALOGE("Unable to get the displays for test, failed to get the DisplayConfigs "
- "for display %" PRId64,
- display);
- return {std::move(status), vtsDisplays};
+ "for displayId %" PRId64,
+ displayId);
+ return {std::move(status), displays};
}
- addDisplayConfigs(&vtsDisplay, configs);
+ addDisplayConfigs(&display, configs);
} else {
- auto [status, configs] = getDisplayConfigs(display);
+ auto [status, configs] = getDisplayConfigs(displayId);
if (!status.isOk()) {
ALOGE("Unable to get the displays for test, failed to get the configs "
- "for display %" PRId64,
- display);
- return {std::move(status), vtsDisplays};
+ "for displayId %" PRId64,
+ displayId);
+ return {std::move(status), displays};
}
for (int config : configs) {
- status = addDisplayConfigLegacy(&vtsDisplay, config);
+ status = addDisplayConfigLegacy(&display, config);
if (!status.isOk()) {
ALOGE("Unable to get the displays for test, failed to add config "
- "for display %" PRId64,
- display);
- return {std::move(status), vtsDisplays};
+ "for displayId %" PRId64,
+ displayId);
+ return {std::move(status), displays};
}
}
}
- auto activeConfig = getActiveConfig(display);
+ auto activeConfig = getActiveConfig(displayId);
if (!activeConfig.first.isOk()) {
ALOGE("Unable to get the displays for test, failed to get active config "
- "for display %" PRId64,
- display);
- return {std::move(activeConfig.first), vtsDisplays};
+ "for displayId %" PRId64,
+ displayId);
+ return {std::move(activeConfig.first), displays};
}
- auto status = updateDisplayProperties(&vtsDisplay, activeConfig.second);
+ auto status = updateDisplayProperties(&display, activeConfig.second);
if (!status.isOk()) {
ALOGE("Unable to get the displays for test, "
"failed to update the properties "
- "for display %" PRId64,
- display);
- return {std::move(status), vtsDisplays};
+ "for displayId %" PRId64,
+ displayId);
+ return {std::move(status), displays};
}
- vtsDisplays.emplace_back(vtsDisplay);
- addDisplayToDisplayResources(display, /*isVirtual*/ false);
+ displays.emplace_back(display);
+ addDisplayToDisplayResources(displayId, /*isVirtual*/ false);
}
- return {ScopedAStatus::ok(), vtsDisplays};
+ return {ScopedAStatus::ok(), displays};
}
}
-void VtsComposerClient::addDisplayConfigs(VtsDisplay* vtsDisplay,
- const std::vector<DisplayConfiguration>& configs) {
+void ComposerClientWrapper::addDisplayConfigs(DisplayWrapper* display,
+ const std::vector<DisplayConfiguration>& configs) {
for (const auto& config : configs) {
- vtsDisplay->addDisplayConfig(config.configId,
- {config.vsyncPeriod, config.configGroup, config.vrrConfig});
+ display->addDisplayConfig(config.configId,
+ {config.vsyncPeriod, config.configGroup, config.vrrConfig});
}
}
-ScopedAStatus VtsComposerClient::addDisplayConfigLegacy(VtsDisplay* vtsDisplay, int32_t config) {
+ScopedAStatus ComposerClientWrapper::addDisplayConfigLegacy(DisplayWrapper* display,
+ int32_t config) {
const auto vsyncPeriod =
- getDisplayAttribute(vtsDisplay->getDisplayId(), config, DisplayAttribute::VSYNC_PERIOD);
+ getDisplayAttribute(display->getDisplayId(), config, DisplayAttribute::VSYNC_PERIOD);
const auto configGroup =
- getDisplayAttribute(vtsDisplay->getDisplayId(), config, DisplayAttribute::CONFIG_GROUP);
+ getDisplayAttribute(display->getDisplayId(), config, DisplayAttribute::CONFIG_GROUP);
if (vsyncPeriod.first.isOk() && configGroup.first.isOk()) {
- vtsDisplay->addDisplayConfig(config, {vsyncPeriod.second, configGroup.second});
+ display->addDisplayConfig(config, {vsyncPeriod.second, configGroup.second});
return ScopedAStatus::ok();
}
@@ -563,13 +567,14 @@
return ScopedAStatus::fromServiceSpecificError(IComposerClient::EX_BAD_CONFIG);
}
-ScopedAStatus VtsComposerClient::updateDisplayProperties(VtsDisplay* vtsDisplay, int32_t config) {
+ScopedAStatus ComposerClientWrapper::updateDisplayProperties(DisplayWrapper* display,
+ int32_t config) {
if (getDisplayConfigurationSupported()) {
- auto [status, configs] = getDisplayConfigurations(vtsDisplay->getDisplayId());
+ auto [status, configs] = getDisplayConfigurations(display->getDisplayId());
if (status.isOk()) {
for (const auto& displayConfig : configs) {
if (displayConfig.configId == config) {
- vtsDisplay->setDimensions(displayConfig.width, displayConfig.height);
+ display->setDimensions(displayConfig.width, displayConfig.height);
return ScopedAStatus::ok();
}
}
@@ -577,11 +582,11 @@
LOG(ERROR) << "Failed to update display property with DisplayConfig";
} else {
const auto width =
- getDisplayAttribute(vtsDisplay->getDisplayId(), config, DisplayAttribute::WIDTH);
+ getDisplayAttribute(display->getDisplayId(), config, DisplayAttribute::WIDTH);
const auto height =
- getDisplayAttribute(vtsDisplay->getDisplayId(), config, DisplayAttribute::HEIGHT);
+ getDisplayAttribute(display->getDisplayId(), config, DisplayAttribute::HEIGHT);
if (width.first.isOk() && height.first.isOk()) {
- vtsDisplay->setDimensions(width.second, height.second);
+ display->setDimensions(width.second, height.second);
return ScopedAStatus::ok();
}
@@ -591,7 +596,7 @@
return ScopedAStatus::fromServiceSpecificError(IComposerClient::EX_BAD_CONFIG);
}
-ScopedAStatus VtsComposerClient::addDisplayToDisplayResources(int64_t display, bool isVirtual) {
+ScopedAStatus ComposerClientWrapper::addDisplayToDisplayResources(int64_t display, bool isVirtual) {
if (mDisplayResources.insert({display, DisplayResource(isVirtual)}).second) {
return ScopedAStatus::ok();
}
@@ -600,7 +605,7 @@
return ScopedAStatus::fromServiceSpecificError(IComposerClient::EX_BAD_DISPLAY);
}
-ScopedAStatus VtsComposerClient::addLayerToDisplayResources(int64_t display, int64_t layer) {
+ScopedAStatus ComposerClientWrapper::addLayerToDisplayResources(int64_t display, int64_t layer) {
auto resource = mDisplayResources.find(display);
if (resource == mDisplayResources.end()) {
resource = mDisplayResources.insert({display, DisplayResource(false)}).first;
@@ -613,14 +618,14 @@
return ScopedAStatus::ok();
}
-void VtsComposerClient::removeLayerFromDisplayResources(int64_t display, int64_t layer) {
+void ComposerClientWrapper::removeLayerFromDisplayResources(int64_t display, int64_t layer) {
auto resource = mDisplayResources.find(display);
if (resource != mDisplayResources.end()) {
resource->second.layers.erase(layer);
}
}
-bool VtsComposerClient::verifyComposerCallbackParams() {
+bool ComposerClientWrapper::verifyComposerCallbackParams() {
bool isValid = true;
if (mComposerCallback != nullptr) {
if (mComposerCallback->getInvalidHotplugCount() != 0) {
@@ -651,14 +656,14 @@
return isValid;
}
-bool VtsComposerClient::getDisplayConfigurationSupported() const {
+bool ComposerClientWrapper::getDisplayConfigurationSupported() const {
auto [status, interfaceVersion] = getInterfaceVersion();
EXPECT_TRUE(status.isOk());
// getDisplayConfigurations api is supported starting interface version 3
return interfaceVersion >= 3;
}
-bool VtsComposerClient::destroyAllLayers(ComposerClientWriter* writer) {
+bool ComposerClientWrapper::destroyAllLayers(ComposerClientWriter* writer) {
std::unordered_map<int64_t, DisplayResource> physicalDisplays;
while (!mDisplayResources.empty()) {
const auto& it = mDisplayResources.begin();
@@ -691,15 +696,16 @@
return true;
}
-std::pair<ScopedAStatus, int32_t> VtsComposerClient::getMaxLayerPictureProfiles(int64_t display) {
+std::pair<ScopedAStatus, int32_t> ComposerClientWrapper::getMaxLayerPictureProfiles(
+ int64_t display) {
int32_t outMaxProfiles = 0;
return {mComposerClient->getMaxLayerPictureProfiles(display, &outMaxProfiles), outMaxProfiles};
}
-std::pair<ScopedAStatus, std::vector<Luts>> VtsComposerClient::getLuts(
+std::pair<ScopedAStatus, std::vector<Luts>> ComposerClientWrapper::getLuts(
int64_t display, const std::vector<Buffer>& buffers) {
std::vector<Luts> outLuts;
return {mComposerClient->getLuts(display, buffers, &outLuts), std::move(outLuts)};
}
-} // namespace aidl::android::hardware::graphics::composer3::vts
+} // namespace aidl::android::hardware::graphics::composer3::libhwc_aidl_test
diff --git a/graphics/composer/aidl/vts/GraphicsComposerCallback.cpp b/graphics/composer/aidl/libhwc_aidl_test/GraphicsComposerCallback.cpp
similarity index 97%
rename from graphics/composer/aidl/vts/GraphicsComposerCallback.cpp
rename to graphics/composer/aidl/libhwc_aidl_test/GraphicsComposerCallback.cpp
index 1f7972c..ba16348 100644
--- a/graphics/composer/aidl/vts/GraphicsComposerCallback.cpp
+++ b/graphics/composer/aidl/libhwc_aidl_test/GraphicsComposerCallback.cpp
@@ -23,7 +23,7 @@
#undef LOG_TAG
#define LOG_TAG "GraphicsComposerCallback"
-namespace aidl::android::hardware::graphics::composer3::vts {
+namespace aidl::android::hardware::graphics::composer3::libhwc_aidl_test {
void GraphicsComposerCallback::setVsyncAllowed(bool allowed) {
std::scoped_lock lock(mMutex);
@@ -219,4 +219,4 @@
return ::ndk::ScopedAStatus::ok();
}
-} // namespace aidl::android::hardware::graphics::composer3::vts
+} // namespace aidl::android::hardware::graphics::composer3::libhwc_aidl_test
diff --git a/graphics/composer/aidl/vts/ReadbackVts.cpp b/graphics/composer/aidl/libhwc_aidl_test/Readback.cpp
similarity index 97%
rename from graphics/composer/aidl/vts/ReadbackVts.cpp
rename to graphics/composer/aidl/libhwc_aidl_test/Readback.cpp
index b45c8c0..2aded73 100644
--- a/graphics/composer/aidl/vts/ReadbackVts.cpp
+++ b/graphics/composer/aidl/libhwc_aidl_test/Readback.cpp
@@ -14,14 +14,12 @@
* limitations under the License.
*/
-#include "ReadbackVts.h"
+#include "Readback.h"
#include <aidl/android/hardware/graphics/common/BufferUsage.h>
-#include <cmath>
-#include "RenderEngineVts.h"
-#include "renderengine/ExternalTexture.h"
+#include "RenderEngine.h"
#include "renderengine/impl/ExternalTexture.h"
-namespace aidl::android::hardware::graphics::composer3::vts {
+namespace aidl::android::hardware::graphics::composer3::libhwc_aidl_test {
const std::vector<ColorMode> ReadbackHelper::colorModes = {ColorMode::SRGB, ColorMode::DISPLAY_P3};
const std::vector<Dataspace> ReadbackHelper::dataspaces = {common::Dataspace::SRGB,
@@ -344,8 +342,9 @@
}
}
-ReadbackBuffer::ReadbackBuffer(int64_t display, const std::shared_ptr<VtsComposerClient>& client,
- int32_t width, int32_t height, common::PixelFormat pixelFormat,
+ReadbackBuffer::ReadbackBuffer(int64_t display,
+ const std::shared_ptr<ComposerClientWrapper>& client, int32_t width,
+ int32_t height, common::PixelFormat pixelFormat,
common::Dataspace dataspace)
: mComposerClient(client) {
mDisplay = display;
@@ -427,7 +426,7 @@
return layerSettings;
}
-TestBufferLayer::TestBufferLayer(const std::shared_ptr<VtsComposerClient>& client,
+TestBufferLayer::TestBufferLayer(const std::shared_ptr<ComposerClientWrapper>& client,
TestRenderEngine& renderEngine, int64_t display, uint32_t width,
uint32_t height, common::PixelFormat format,
ComposerClientWriter& writer, Composition composition)
@@ -513,4 +512,4 @@
writer.setLayerCompositionType(mDisplay, mLayer, Composition::CLIENT);
}
-} // namespace aidl::android::hardware::graphics::composer3::vts
+} // namespace aidl::android::hardware::graphics::composer3::libhwc_aidl_test
diff --git a/graphics/composer/aidl/vts/RenderEngineVts.cpp b/graphics/composer/aidl/libhwc_aidl_test/RenderEngine.cpp
similarity index 96%
rename from graphics/composer/aidl/vts/RenderEngineVts.cpp
rename to graphics/composer/aidl/libhwc_aidl_test/RenderEngine.cpp
index 8f8b5fd..6715ea4 100644
--- a/graphics/composer/aidl/vts/RenderEngineVts.cpp
+++ b/graphics/composer/aidl/libhwc_aidl_test/RenderEngine.cpp
@@ -14,10 +14,10 @@
* limitations under the License.
*/
-#include "RenderEngineVts.h"
+#include "RenderEngine.h"
#include "renderengine/impl/ExternalTexture.h"
-namespace aidl::android::hardware::graphics::composer3::vts {
+namespace aidl::android::hardware::graphics::composer3::libhwc_aidl_test {
using ::android::renderengine::DisplaySettings;
using ::android::renderengine::LayerSettings;
@@ -115,4 +115,4 @@
ASSERT_EQ(::android::OK, mGraphicBuffer->unlock());
}
-} // namespace aidl::android::hardware::graphics::composer3::vts
+} // namespace aidl::android::hardware::graphics::composer3::libhwc_aidl_test
diff --git a/graphics/composer/aidl/vts/VtsComposerClient.h b/graphics/composer/aidl/libhwc_aidl_test/include/ComposerClientWrapper.h
similarity index 90%
rename from graphics/composer/aidl/vts/VtsComposerClient.h
rename to graphics/composer/aidl/libhwc_aidl_test/include/ComposerClientWrapper.h
index f0dbe57..22dd888 100644
--- a/graphics/composer/aidl/vts/VtsComposerClient.h
+++ b/graphics/composer/aidl/libhwc_aidl_test/include/ComposerClientWrapper.h
@@ -46,17 +46,17 @@
using aidl::android::hardware::graphics::common::Rect;
using namespace ::ndk;
-namespace aidl::android::hardware::graphics::composer3::vts {
+namespace aidl::android::hardware::graphics::composer3::libhwc_aidl_test {
-class VtsDisplay;
+class DisplayWrapper;
/**
* A wrapper to IComposerClient.
* This wrapper manages the IComposerClient instance and manages the resources for
* the tests with respect to the IComposerClient calls.
*/
-class VtsComposerClient {
+class ComposerClientWrapper {
public:
- VtsComposerClient(const std::string& name);
+ ComposerClientWrapper(const std::string& name);
ScopedAStatus createClient();
@@ -77,9 +77,9 @@
std::pair<ScopedAStatus, int32_t> getActiveConfig(int64_t display);
- ScopedAStatus setActiveConfig(VtsDisplay* vtsDisplay, int32_t config);
+ ScopedAStatus setActiveConfig(DisplayWrapper* display, int32_t config);
- ScopedAStatus setPeakRefreshRateConfig(VtsDisplay* vtsDisplay);
+ ScopedAStatus setPeakRefreshRateConfig(DisplayWrapper* display);
std::pair<ScopedAStatus, int32_t> getDisplayAttribute(int64_t display, int32_t config,
DisplayAttribute displayAttribute);
@@ -100,7 +100,7 @@
ScopedAStatus setContentType(int64_t display, ContentType contentType);
std::pair<ScopedAStatus, VsyncPeriodChangeTimeline> setActiveConfigWithConstraints(
- VtsDisplay* vtsDisplay, int32_t config,
+ DisplayWrapper* display, int32_t config,
const VsyncPeriodChangeConstraints& constraints);
std::pair<ScopedAStatus, std::vector<DisplayCapability>> getDisplayCapabilities(
@@ -190,7 +190,7 @@
int64_t getInvalidDisplayId();
- std::pair<ScopedAStatus, std::vector<VtsDisplay>> getDisplays();
+ std::pair<ScopedAStatus, std::vector<DisplayWrapper>> getDisplays();
std::pair<ScopedAStatus, OverlayProperties> getOverlaySupport();
@@ -207,10 +207,10 @@
static constexpr int32_t kNoFrameIntervalNs = 0;
private:
- void addDisplayConfigs(VtsDisplay*, const std::vector<DisplayConfiguration>&);
- ScopedAStatus addDisplayConfigLegacy(VtsDisplay*, int32_t config);
+ void addDisplayConfigs(DisplayWrapper*, const std::vector<DisplayConfiguration>&);
+ ScopedAStatus addDisplayConfigLegacy(DisplayWrapper*, int32_t config);
bool getDisplayConfigurationSupported() const;
- ScopedAStatus updateDisplayProperties(VtsDisplay* vtsDisplay, int32_t config);
+ ScopedAStatus updateDisplayProperties(DisplayWrapper* display, int32_t config);
ScopedAStatus addDisplayToDisplayResources(int64_t display, bool isVirtual);
@@ -223,7 +223,7 @@
bool verifyComposerCallbackParams();
// Keep track of displays and layers. When a test fails/ends,
- // the VtsComposerClient::tearDown should be called from the
+ // the ComposerClientWrapper::tearDown should be called from the
// test tearDown to clean up the resources for the test.
struct DisplayResource {
DisplayResource(bool isVirtual_) : isVirtual(isVirtual_) {}
@@ -240,9 +240,10 @@
std::atomic<int64_t> mNextLayerHandle = 1;
};
-class VtsDisplay {
+class DisplayWrapper {
public:
- VtsDisplay(int64_t displayId) : mDisplayId(displayId), mDisplayWidth(0), mDisplayHeight(0) {}
+ DisplayWrapper(int64_t displayId)
+ : mDisplayId(displayId), mDisplayWidth(0), mDisplayHeight(0) {}
int64_t getDisplayId() const { return mDisplayId; }
@@ -299,9 +300,8 @@
std::stringstream ss;
if (displayConfig.vrrConfigOpt) {
ss << "{Config " << config << ": vsyncPeriod " << displayConfig.vsyncPeriod
- << ", minFrameIntervalNs " << vrrConfigOpt->minFrameIntervalNs << "}";
- }
- else {
+ << ", minFrameIntervalNs " << vrrConfigOpt->minFrameIntervalNs << "}";
+ } else {
ss << "{Config " << config << ": vsyncPeriod " << displayConfig.vsyncPeriod << "}";
}
return ss.str();
@@ -315,4 +315,4 @@
int32_t mDisplayHeight;
std::unordered_map<int32_t, DisplayConfig> mDisplayConfigs;
};
-} // namespace aidl::android::hardware::graphics::composer3::vts
+} // namespace aidl::android::hardware::graphics::composer3::libhwc_aidl_test
diff --git a/graphics/composer/aidl/vts/GraphicsComposerCallback.h b/graphics/composer/aidl/libhwc_aidl_test/include/GraphicsComposerCallback.h
similarity index 95%
rename from graphics/composer/aidl/vts/GraphicsComposerCallback.h
rename to graphics/composer/aidl/libhwc_aidl_test/include/GraphicsComposerCallback.h
index 97f8e2b..ff379b7 100644
--- a/graphics/composer/aidl/vts/GraphicsComposerCallback.h
+++ b/graphics/composer/aidl/libhwc_aidl_test/include/GraphicsComposerCallback.h
@@ -20,7 +20,7 @@
#include <mutex>
#include <vector>
-namespace aidl::android::hardware::graphics::composer3::vts {
+namespace aidl::android::hardware::graphics::composer3::libhwc_aidl_test {
class GraphicsComposerCallback : public BnComposerCallback {
public:
@@ -93,4 +93,4 @@
int32_t mHdcpLevelChangedCount GUARDED_BY(mMutex) = 0;
};
-} // namespace aidl::android::hardware::graphics::composer3::vts
+} // namespace aidl::android::hardware::graphics::composer3::libhwc_aidl_test
diff --git a/graphics/composer/aidl/vts/ReadbackVts.h b/graphics/composer/aidl/libhwc_aidl_test/include/Readback.h
similarity index 90%
rename from graphics/composer/aidl/vts/ReadbackVts.h
rename to graphics/composer/aidl/libhwc_aidl_test/include/Readback.h
index c04e37a..9fdb4d3 100644
--- a/graphics/composer/aidl/vts/ReadbackVts.h
+++ b/graphics/composer/aidl/libhwc_aidl_test/include/Readback.h
@@ -24,12 +24,11 @@
#include <renderengine/RenderEngine.h>
#include <ui/GraphicBuffer.h>
#include <memory>
-#include "GraphicsComposerCallback.h"
-#include "VtsComposerClient.h"
+#include "ComposerClientWrapper.h"
using aidl::android::hardware::graphics::composer3::Luts;
-namespace aidl::android::hardware::graphics::composer3::vts {
+namespace aidl::android::hardware::graphics::composer3::libhwc_aidl_test {
using ::android::renderengine::LayerSettings;
using common::Dataspace;
@@ -53,7 +52,7 @@
class TestLayer {
public:
- TestLayer(const std::shared_ptr<VtsComposerClient>& client, int64_t display,
+ TestLayer(const std::shared_ptr<ComposerClientWrapper>& client, int64_t display,
ComposerClientWriter& writer)
: mDisplay(display) {
const auto& [status, layer] = client->createLayer(display, kBufferSlotCount, &writer);
@@ -63,7 +62,7 @@
// ComposerClient will take care of destroying layers, no need to explicitly
// call destroyLayers here
- virtual ~TestLayer(){};
+ virtual ~TestLayer() {};
virtual void write(ComposerClientWriter& writer);
virtual LayerSettings toRenderEngineLayerSettings();
@@ -114,7 +113,7 @@
class TestColorLayer : public TestLayer {
public:
- TestColorLayer(const std::shared_ptr<VtsComposerClient>& client, int64_t display,
+ TestColorLayer(const std::shared_ptr<ComposerClientWrapper>& client, int64_t display,
ComposerClientWriter& writer)
: TestLayer{client, display, writer} {}
@@ -130,7 +129,7 @@
class TestBufferLayer : public TestLayer {
public:
- TestBufferLayer(const std::shared_ptr<VtsComposerClient>& client,
+ TestBufferLayer(const std::shared_ptr<ComposerClientWrapper>& client,
TestRenderEngine& renderEngine, int64_t display, uint32_t width,
uint32_t height, common::PixelFormat format, ComposerClientWriter& writer,
Composition composition = Composition::DEVICE);
@@ -206,8 +205,9 @@
class ReadbackBuffer {
public:
- ReadbackBuffer(int64_t display, const std::shared_ptr<VtsComposerClient>& client, int32_t width,
- int32_t height, common::PixelFormat pixelFormat, common::Dataspace dataspace);
+ ReadbackBuffer(int64_t display, const std::shared_ptr<ComposerClientWrapper>& client,
+ int32_t width, int32_t height, common::PixelFormat pixelFormat,
+ common::Dataspace dataspace);
void setReadbackBuffer();
@@ -224,7 +224,7 @@
Dataspace mDataspace;
int64_t mDisplay;
::android::sp<::android::GraphicBuffer> mGraphicBuffer;
- std::shared_ptr<VtsComposerClient> mComposerClient;
+ std::shared_ptr<ComposerClientWrapper> mComposerClient;
::android::Rect mAccessRegion;
native_handle_t mBufferHandle;
@@ -232,4 +232,4 @@
::android::sp<::android::GraphicBuffer> allocateBuffer();
};
-} // namespace aidl::android::hardware::graphics::composer3::vts
+} // namespace aidl::android::hardware::graphics::composer3::libhwc_aidl_test
diff --git a/graphics/composer/aidl/vts/RenderEngineVts.h b/graphics/composer/aidl/libhwc_aidl_test/include/RenderEngine.h
similarity index 91%
rename from graphics/composer/aidl/vts/RenderEngineVts.h
rename to graphics/composer/aidl/libhwc_aidl_test/include/RenderEngine.h
index 6553720..6b8b82f 100644
--- a/graphics/composer/aidl/vts/RenderEngineVts.h
+++ b/graphics/composer/aidl/libhwc_aidl_test/include/RenderEngine.h
@@ -23,9 +23,9 @@
#include <ui/PixelFormat.h>
#include <ui/Rect.h>
#include <ui/Region.h>
-#include "ReadbackVts.h"
+#include "Readback.h"
-namespace aidl::android::hardware::graphics::composer3::vts {
+namespace aidl::android::hardware::graphics::composer3::libhwc_aidl_test {
using ::android::renderengine::DisplaySettings;
using ::android::renderengine::ExternalTexture;
@@ -60,4 +60,4 @@
DisplaySettings mDisplaySettings;
};
-} // namespace aidl::android::hardware::graphics::composer3::vts
+} // namespace aidl::android::hardware::graphics::composer3::libhwc_aidl_test
diff --git a/graphics/composer/aidl/vts/Android.bp b/graphics/composer/aidl/vts/Android.bp
index 61c2593..cf9c6d7 100644
--- a/graphics/composer/aidl/vts/Android.bp
+++ b/graphics/composer/aidl/vts/Android.bp
@@ -36,28 +36,19 @@
srcs: [
"VtsHalGraphicsComposer3_TargetTest.cpp",
"VtsHalGraphicsComposer3_ReadbackTest.cpp",
- "GraphicsComposerCallback.cpp",
- "ReadbackVts.cpp",
- "RenderEngineVts.cpp",
- "VtsComposerClient.cpp",
],
-
shared_libs: [
"libEGL",
- "libGLESv1_CM",
"libGLESv2",
"libbinder_ndk",
"libbinder",
- "libfmq",
"libbase",
"libsync",
"libui",
"libgui",
- "libhidlbase",
"libprocessgroup",
- "libvndksupport",
- "server_configurable_flags",
"libtracing_perfetto",
+ "server_configurable_flags",
],
header_libs: [
"android.hardware.graphics.composer3-command-buffer",
@@ -66,19 +57,17 @@
"android.hardware.graphics.common@1.2",
"android.hardware.common-V2-ndk",
"android.hardware.common.fmq-V1-ndk",
- "android.hardware.drm.common-V1-ndk",
"libaidlcommonsupport",
"libarect",
"libbase",
- "libfmq",
"libgmock",
"libgtest",
- "libmath",
+ "libhwc_aidl_test",
"librenderengine",
- "libshaders",
"libsync",
- "libtonemap",
"libsurfaceflinger_common",
+ "libshaders",
+ "libtonemap",
],
cflags: [
"-Wconversion",
diff --git a/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_ReadbackTest.cpp b/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_ReadbackTest.cpp
index 6883cdb..dff044d 100644
--- a/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_ReadbackTest.cpp
+++ b/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_ReadbackTest.cpp
@@ -27,14 +27,16 @@
#include <ui/GraphicBuffer.h>
#include <ui/PixelFormat.h>
#include <ui/Rect.h>
+#include "ComposerClientWrapper.h"
#include "GraphicsComposerCallback.h"
-#include "ReadbackVts.h"
-#include "RenderEngineVts.h"
-#include "VtsComposerClient.h"
+#include "Readback.h"
+#include "RenderEngine.h"
namespace aidl::android::hardware::graphics::composer3::vts {
namespace {
+using namespace ::aidl::android::hardware::graphics::composer3::libhwc_aidl_test;
+
using ::android::Rect;
using common::Dataspace;
using common::PixelFormat;
@@ -42,7 +44,7 @@
class GraphicsCompositionTestBase : public ::testing::Test {
protected:
void SetUpBase(const std::string& name) {
- mComposerClient = std::make_shared<VtsComposerClient>(name);
+ mComposerClient = std::make_shared<ComposerClientWrapper>(name);
ASSERT_TRUE(mComposerClient->createClient().isOk());
const auto& [status, displays] = mComposerClient->getDisplays();
@@ -97,7 +99,7 @@
ASSERT_TRUE(mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty());
}
- const VtsDisplay& getPrimaryDisplay() const { return mDisplays[0]; }
+ const DisplayWrapper& getPrimaryDisplay() const { return mDisplays[0]; }
int64_t getPrimaryDisplayId() const { return getPrimaryDisplay().getDisplayId(); }
@@ -158,8 +160,8 @@
return false;
}
- std::shared_ptr<VtsComposerClient> mComposerClient;
- std::vector<VtsDisplay> mDisplays;
+ std::shared_ptr<ComposerClientWrapper> mComposerClient;
+ std::vector<DisplayWrapper> mDisplays;
// use the slot count usually set by SF
std::vector<ColorMode> mTestColorModes;
std::unique_ptr<ComposerClientWriter> mWriter;
@@ -226,7 +228,7 @@
writeLayers(layers);
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
// if hwc cannot handle and asks for composition change,
// just succeed the test
@@ -286,7 +288,7 @@
writeLayers(layers);
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
@@ -347,7 +349,7 @@
ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
@@ -462,7 +464,7 @@
auto layer = std::make_shared<TestBufferLayer>(
mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), getDisplayWidth(),
- getDisplayHeight(), PixelFormat::RGBA_FP16, *mWriter);
+ getDisplayHeight(), PixelFormat::RGBA_8888, *mWriter);
layer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
layer->setZOrder(10);
layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode));
@@ -475,7 +477,7 @@
writeLayers(layers);
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
auto changedCompositionTypes = mReader.takeChangedCompositionTypes(getPrimaryDisplayId());
@@ -512,7 +514,7 @@
clientDataspace, std::vector<common::Rect>(1, damage), 1.f);
layer->setToClientComposition(*mWriter);
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
changedCompositionTypes = mReader.takeChangedCompositionTypes(getPrimaryDisplayId());
ASSERT_TRUE(changedCompositionTypes.empty());
@@ -612,7 +614,7 @@
writeLayers(layers);
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
// if hwc cannot handle and asks for composition change,
// just succeed the test
@@ -703,7 +705,7 @@
writeLayers({srgbLayer, displayP3Layer});
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
auto changedCompositionTypes = mReader.takeChangedCompositionTypes(getPrimaryDisplayId());
@@ -780,7 +782,7 @@
clientLayer->setZOrder(0);
clientLayer->write(*mWriter);
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
auto changedCompositionTypes = mReader.takeChangedCompositionTypes(getPrimaryDisplayId());
@@ -813,7 +815,7 @@
clientDataspace, std::vector<common::Rect>(1, clientFrame), 1.f);
clientLayer->setToClientComposition(*mWriter);
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
changedCompositionTypes = mReader.takeChangedCompositionTypes(getPrimaryDisplayId());
ASSERT_TRUE(changedCompositionTypes.empty());
@@ -862,7 +864,7 @@
writeLayers(layers);
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED();
@@ -891,7 +893,7 @@
writeLayers(layers);
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
ASSERT_TRUE(mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty());
@@ -934,7 +936,7 @@
writeLayers(layers);
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED();
@@ -999,7 +1001,7 @@
writeLayers(layers);
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED();
@@ -1060,7 +1062,7 @@
writeLayers(layers);
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED();
@@ -1083,7 +1085,7 @@
writeLayers(layers);
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
ASSERT_TRUE(mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty());
ASSERT_TRUE(mReader.takeErrors().empty());
@@ -1149,7 +1151,7 @@
writeLayers(layers);
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED()
@@ -1285,7 +1287,7 @@
writeLayers(mLayers);
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED();
@@ -1331,7 +1333,7 @@
writeLayers(mLayers);
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED();
@@ -1372,7 +1374,7 @@
writeLayers(mLayers);
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED();
@@ -1457,7 +1459,7 @@
writeLayers(mLayers);
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED();
@@ -1504,7 +1506,7 @@
writeLayers(mLayers);
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED();
@@ -1551,7 +1553,7 @@
writeLayers(mLayers);
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED();
@@ -1646,7 +1648,7 @@
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
continue;
diff --git a/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_TargetTest.cpp b/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_TargetTest.cpp
index 6b43cc8..9669443 100644
--- a/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_TargetTest.cpp
+++ b/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_TargetTest.cpp
@@ -22,8 +22,8 @@
#include <aidl/android/hardware/graphics/common/PixelFormat.h>
#include <aidl/android/hardware/graphics/common/Rect.h>
#include <aidl/android/hardware/graphics/composer3/Composition.h>
-#include <aidl/android/hardware/graphics/composer3/OutputType.h>
#include <aidl/android/hardware/graphics/composer3/IComposer.h>
+#include <aidl/android/hardware/graphics/composer3/OutputType.h>
#include <android-base/properties.h>
#include <android/binder_process.h>
#include <android/hardware/graphics/composer3/ComposerClientReader.h>
@@ -43,8 +43,8 @@
#include <string>
#include <thread>
#include <unordered_map>
+#include "ComposerClientWrapper.h"
#include "GraphicsComposerCallback.h"
-#include "VtsComposerClient.h"
#undef LOG_TAG
#define LOG_TAG "VtsHalGraphicsComposer3_TargetTest"
@@ -54,6 +54,7 @@
namespace aidl::android::hardware::graphics::composer3::vts {
using namespace std::chrono_literals;
+using namespace aidl::android::hardware::graphics::composer3::libhwc_aidl_test;
using ::android::GraphicBuffer;
using ::android::sp;
@@ -61,7 +62,7 @@
class GraphicsComposerAidlTest : public ::testing::TestWithParam<std::string> {
protected:
void SetUp() override {
- mComposerClient = std::make_unique<VtsComposerClient>(GetParam());
+ mComposerClient = std::make_unique<ComposerClientWrapper>(GetParam());
ASSERT_TRUE(mComposerClient->createClient().isOk());
const auto& [status, displays] = mComposerClient->getDisplays();
@@ -139,21 +140,21 @@
return version;
}
- const VtsDisplay& getPrimaryDisplay() const { return mDisplays[0]; }
+ const DisplayWrapper& getPrimaryDisplay() const { return mDisplays[0]; }
int64_t getPrimaryDisplayId() const { return getPrimaryDisplay().getDisplayId(); }
int64_t getInvalidDisplayId() const { return mComposerClient->getInvalidDisplayId(); }
- VtsDisplay& getEditablePrimaryDisplay() { return mDisplays[0]; }
+ DisplayWrapper& getEditablePrimaryDisplay() { return mDisplays[0]; }
struct TestParameters {
nsecs_t delayForChange;
bool refreshMiss;
};
- std::unique_ptr<VtsComposerClient> mComposerClient;
- std::vector<VtsDisplay> mDisplays;
+ std::unique_ptr<ComposerClientWrapper> mComposerClient;
+ std::vector<DisplayWrapper> mDisplays;
// use the slot count usually set by SF
static constexpr uint32_t kBufferSlotCount = 64;
};
@@ -248,7 +249,6 @@
GTEST_SUCCEED() << "getReadbackBufferAttributes is not supported";
return;
}
-
ASSERT_TRUE(status.isOk());
}
@@ -512,7 +512,7 @@
VsyncPeriodChangeConstraints constraints;
constraints.seamlessRequired = false;
constraints.desiredTimeNanos = systemTime();
- auto invalidDisplay = VtsDisplay(getInvalidDisplayId());
+ auto invalidDisplay = DisplayWrapper(getInvalidDisplayId());
const auto& [status, timeline] = mComposerClient->setActiveConfigWithConstraints(
&invalidDisplay, /*config*/ 0, constraints);
@@ -526,7 +526,7 @@
constraints.seamlessRequired = false;
constraints.desiredTimeNanos = systemTime();
- for (VtsDisplay& display : mDisplays) {
+ for (DisplayWrapper& display : mDisplays) {
int32_t constexpr kInvalidConfigId = IComposerClient::INVALID_CONFIGURATION;
const auto& [status, _] = mComposerClient->setActiveConfigWithConstraints(
&display, kInvalidConfigId, constraints);
@@ -552,7 +552,7 @@
GTEST_SUCCEED() << "Boot Display Config not supported";
return;
}
- for (VtsDisplay& display : mDisplays) {
+ for (DisplayWrapper& display : mDisplays) {
int32_t constexpr kInvalidConfigId = IComposerClient::INVALID_CONFIGURATION;
const auto& status =
mComposerClient->setBootDisplayConfig(display.getDisplayId(), kInvalidConfigId);
@@ -1315,7 +1315,7 @@
const auto minFrameInterval = *min_element(frameIntervalPowerHints.cbegin(),
frameIntervalPowerHints.cend());
EXPECT_LE(minFrameInterval->frameIntervalNs,
- VtsComposerClient::kMaxFrameIntervalNs);
+ ComposerClientWrapper::kMaxFrameIntervalNs);
const auto maxFrameInterval = *max_element(frameIntervalPowerHints.cbegin(),
frameIntervalPowerHints.cend());
EXPECT_GE(maxFrameInterval->frameIntervalNs, vrrConfig.minFrameIntervalNs);
@@ -1495,7 +1495,8 @@
static_cast<uint32_t>(getPrimaryDisplay().getDisplayHeight()), pixelFormat);
}
- void sendRefreshFrame(const VtsDisplay& display, const VsyncPeriodChangeTimeline* timeline) {
+ void sendRefreshFrame(const DisplayWrapper& display,
+ const VsyncPeriodChangeTimeline* timeline) {
if (timeline != nullptr) {
// Refresh time should be before newVsyncAppliedTimeNanos
EXPECT_LT(timeline->refreshTimeNanos, timeline->newVsyncAppliedTimeNanos);
@@ -1526,7 +1527,7 @@
writer.setLayerDataspace(display.getDisplayId(), layer, common::Dataspace::UNKNOWN);
writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
@@ -1544,7 +1545,7 @@
writer.setLayerSurfaceDamage(display.getDisplayId(), layer,
std::vector<Rect>(1, {0, 0, 10, 10}));
writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
@@ -1557,8 +1558,8 @@
sp<::android::Fence> presentAndGetFence(
std::optional<ClockMonotonicTimestamp> expectedPresentTime,
- std::optional<int64_t> displayIdOpt = {},
- int32_t frameIntervalNs = VtsComposerClient::kNoFrameIntervalNs) {
+ std::optional<int> displayIdOpt = {},
+ int32_t frameIntervalNs = ComposerClientWrapper::kNoFrameIntervalNs) {
const auto displayId = displayIdOpt.value_or(getPrimaryDisplayId());
auto& writer = getWriter(displayId);
writer.validateDisplay(displayId, expectedPresentTime, frameIntervalNs);
@@ -1588,7 +1589,7 @@
return vsyncPeriod;
}
- int64_t createOnScreenLayer(const VtsDisplay& display,
+ int64_t createOnScreenLayer(const DisplayWrapper& display,
Composition composition = Composition::DEVICE) {
auto& writer = getWriter(display.getDisplayId());
const auto& [status, layer] =
@@ -1623,7 +1624,7 @@
}
void Test_setActiveConfigWithConstraints(const TestParameters& params) {
- for (VtsDisplay& display : mDisplays) {
+ for (DisplayWrapper& display : mDisplays) {
forEachTwoConfigs(display.getDisplayId(), [&](int32_t config1, int32_t config2) {
EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
sendRefreshFrame(display, nullptr);
@@ -1750,8 +1751,8 @@
}
void forEachNotifyExpectedPresentConfig(
- std::function<void(VtsDisplay&, const DisplayConfiguration&)> func) {
- for (VtsDisplay& display : mDisplays) {
+ std::function<void(DisplayWrapper&, const DisplayConfiguration&)> func) {
+ for (DisplayWrapper& display : mDisplays) {
const auto displayId = display.getDisplayId();
EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
const auto& [status, displayConfigurations] =
@@ -1781,7 +1782,7 @@
}
}
- void configureLayer(const VtsDisplay& display, int64_t layer, Composition composition,
+ void configureLayer(const DisplayWrapper& display, int64_t layer, Composition composition,
const Rect& displayFrame, const FRect& cropRect) {
auto& writer = getWriter(display.getDisplayId());
writer.setLayerCompositionType(display.getDisplayId(), layer, composition);
@@ -1943,14 +1944,14 @@
TEST_P(GraphicsComposerAidlCommandTest, ValidDisplay) {
auto& writer = getWriter(getPrimaryDisplayId());
writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
}
TEST_P(GraphicsComposerAidlCommandTest, AcceptDisplayChanges) {
auto& writer = getWriter(getPrimaryDisplayId());
writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
writer.acceptDisplayChanges(getPrimaryDisplayId());
execute();
}
@@ -1958,7 +1959,7 @@
TEST_P(GraphicsComposerAidlCommandTest, PresentDisplay) {
auto& writer = getWriter(getPrimaryDisplayId());
writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
writer.presentDisplay(getPrimaryDisplayId());
execute();
}
@@ -1998,7 +1999,7 @@
/*acquireFence*/ -1);
writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED() << "Composition change requested, skipping test";
@@ -2041,7 +2042,7 @@
configureLayer(getPrimaryDisplay(), layer, Composition::CURSOR, displayFrame, cropRect);
writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
@@ -2057,7 +2058,7 @@
writer.setLayerCursorPosition(getPrimaryDisplayId(), layer, /*x*/ 0, /*y*/ 0);
writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
writer.presentDisplay(getPrimaryDisplayId());
execute();
}
@@ -2228,7 +2229,7 @@
}
TEST_P(GraphicsComposerAidlCommandTest, DisplayDecoration) {
- for (VtsDisplay& display : mDisplays) {
+ for (DisplayWrapper& display : mDisplays) {
const auto displayId = display.getDisplayId();
auto& writer = getWriter(displayId);
const auto [layerStatus, layer] =
@@ -2258,7 +2259,7 @@
writer.setLayerBuffer(displayId, layer, /*slot*/ 0, decorBuffer->handle,
/*acquireFence*/ -1);
writer.validateDisplay(displayId, ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
if (support) {
ASSERT_TRUE(mReader.takeErrors().empty());
@@ -2509,7 +2510,7 @@
}
TEST_P(GraphicsComposerAidlCommandTest, GetDisplayVsyncPeriod) {
- for (VtsDisplay& display : mDisplays) {
+ for (DisplayWrapper& display : mDisplays) {
const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
EXPECT_TRUE(status.isOk());
@@ -2568,7 +2569,7 @@
constraints.seamlessRequired = true;
constraints.desiredTimeNanos = systemTime();
- for (VtsDisplay& display : mDisplays) {
+ for (DisplayWrapper& display : mDisplays) {
forEachTwoConfigs(display.getDisplayId(), [&](int32_t config1, int32_t config2) {
int32_t configGroup1 = display.getDisplayConfig(config1).configGroup;
int32_t configGroup2 = display.getDisplayConfig(config2).configGroup;
@@ -2755,7 +2756,7 @@
return;
}
- for (VtsDisplay& display : mDisplays) {
+ for (DisplayWrapper& display : mDisplays) {
const auto displayId = display.getDisplayId();
EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
// Enable the callback
@@ -2859,7 +2860,7 @@
constraints.seamlessRequired = false;
constraints.desiredTimeNanos = systemTime();
- for (VtsDisplay& display : mDisplays) {
+ for (DisplayWrapper& display : mDisplays) {
const auto displayId = display.getDisplayId();
EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
@@ -2917,7 +2918,7 @@
}
TEST_P(GraphicsComposerAidlCommandTest, MultiThreadedPresent) {
- std::vector<VtsDisplay*> displays;
+ std::vector<DisplayWrapper*> displays;
for (auto& display : mDisplays) {
if (hasDisplayCapability(display.getDisplayId(),
DisplayCapability::MULTI_THREADED_PRESENT)) {
@@ -2980,7 +2981,7 @@
lock.unlock();
writer.validateDisplay(displayId, ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute(writer, reader);
threads.emplace_back([this, displayId, &readers, &readersMutex]() {
@@ -3115,7 +3116,7 @@
GTEST_SUCCEED() << "Device has unreliable present fences capability, skipping";
return;
}
- forEachNotifyExpectedPresentConfig([&](VtsDisplay& display,
+ forEachNotifyExpectedPresentConfig([&](DisplayWrapper& display,
const DisplayConfiguration& config) {
const auto displayId = display.getDisplayId();
auto minFrameIntervalNs = config.vrrConfig->minFrameIntervalNs;
@@ -3155,7 +3156,7 @@
GTEST_SUCCEED() << "Device has unreliable present fences capability, skipping";
return;
}
- forEachNotifyExpectedPresentConfig([&](VtsDisplay& display,
+ forEachNotifyExpectedPresentConfig([&](DisplayWrapper& display,
const DisplayConfiguration& config) {
const auto displayId = display.getDisplayId();
const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
@@ -3171,7 +3172,7 @@
auto lastPresentTimeNs = presentFence->getSignalTime();
auto vsyncPeriod = config.vsyncPeriod;
- int32_t highestDivisor = VtsComposerClient::kMaxFrameIntervalNs / vsyncPeriod;
+ int32_t highestDivisor = ComposerClientWrapper::kMaxFrameIntervalNs / vsyncPeriod;
int32_t lowestDivisor = minFrameIntervalNs / vsyncPeriod;
const auto headsUpNs = config.vrrConfig->notifyExpectedPresentConfig->headsUpNs;
float totalDivisorsPassed = 0.f;
@@ -3202,7 +3203,7 @@
GTEST_SUCCEED() << "Device has unreliable present fences capability, skipping";
return;
}
- forEachNotifyExpectedPresentConfig([&](VtsDisplay& display,
+ forEachNotifyExpectedPresentConfig([&](DisplayWrapper& display,
const DisplayConfiguration& config) {
const auto displayId = display.getDisplayId();
const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
@@ -3214,7 +3215,7 @@
auto minFrameIntervalNs = config.vrrConfig->minFrameIntervalNs;
auto vsyncPeriod = config.vsyncPeriod;
- int32_t highestDivisor = VtsComposerClient::kMaxFrameIntervalNs / vsyncPeriod;
+ int32_t highestDivisor = ComposerClientWrapper::kMaxFrameIntervalNs / vsyncPeriod;
int32_t lowestDivisor = minFrameIntervalNs / vsyncPeriod;
const auto headsUpNs = config.vrrConfig->notifyExpectedPresentConfig->headsUpNs;
float totalDivisorsPassed = 0.f;
@@ -3411,7 +3412,7 @@
/*acquireFence*/ -1);
writer.setLayerLuts(getPrimaryDisplayId(), layer, luts);
writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
const auto errors = mReader.takeErrors();
if (errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_UNSUPPORTED) {