Merge "setCellularIdentifierTransparencyEnabled: skip on errors" into main
diff --git a/audio/aidl/default/r_submix/StreamRemoteSubmix.cpp b/audio/aidl/default/r_submix/StreamRemoteSubmix.cpp
index cef0ea6..f8ead16 100644
--- a/audio/aidl/default/r_submix/StreamRemoteSubmix.cpp
+++ b/audio/aidl/default/r_submix/StreamRemoteSubmix.cpp
@@ -283,6 +283,15 @@
}
return ::android::OK;
}
+ // get and hold the sink because 'MonoPipeReader' does not hold a strong pointer to it.
+ sp<MonoPipe> sink = mCurrentRoute->getSink();
+ if (sink == nullptr) {
+ if (++mReadErrorCount < kMaxErrorLogs) {
+ LOG(ERROR) << __func__
+ << ": the sink has been released! (not all errors will be logged)";
+ }
+ return ::android::OK;
+ }
mReadErrorCount = 0;
LOG(VERBOSE) << __func__ << ": " << mDeviceAddress.toString() << ", " << frameCount
diff --git a/audio/aidl/vts/EffectHelper.h b/audio/aidl/vts/EffectHelper.h
index 5c75e48..e334ee9 100644
--- a/audio/aidl/vts/EffectHelper.h
+++ b/audio/aidl/vts/EffectHelper.h
@@ -88,6 +88,7 @@
static constexpr int kNPointFFT = 16384;
static constexpr int kSamplingFrequency = 44100;
static constexpr int kDefaultChannelLayout = AudioChannelLayout::LAYOUT_STEREO;
+static constexpr float kLn10Div20 = -0.11512925f; // -ln(10)/20
class EffectHelper {
public:
@@ -595,6 +596,8 @@
}
}
+ constexpr float dBToAmplitude(float dB) { return std::exp(dB * kLn10Div20); }
+
static int getHalVersion(const std::shared_ptr<IEffect>& effect) {
int version = 0;
return (effect && effect->getInterfaceVersion(&version).isOk()) ? version : 0;
diff --git a/audio/aidl/vts/TestUtils.h b/audio/aidl/vts/TestUtils.h
index 3a6c137..9ebdc6e 100644
--- a/audio/aidl/vts/TestUtils.h
+++ b/audio/aidl/vts/TestUtils.h
@@ -124,3 +124,30 @@
EXPECT_PRED_FORMAT2( \
::android::hardware::audio::common::testing::detail::assertResultOrUnknownTransaction, \
expected, ret)
+
+namespace android::hardware::audio::common::testing::detail {
+
+template <typename>
+struct mf_traits {};
+template <class T, class U>
+struct mf_traits<U T::*> {
+ using member_type = U;
+};
+
+} // namespace android::hardware::audio::common::testing::detail
+
+namespace aidl::android::media::audio::common {
+
+template <typename P>
+std::enable_if_t<std::is_function_v<typename ::android::hardware::audio::common::testing::detail::
+ mf_traits<decltype(&P::toString)>::member_type>,
+ std::ostream&>
+operator<<(std::ostream& os, const P& p) {
+ return os << p.toString();
+}
+template <typename E>
+std::enable_if_t<std::is_enum_v<E>, std::ostream&> operator<<(std::ostream& os, const E& e) {
+ return os << toString(e);
+}
+
+} // namespace aidl::android::media::audio::common
diff --git a/audio/aidl/vts/VtsHalAudioCoreConfigTargetTest.cpp b/audio/aidl/vts/VtsHalAudioCoreConfigTargetTest.cpp
index eaec88b..7b15e5e 100644
--- a/audio/aidl/vts/VtsHalAudioCoreConfigTargetTest.cpp
+++ b/audio/aidl/vts/VtsHalAudioCoreConfigTargetTest.cpp
@@ -341,7 +341,7 @@
auto values = criterionV2.values;
auto valueIt = find_if(values.begin(), values.end(),
[&](const auto& typedValue) { return typedValue == value; });
- EXPECT_NE(valueIt, values.end());
+ EXPECT_NE(valueIt, values.end()) << "Not found: \"" << value << "\"";
}
/**
diff --git a/audio/aidl/vts/VtsHalDynamicsProcessingTest.cpp b/audio/aidl/vts/VtsHalDynamicsProcessingTest.cpp
index 70790c4..0d4c74e 100644
--- a/audio/aidl/vts/VtsHalDynamicsProcessingTest.cpp
+++ b/audio/aidl/vts/VtsHalDynamicsProcessingTest.cpp
@@ -788,9 +788,10 @@
void SetUp() override {
SetUpDynamicsProcessingEffect();
SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);
- ASSERT_NO_FATAL_FAILURE(generateSineWave(1000 /*Input Frequency*/, mInput, 1.0,
- kSamplingFrequency, mChannelLayout));
+ ASSERT_NO_FATAL_FAILURE(
+ generateSineWave(kInputFrequency, mInput, 1.0, kSamplingFrequency, mChannelLayout));
mInputDb = calculateDb(mInput);
+ ASSERT_NEAR(mInputDb, kSineFullScaleDb, kToleranceDb);
}
void TearDown() override { TearDownDynamicsProcessingEffect(); }
@@ -823,6 +824,9 @@
static constexpr float kDefaultRatio = 4;
static constexpr float kDefaultThreshold = -10;
static constexpr float kDefaultPostGain = 0;
+ static constexpr float kInputFrequency = 1000;
+ // Full scale sine wave with 1000 Hz frequency is -3 dB
+ static constexpr float kSineFullScaleDb = -3;
std::vector<DynamicsProcessing::LimiterConfig> mLimiterConfigList;
std::vector<float> mInput;
float mInputDb;
@@ -887,9 +891,13 @@
std::vector<float> output(mInput.size());
for (float postGainDb : postGainDbValues) {
cleanUpLimiterConfig();
+ ASSERT_NO_FATAL_FAILURE(generateSineWave(kInputFrequency, mInput, dBToAmplitude(postGainDb),
+ kSamplingFrequency, mChannelLayout));
+ mInputDb = calculateDb(mInput);
+ EXPECT_NEAR(mInputDb, kSineFullScaleDb - postGainDb, kToleranceDb);
for (int i = 0; i < mChannelCount; i++) {
fillLimiterConfig(mLimiterConfigList, i, true, kDefaultLinkerGroup, kDefaultAttackTime,
- kDefaultReleaseTime, kDefaultRatio, -1, postGainDb);
+ kDefaultReleaseTime, 1, kDefaultThreshold, postGainDb);
}
ASSERT_NO_FATAL_FAILURE(setLimiterParamsAndProcess(mInput, output));
if (!isAllParamsValid()) {
@@ -1255,6 +1263,7 @@
ASSERT_NO_FATAL_FAILURE(generateSineWave(mTestFrequencies, mInput, 1.0, kSamplingFrequency,
mChannelLayout));
mInputDb = calculateDb(mInput);
+ ASSERT_NEAR(mInputDb, kFullScaleDb, kToleranceDb);
}
void TearDown() override { TearDownDynamicsProcessingEffect(); }
@@ -1267,12 +1276,7 @@
addEngineConfig(mEngineConfigPreset);
addMbcChannelConfig(mChannelConfig);
addMbcBandConfigs(mCfgs);
-
- if (isAllParamsValid()) {
- ASSERT_NO_FATAL_FAILURE(SetAndGetDynamicsProcessingParameters());
- ASSERT_NO_FATAL_FAILURE(
- processAndWriteToOutput(mInput, output, mEffect, &mOpenEffectReturn));
- }
+ ASSERT_NO_FATAL_FAILURE(setParamsAndProcess(mInput, output));
}
void fillMbcBandConfig(std::vector<DynamicsProcessing::MbcBandConfig>& cfgs, int channelIndex,
@@ -1387,9 +1391,9 @@
std::vector<float> postGainDbValues = {-55, -30, 0, 30, 55};
std::vector<float> output(mInput.size());
for (float postGainDb : postGainDbValues) {
- float amplitude = 1.0 / (pow(10, postGainDb / 20));
- ASSERT_NO_FATAL_FAILURE(generateSineWave(mTestFrequencies, mInput, amplitude,
- kSamplingFrequency, mChannelLayout));
+ ASSERT_NO_FATAL_FAILURE(generateSineWave(mTestFrequencies, mInput,
+ dBToAmplitude(postGainDb), kSamplingFrequency,
+ mChannelLayout));
mInputDb = calculateDb(mInput);
EXPECT_NEAR(mInputDb, kFullScaleDb - postGainDb, kToleranceDb);
cleanUpMbcConfig();
diff --git a/automotive/vehicle/vts/Android.bp b/automotive/vehicle/vts/Android.bp
index 219119d..a9e2bf5 100644
--- a/automotive/vehicle/vts/Android.bp
+++ b/automotive/vehicle/vts/Android.bp
@@ -45,7 +45,7 @@
"vhalclient_defaults",
],
header_libs: [
- "IVehicleGeneratedHeaders-V4",
+ "IVehicleGeneratedHeaders",
],
test_suites: [
"general-tests",
diff --git a/automotive/vehicle/vts/src/VtsHalAutomotiveVehicle_TargetTest.cpp b/automotive/vehicle/vts/src/VtsHalAutomotiveVehicle_TargetTest.cpp
index 02a9830..c93de09 100644
--- a/automotive/vehicle/vts/src/VtsHalAutomotiveVehicle_TargetTest.cpp
+++ b/automotive/vehicle/vts/src/VtsHalAutomotiveVehicle_TargetTest.cpp
@@ -16,12 +16,16 @@
#define LOG_TAG "VtsHalAutomotiveVehicle"
+#include <AccessForVehicleProperty.h>
+#include <AnnotationsForVehicleProperty.h>
+#include <ChangeModeForVehicleProperty.h>
#include <IVhalClient.h>
#include <VehicleHalTypes.h>
#include <VehicleUtils.h>
#include <VersionForVehicleProperty.h>
#include <aidl/Gtest.h>
#include <aidl/Vintf.h>
+#include <aidl/android/hardware/automotive/vehicle/HasSupportedValueInfo.h>
#include <aidl/android/hardware/automotive/vehicle/IVehicle.h>
#include <android-base/stringprintf.h>
#include <android-base/thread_annotations.h>
@@ -42,9 +46,14 @@
#include <unordered_set>
#include <vector>
+using ::aidl::android::hardware::automotive::vehicle::AllowedAccessForVehicleProperty;
+using ::aidl::android::hardware::automotive::vehicle::AnnotationsForVehicleProperty;
+using ::aidl::android::hardware::automotive::vehicle::ChangeModeForVehicleProperty;
+using ::aidl::android::hardware::automotive::vehicle::HasSupportedValueInfo;
using ::aidl::android::hardware::automotive::vehicle::IVehicle;
using ::aidl::android::hardware::automotive::vehicle::StatusCode;
using ::aidl::android::hardware::automotive::vehicle::SubscribeOptions;
+using ::aidl::android::hardware::automotive::vehicle::toString;
using ::aidl::android::hardware::automotive::vehicle::VehicleArea;
using ::aidl::android::hardware::automotive::vehicle::VehicleProperty;
using ::aidl::android::hardware::automotive::vehicle::VehiclePropertyAccess;
@@ -76,12 +85,22 @@
constexpr int32_t kInvalidProp = 0x31600207;
// The timeout for retrying getting prop value after setting prop value.
constexpr int64_t kRetryGetPropAfterSetPropTimeoutMillis = 10'000;
+static constexpr char ANNOTATION_REQUIRE_MIN_MAX_VALUE[] = "require_min_max_supported_value";
+static constexpr char ANNOTATION_REQUIRE_SUPPORTED_VALUES[] = "require_supported_values_list";
+static constexpr char ANNOTATION_SUPPORTED_VALUES_IN_CONFIG[] = "legacy_supported_values_in_config";
+static constexpr char ANNOTATIONS_DATA_ENUM[] = "data_enum";
struct ServiceDescriptor {
std::string name;
bool isAidlService;
};
+struct PropertyConfigTestParam {
+ VehicleProperty propId;
+ std::vector<VehiclePropertyAccess> accessModes;
+ VehiclePropertyChangeMode changeMode;
+};
+
class VtsVehicleCallback final : public ISubscriptionCallback {
private:
std::mutex mLock;
@@ -145,34 +164,14 @@
}
};
-class VtsHalAutomotiveVehicleTargetTest : public testing::TestWithParam<ServiceDescriptor> {
- protected:
- bool checkIsSupported(int32_t propertyId);
-
- static bool isUnavailable(const VhalClientResult<std::unique_ptr<IHalPropValue>>& result);
- static bool isResultOkayWithValue(
- const VhalClientResult<std::unique_ptr<IHalPropValue>>& result, int32_t value);
-
+class VtsHalAutomotiveTest : public testing::Test {
public:
- void verifyAccessMode(int actualAccess, int expectedAccess);
+ void verifyAccessMode(int actualAccess, std::vector<VehiclePropertyAccess> expectedAccess);
void verifyGlobalAccessIsMaximalAreaAccessSubset(
int propertyLevelAccess,
const std::vector<std::unique_ptr<IHalAreaConfig>>& areaConfigs) const;
- void verifyProperty(VehicleProperty propId, VehiclePropertyAccess access,
- VehiclePropertyChangeMode changeMode, VehiclePropertyGroup group,
- VehicleArea area, VehiclePropertyType propertyType);
- virtual void SetUp() override {
- auto descriptor = GetParam();
- if (descriptor.isAidlService) {
- mVhalClient = IVhalClient::tryCreateAidlClient(descriptor.name.c_str());
- } else {
- mVhalClient = IVhalClient::tryCreateHidlClient(descriptor.name.c_str());
- }
-
- ASSERT_NE(mVhalClient, nullptr) << "Failed to connect to VHAL";
-
- mCallback = std::make_shared<VtsVehicleCallback>();
- }
+ void verifyProperty(VehicleProperty propId, std::vector<VehiclePropertyAccess> accessModes,
+ VehiclePropertyChangeMode changeMode);
static bool isBooleanGlobalProp(int32_t property) {
return (property & toInt(VehiclePropertyType::MASK)) ==
@@ -183,6 +182,118 @@
protected:
std::shared_ptr<IVhalClient> mVhalClient;
std::shared_ptr<VtsVehicleCallback> mCallback;
+
+ bool checkIsSupported(int32_t propertyId);
+ void connectToVhal(const ServiceDescriptor& descriptor);
+
+ static bool isUnavailable(const VhalClientResult<std::unique_ptr<IHalPropValue>>& result);
+ static bool isResultOkayWithValue(
+ const VhalClientResult<std::unique_ptr<IHalPropValue>>& result, int32_t value);
+};
+
+bool VtsHalAutomotiveTest::checkIsSupported(int32_t propertyId) {
+ auto result = mVhalClient->getPropConfigs({propertyId});
+ return result.ok();
+}
+
+void VtsHalAutomotiveTest::connectToVhal(const ServiceDescriptor& descriptor) {
+ if (descriptor.isAidlService) {
+ mVhalClient = IVhalClient::tryCreateAidlClient(descriptor.name.c_str());
+ } else {
+ mVhalClient = IVhalClient::tryCreateHidlClient(descriptor.name.c_str());
+ }
+
+ ASSERT_NE(mVhalClient, nullptr) << "Failed to connect to VHAL";
+
+ mCallback = std::make_shared<VtsVehicleCallback>();
+}
+
+bool VtsHalAutomotiveTest::isResultOkayWithValue(
+ const VhalClientResult<std::unique_ptr<IHalPropValue>>& result, int32_t value) {
+ return result.ok() && result.value() != nullptr &&
+ result.value()->getStatus() == VehiclePropertyStatus::AVAILABLE &&
+ result.value()->getInt32Values().size() == 1 &&
+ result.value()->getInt32Values()[0] == value;
+}
+
+bool VtsHalAutomotiveTest::isUnavailable(
+ const VhalClientResult<std::unique_ptr<IHalPropValue>>& result) {
+ if (!result.ok()) {
+ return result.error().code() == ErrorCode::NOT_AVAILABLE_FROM_VHAL;
+ }
+ if (result.value() != nullptr &&
+ result.value()->getStatus() == VehiclePropertyStatus::UNAVAILABLE) {
+ return true;
+ }
+
+ return false;
+}
+
+void VtsHalAutomotiveTest::verifyAccessMode(int actualAccess,
+ std::vector<VehiclePropertyAccess> expectedAccess) {
+ if (actualAccess == toInt(VehiclePropertyAccess::NONE)) {
+ return;
+ }
+ EXPECT_THAT(expectedAccess,
+ ::testing::Contains(static_cast<VehiclePropertyAccess>(actualAccess)))
+ << "Invalid property access mode, not one of the allowed access modes";
+}
+
+void VtsHalAutomotiveTest::verifyGlobalAccessIsMaximalAreaAccessSubset(
+ int propertyLevelAccess,
+ const std::vector<std::unique_ptr<IHalAreaConfig>>& areaConfigs) const {
+ bool readOnlyPresent = false;
+ bool writeOnlyPresent = false;
+ bool readWritePresent = false;
+ int maximalAreaAccessSubset = toInt(VehiclePropertyAccess::NONE);
+ for (size_t i = 0; i < areaConfigs.size(); i++) {
+ int access = areaConfigs[i]->getAccess();
+ switch (access) {
+ case toInt(VehiclePropertyAccess::READ):
+ readOnlyPresent = true;
+ break;
+ case toInt(VehiclePropertyAccess::WRITE):
+ writeOnlyPresent = true;
+ break;
+ case toInt(VehiclePropertyAccess::READ_WRITE):
+ readWritePresent = true;
+ break;
+ default:
+ ASSERT_EQ(access, toInt(VehiclePropertyAccess::NONE)) << StringPrintf(
+ "Area access can be NONE only if global property access is also NONE");
+ return;
+ }
+ }
+
+ if (readOnlyPresent) {
+ ASSERT_FALSE(writeOnlyPresent) << StringPrintf(
+ "Found both READ_ONLY and WRITE_ONLY access modes in area configs, which is not "
+ "supported");
+ maximalAreaAccessSubset = toInt(VehiclePropertyAccess::READ);
+ } else if (writeOnlyPresent) {
+ ASSERT_FALSE(readWritePresent) << StringPrintf(
+ "Found both WRITE_ONLY and READ_WRITE access modes in area configs, which is not "
+ "supported");
+ maximalAreaAccessSubset = toInt(VehiclePropertyAccess::WRITE);
+ } else if (readWritePresent) {
+ maximalAreaAccessSubset = toInt(VehiclePropertyAccess::READ_WRITE);
+ }
+ ASSERT_EQ(propertyLevelAccess, maximalAreaAccessSubset) << StringPrintf(
+ "Expected global access to be equal to maximal area access subset %d, Instead got %d",
+ maximalAreaAccessSubset, propertyLevelAccess);
+}
+
+class VtsHalAutomotiveVehicleTargetTest : public VtsHalAutomotiveTest,
+ public testing::WithParamInterface<ServiceDescriptor> {
+ virtual void SetUp() override { ASSERT_NO_FATAL_FAILURE(connectToVhal(GetParam())); }
+};
+
+class VtsHalAutomotivePropertyConfigTest
+ : public VtsHalAutomotiveTest,
+ public testing::WithParamInterface<std::tuple<PropertyConfigTestParam, ServiceDescriptor>> {
+ virtual void SetUp() override {
+ ASSERT_NO_FATAL_FAILURE(connectToVhal(std::get<1>(GetParam())));
+ }
};
TEST_P(VtsHalAutomotiveVehicleTargetTest, useAidlBackend) {
@@ -319,27 +430,6 @@
"Expect failure to get property for invalid prop: %" PRId32, kInvalidProp);
}
-bool VtsHalAutomotiveVehicleTargetTest::isResultOkayWithValue(
- const VhalClientResult<std::unique_ptr<IHalPropValue>>& result, int32_t value) {
- return result.ok() && result.value() != nullptr &&
- result.value()->getStatus() == VehiclePropertyStatus::AVAILABLE &&
- result.value()->getInt32Values().size() == 1 &&
- result.value()->getInt32Values()[0] == value;
-}
-
-bool VtsHalAutomotiveVehicleTargetTest::isUnavailable(
- const VhalClientResult<std::unique_ptr<IHalPropValue>>& result) {
- if (!result.ok()) {
- return result.error().code() == ErrorCode::NOT_AVAILABLE_FROM_VHAL;
- }
- if (result.value() != nullptr &&
- result.value()->getStatus() == VehiclePropertyStatus::UNAVAILABLE) {
- return true;
- }
-
- return false;
-}
-
// Test set() on read_write properties.
TEST_P(VtsHalAutomotiveVehicleTargetTest, setProp) {
ALOGD("VtsHalAutomotiveVehicleTargetTest::setProp");
@@ -711,77 +801,147 @@
}
}
-void VtsHalAutomotiveVehicleTargetTest::verifyAccessMode(int actualAccess, int expectedAccess) {
- if (actualAccess == toInt(VehiclePropertyAccess::NONE)) {
- return;
- }
- if (expectedAccess == toInt(VehiclePropertyAccess::READ_WRITE)) {
- ASSERT_TRUE(actualAccess == expectedAccess ||
- actualAccess == toInt(VehiclePropertyAccess::READ))
- << StringPrintf("Expect to get VehiclePropertyAccess: %i or %i, got %i",
- expectedAccess, toInt(VehiclePropertyAccess::READ), actualAccess);
- return;
- }
- ASSERT_EQ(actualAccess, expectedAccess) << StringPrintf(
- "Expect to get VehiclePropertyAccess: %i, got %i", expectedAccess, actualAccess);
-}
-
-void VtsHalAutomotiveVehicleTargetTest::verifyGlobalAccessIsMaximalAreaAccessSubset(
- int propertyLevelAccess,
- const std::vector<std::unique_ptr<IHalAreaConfig>>& areaConfigs) const {
- bool readOnlyPresent = false;
- bool writeOnlyPresent = false;
- bool readWritePresent = false;
- int maximalAreaAccessSubset = toInt(VehiclePropertyAccess::NONE);
- for (size_t i = 0; i < areaConfigs.size(); i++) {
- int access = areaConfigs[i]->getAccess();
- switch (access) {
- case toInt(VehiclePropertyAccess::READ):
- readOnlyPresent = true;
- break;
- case toInt(VehiclePropertyAccess::WRITE):
- writeOnlyPresent = true;
- break;
- case toInt(VehiclePropertyAccess::READ_WRITE):
- readWritePresent = true;
- break;
- default:
- ASSERT_EQ(access, toInt(VehiclePropertyAccess::NONE)) << StringPrintf(
- "Area access can be NONE only if global property access is also NONE");
- return;
+void verifyPropertyConfigMinMaxValue(const IHalPropConfig* config, int propertyType) {
+ for (const auto& areaConfig : config->getAreaConfigs()) {
+ std::optional<HasSupportedValueInfo> maybeHasSupportedValueInfo =
+ areaConfig->getHasSupportedValueInfo();
+ if (areaConfig->getMinInt32Value() != 0 || areaConfig->getMaxInt32Value() != 0) {
+ EXPECT_EQ(propertyType, toInt(VehiclePropertyType::INT32))
+ << "minInt32Value and maxInt32Value must not be specified for INT32 type "
+ "property";
+ EXPECT_THAT(areaConfig->getMinInt32Value(),
+ ::testing::Le(areaConfig->getMaxInt32Value()))
+ << "minInt32Value must be less or equal to maxInt32Value";
+ if (maybeHasSupportedValueInfo.has_value()) {
+ EXPECT_TRUE(maybeHasSupportedValueInfo->hasMinSupportedValue)
+ << "HasSupportedValueInfo.hasMinSupportedValue must be true because"
+ "minInt32Value is specified in VehicleAreaConfig";
+ EXPECT_TRUE(maybeHasSupportedValueInfo->hasMaxSupportedValue)
+ << "HasSupportedValueInfo.hasMaxSupportedValue must be true because"
+ "maxInt32Value is specified in VehicleAreaConfig";
+ }
+ }
+ if (areaConfig->getMinFloatValue() != 0 || areaConfig->getMaxFloatValue() != 0) {
+ EXPECT_EQ(propertyType, toInt(VehiclePropertyType::FLOAT))
+ << "minFloatValue and maxFloatValue must not be specified for FLOAT type "
+ "property";
+ EXPECT_THAT(areaConfig->getMinFloatValue(),
+ ::testing::Le(areaConfig->getMaxFloatValue()))
+ << "minFloatValue must be less or equal to maxFloatValue";
+ if (maybeHasSupportedValueInfo.has_value()) {
+ EXPECT_TRUE(maybeHasSupportedValueInfo->hasMinSupportedValue)
+ << "HasSupportedValueInfo.hasMinSupportedValue must be true because"
+ "minFloatValue is specified in VehicleAreaConfig";
+ EXPECT_TRUE(maybeHasSupportedValueInfo->hasMaxSupportedValue)
+ << "HasSupportedValueInfo.hasMaxSupportedValue must be true because"
+ "maxFloatValue is specified in VehicleAreaConfig";
+ }
+ }
+ if (areaConfig->getMinInt64Value() != 0 || areaConfig->getMaxInt64Value() != 0) {
+ EXPECT_EQ(propertyType, toInt(VehiclePropertyType::INT64))
+ << "minInt64Value and maxInt64Value must not be specified for INT64 type "
+ "property";
+ EXPECT_THAT(areaConfig->getMinInt64Value(),
+ ::testing::Le(areaConfig->getMaxInt64Value()))
+ << "minInt64Value must be less or equal to maxInt64Value";
+ if (maybeHasSupportedValueInfo.has_value()) {
+ EXPECT_TRUE(maybeHasSupportedValueInfo->hasMinSupportedValue)
+ << "HasSupportedValueInfo.hasMinSupportedValue must be true because"
+ "minInt64Value is specified in VehicleAreaConfig";
+ EXPECT_TRUE(maybeHasSupportedValueInfo->hasMaxSupportedValue)
+ << "HasSupportedValueInfo.hasMaxSupportedValue must be true because"
+ "maxInt64Value is specified in VehicleAreaConfig";
+ }
}
}
-
- if (readOnlyPresent) {
- ASSERT_FALSE(writeOnlyPresent) << StringPrintf(
- "Found both READ_ONLY and WRITE_ONLY access modes in area configs, which is not "
- "supported");
- maximalAreaAccessSubset = toInt(VehiclePropertyAccess::READ);
- } else if (writeOnlyPresent) {
- ASSERT_FALSE(readWritePresent) << StringPrintf(
- "Found both WRITE_ONLY and READ_WRITE access modes in area configs, which is not "
- "supported");
- maximalAreaAccessSubset = toInt(VehiclePropertyAccess::WRITE);
- } else if (readWritePresent) {
- maximalAreaAccessSubset = toInt(VehiclePropertyAccess::READ_WRITE);
- }
- ASSERT_EQ(propertyLevelAccess, maximalAreaAccessSubset) << StringPrintf(
- "Expected global access to be equal to maximal area access subset %d, Instead got %d",
- maximalAreaAccessSubset, propertyLevelAccess);
}
-// Helper function to compare actual vs expected property config
-void VtsHalAutomotiveVehicleTargetTest::verifyProperty(VehicleProperty propId,
- VehiclePropertyAccess access,
- VehiclePropertyChangeMode changeMode,
- VehiclePropertyGroup group, VehicleArea area,
- VehiclePropertyType propertyType) {
- int expectedPropId = toInt(propId);
- int expectedAccess = toInt(access);
- int expectedChangeMode = toInt(changeMode);
- int expectedGroup = toInt(group);
- int expectedArea = toInt(area);
- int expectedPropertyType = toInt(propertyType);
+void verifyPropertyConfigRequireMinMaxValue(const IHalPropConfig* config, int propertyType) {
+ for (const auto& areaConfig : config->getAreaConfigs()) {
+ switch (propertyType) {
+ case toInt(VehiclePropertyType::INT32):
+ EXPECT_FALSE(areaConfig->getMinInt32Value() == 0 &&
+ areaConfig->getMaxInt32Value() == 0)
+ << "minInt32Value and maxInt32Value must not both be 0 because "
+ "min and max value is required for this property";
+ break;
+ case toInt(VehiclePropertyType::FLOAT):
+ EXPECT_FALSE(areaConfig->getMinFloatValue() == 0 &&
+ areaConfig->getMaxFloatValue() == 0)
+ << "minFloatValue and maxFloatValue must not both be 0 because "
+ "min and max value is required for this property";
+ break;
+ case toInt(VehiclePropertyType::INT64):
+ EXPECT_FALSE(areaConfig->getMinInt64Value() == 0 &&
+ areaConfig->getMaxInt64Value() == 0)
+ << "minInt64Value and maxInt64Value must not both be 0 because "
+ "min and max value is required for this property";
+ break;
+ }
+
+ std::optional<HasSupportedValueInfo> maybeHasSupportedValueInfo =
+ areaConfig->getHasSupportedValueInfo();
+ if (maybeHasSupportedValueInfo.has_value()) {
+ EXPECT_TRUE(maybeHasSupportedValueInfo->hasMinSupportedValue)
+ << "HasSupportedValueInfo.hasMinSupportedValue must be true because"
+ "min and max value is required for this property";
+ EXPECT_TRUE(maybeHasSupportedValueInfo->hasMaxSupportedValue)
+ << "HasSupportedValueInfo.hasMaxSupportedValue must be true because"
+ "min and max value is required for this property";
+ }
+ }
+}
+
+void verifyPropertyConfigRequireSupportedValues(
+ const IHalPropConfig* config, const std::unordered_set<std::string>& annotations) {
+ bool supportedValuesInConfig =
+ (annotations.find(ANNOTATION_SUPPORTED_VALUES_IN_CONFIG) != annotations.end());
+ if (supportedValuesInConfig) {
+ const std::vector<int32_t>& configArray = config->getConfigArray();
+ EXPECT_THAT(configArray, Not(::testing::IsEmpty()))
+ << "Config array must not be empty because supported values list must be specified"
+ << " by the config array";
+ }
+
+ for (const auto& areaConfig : config->getAreaConfigs()) {
+ std::optional<HasSupportedValueInfo> maybeHasSupportedValueInfo =
+ areaConfig->getHasSupportedValueInfo();
+ if (maybeHasSupportedValueInfo.has_value()) {
+ EXPECT_TRUE(maybeHasSupportedValueInfo->hasSupportedValuesList)
+ << "HasSupportedValueInfo.hasSupportedValuesList must be true because"
+ "supported values list is required for this property";
+ }
+ }
+}
+
+void verifyPropertyConfigDataEnum(const IHalPropConfig* config) {
+ for (const auto& areaConfig : config->getAreaConfigs()) {
+ std::optional<std::vector<int64_t>> maybeSupportedEnumValues =
+ areaConfig->getSupportedEnumValues();
+ if (!maybeSupportedEnumValues.has_value()) {
+ continue;
+ }
+ std::optional<HasSupportedValueInfo> maybeHasSupportedValueInfo =
+ areaConfig->getHasSupportedValueInfo();
+ const std::vector<int64_t>& supportedEnumValues = *maybeSupportedEnumValues;
+ if (!supportedEnumValues.empty() && maybeHasSupportedValueInfo.has_value()) {
+ EXPECT_TRUE(maybeHasSupportedValueInfo->hasSupportedValuesList)
+ << "HasSupportedValueInfo.hasSupportedValuesList must be true because"
+ "supported enum values is not empty";
+ }
+
+ // TODO(b/381123190): Verify the supported enum values are within the defined enum type.
+ }
+}
+
+/**
+ * Verifies that each property's property config is consistent with the requirement
+ * documented in VehicleProperty.aidl.
+ */
+TEST_P(VtsHalAutomotivePropertyConfigTest, verifyPropertyConfig) {
+ const PropertyConfigTestParam& param = std::get<0>(GetParam());
+ int expectedPropId = toInt(param.propId);
+ int expectedChangeMode = toInt(param.changeMode);
auto result = mVhalClient->getAllPropConfigs();
ASSERT_TRUE(result.ok()) << "Failed to get all property configs, error: "
@@ -813,650 +973,44 @@
const auto& config = result.value().at(0);
int actualPropId = config->getPropId();
int actualChangeMode = config->getChangeMode();
- int actualGroup = actualPropId & toInt(VehiclePropertyGroup::MASK);
- int actualArea = actualPropId & toInt(VehicleArea::MASK);
- int actualPropertyType = actualPropId & toInt(VehiclePropertyType::MASK);
ASSERT_EQ(actualPropId, expectedPropId)
<< StringPrintf("Expect to get property ID: %i, got %i", expectedPropId, actualPropId);
int globalAccess = config->getAccess();
if (config->getAreaConfigSize() == 0) {
- verifyAccessMode(globalAccess, expectedAccess);
+ verifyAccessMode(globalAccess, param.accessModes);
} else {
for (const auto& areaConfig : config->getAreaConfigs()) {
int areaConfigAccess = areaConfig->getAccess();
int actualAccess = (areaConfigAccess != toInt(VehiclePropertyAccess::NONE))
? areaConfigAccess
: globalAccess;
- verifyAccessMode(actualAccess, expectedAccess);
+ verifyAccessMode(actualAccess, param.accessModes);
}
}
- ASSERT_EQ(actualChangeMode, expectedChangeMode)
+ EXPECT_EQ(actualChangeMode, expectedChangeMode)
<< StringPrintf("Expect to get VehiclePropertyChangeMode: %i, got %i",
expectedChangeMode, actualChangeMode);
- ASSERT_EQ(actualGroup, expectedGroup) << StringPrintf(
- "Expect to get VehiclePropertyGroup: %i, got %i", expectedGroup, actualGroup);
- ASSERT_EQ(actualArea, expectedArea)
- << StringPrintf("Expect to get VehicleArea: %i, got %i", expectedArea, actualArea);
- ASSERT_EQ(actualPropertyType, expectedPropertyType)
- << StringPrintf("Expect to get VehiclePropertyType: %i, got %i", expectedPropertyType,
- actualPropertyType);
-}
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyLocationCharacterizationConfig) {
- verifyProperty(VehicleProperty::LOCATION_CHARACTERIZATION, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::STATIC, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
+ std::unordered_set<std::string> annotations;
+ auto it = AnnotationsForVehicleProperty.find(param.propId);
+ if (it != AnnotationsForVehicleProperty.end()) {
+ annotations = it->second;
+ }
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyUltrasonicsSensorPositionConfig) {
- verifyProperty(VehicleProperty::ULTRASONICS_SENSOR_POSITION, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::STATIC, VehiclePropertyGroup::SYSTEM,
- VehicleArea::VENDOR, VehiclePropertyType::INT32_VEC);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyUltrasonicsSensorOrientationConfig) {
- verifyProperty(VehicleProperty::ULTRASONICS_SENSOR_ORIENTATION, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::STATIC, VehiclePropertyGroup::SYSTEM,
- VehicleArea::VENDOR, VehiclePropertyType::FLOAT_VEC);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyUltrasonicsSensorFieldOfViewConfig) {
- verifyProperty(VehicleProperty::ULTRASONICS_SENSOR_FIELD_OF_VIEW, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::STATIC, VehiclePropertyGroup::SYSTEM,
- VehicleArea::VENDOR, VehiclePropertyType::INT32_VEC);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyUltrasonicsSensorDetectionRangeConfig) {
- verifyProperty(VehicleProperty::ULTRASONICS_SENSOR_DETECTION_RANGE, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::STATIC, VehiclePropertyGroup::SYSTEM,
- VehicleArea::VENDOR, VehiclePropertyType::INT32_VEC);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyUltrasonicsSensorSupportedRangesConfig) {
- verifyProperty(VehicleProperty::ULTRASONICS_SENSOR_SUPPORTED_RANGES,
- VehiclePropertyAccess::READ, VehiclePropertyChangeMode::STATIC,
- VehiclePropertyGroup::SYSTEM, VehicleArea::VENDOR,
- VehiclePropertyType::INT32_VEC);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyUltrasonicsSensorMeasuredDistanceConfig) {
- verifyProperty(VehicleProperty::ULTRASONICS_SENSOR_MEASURED_DISTANCE,
- VehiclePropertyAccess::READ, VehiclePropertyChangeMode::CONTINUOUS,
- VehiclePropertyGroup::SYSTEM, VehicleArea::VENDOR,
- VehiclePropertyType::INT32_VEC);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyEmergencyLaneKeepAssistEnabledConfig) {
- verifyProperty(VehicleProperty::EMERGENCY_LANE_KEEP_ASSIST_ENABLED,
- VehiclePropertyAccess::READ_WRITE, VehiclePropertyChangeMode::ON_CHANGE,
- VehiclePropertyGroup::SYSTEM, VehicleArea::GLOBAL, VehiclePropertyType::BOOLEAN);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyEmergencyLaneKeepAssistStateConfig) {
- verifyProperty(VehicleProperty::EMERGENCY_LANE_KEEP_ASSIST_STATE, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyCruiseControlEnabledConfig) {
- verifyProperty(VehicleProperty::CRUISE_CONTROL_ENABLED, VehiclePropertyAccess::READ_WRITE,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::BOOLEAN);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyCruiseControlTypeConfig) {
- verifyProperty(VehicleProperty::CRUISE_CONTROL_TYPE, VehiclePropertyAccess::READ_WRITE,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyCruiseControlStateConfig) {
- verifyProperty(VehicleProperty::CRUISE_CONTROL_STATE, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyCruiseControlCommandConfig) {
- verifyProperty(VehicleProperty::CRUISE_CONTROL_COMMAND, VehiclePropertyAccess::WRITE,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyCruiseControlTargetSpeedConfig) {
- verifyProperty(VehicleProperty::CRUISE_CONTROL_TARGET_SPEED, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::FLOAT);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyAdaptiveCruiseControlTargetTimeGapConfig) {
- verifyProperty(VehicleProperty::ADAPTIVE_CRUISE_CONTROL_TARGET_TIME_GAP,
- VehiclePropertyAccess::READ_WRITE, VehiclePropertyChangeMode::ON_CHANGE,
- VehiclePropertyGroup::SYSTEM, VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest,
- verifyAdaptiveCruiseControlLeadVehicleMeasuredDistanceConfig) {
- verifyProperty(VehicleProperty::ADAPTIVE_CRUISE_CONTROL_LEAD_VEHICLE_MEASURED_DISTANCE,
- VehiclePropertyAccess::READ, VehiclePropertyChangeMode::CONTINUOUS,
- VehiclePropertyGroup::SYSTEM, VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyHandsOnDetectionEnabledConfig) {
- verifyProperty(VehicleProperty::HANDS_ON_DETECTION_ENABLED, VehiclePropertyAccess::READ_WRITE,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::BOOLEAN);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyHandsOnDetectionDriverStateConfig) {
- verifyProperty(VehicleProperty::HANDS_ON_DETECTION_DRIVER_STATE, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyHandsOnDetectionWarningConfig) {
- verifyProperty(VehicleProperty::HANDS_ON_DETECTION_WARNING, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyDriverDrowsinessAttentionSystemEnabledConfig) {
- verifyProperty(VehicleProperty::DRIVER_DROWSINESS_ATTENTION_SYSTEM_ENABLED,
- VehiclePropertyAccess::READ_WRITE, VehiclePropertyChangeMode::ON_CHANGE,
- VehiclePropertyGroup::SYSTEM, VehicleArea::GLOBAL, VehiclePropertyType::BOOLEAN);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyDriverDrowsinessAttentionStateConfig) {
- verifyProperty(VehicleProperty::DRIVER_DROWSINESS_ATTENTION_STATE, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyDriverDrowsinessAttentionWarningEnabledConfig) {
- verifyProperty(VehicleProperty::DRIVER_DROWSINESS_ATTENTION_WARNING_ENABLED,
- VehiclePropertyAccess::READ_WRITE, VehiclePropertyChangeMode::ON_CHANGE,
- VehiclePropertyGroup::SYSTEM, VehicleArea::GLOBAL, VehiclePropertyType::BOOLEAN);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyDriverDrowsinessAttentionWarningConfig) {
- verifyProperty(VehicleProperty::DRIVER_DROWSINESS_ATTENTION_WARNING,
- VehiclePropertyAccess::READ, VehiclePropertyChangeMode::ON_CHANGE,
- VehiclePropertyGroup::SYSTEM, VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyDriverDistractionSystemEnabledConfig) {
- verifyProperty(VehicleProperty::DRIVER_DISTRACTION_SYSTEM_ENABLED,
- VehiclePropertyAccess::READ_WRITE, VehiclePropertyChangeMode::ON_CHANGE,
- VehiclePropertyGroup::SYSTEM, VehicleArea::GLOBAL, VehiclePropertyType::BOOLEAN);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyDriverDistractionStateConfig) {
- verifyProperty(VehicleProperty::DRIVER_DISTRACTION_STATE, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyDriverDistractionWarningEnabledConfig) {
- verifyProperty(VehicleProperty::DRIVER_DISTRACTION_WARNING_ENABLED,
- VehiclePropertyAccess::READ_WRITE, VehiclePropertyChangeMode::ON_CHANGE,
- VehiclePropertyGroup::SYSTEM, VehicleArea::GLOBAL, VehiclePropertyType::BOOLEAN);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyDriverDistractionWarningConfig) {
- verifyProperty(VehicleProperty::DRIVER_DISTRACTION_WARNING, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyEvBrakeRegenerationLevelConfig) {
- verifyProperty(VehicleProperty::EV_BRAKE_REGENERATION_LEVEL,
- VehiclePropertyAccess::READ_WRITE, VehiclePropertyChangeMode::ON_CHANGE,
- VehiclePropertyGroup::SYSTEM, VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyEvStoppingModeConfig) {
- verifyProperty(VehicleProperty::EV_STOPPING_MODE, VehiclePropertyAccess::READ_WRITE,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyEvCurrentBatteryCapacityConfig) {
- verifyProperty(VehicleProperty::EV_CURRENT_BATTERY_CAPACITY, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::FLOAT);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyEngineIdleAutoStopEnabledConfig) {
- verifyProperty(VehicleProperty::ENGINE_IDLE_AUTO_STOP_ENABLED,
- VehiclePropertyAccess::READ_WRITE, VehiclePropertyChangeMode::ON_CHANGE,
- VehiclePropertyGroup::SYSTEM, VehicleArea::GLOBAL, VehiclePropertyType::BOOLEAN);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyDoorChildLockEnabledConfig) {
- verifyProperty(VehicleProperty::DOOR_CHILD_LOCK_ENABLED, VehiclePropertyAccess::READ_WRITE,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::DOOR, VehiclePropertyType::BOOLEAN);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyWindshieldWipersPeriodConfig) {
- verifyProperty(VehicleProperty::WINDSHIELD_WIPERS_PERIOD, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::WINDOW, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyWindshieldWipersStateConfig) {
- verifyProperty(VehicleProperty::WINDSHIELD_WIPERS_STATE, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::WINDOW, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyWindshieldWipersSwitchConfig) {
- verifyProperty(VehicleProperty::WINDSHIELD_WIPERS_SWITCH, VehiclePropertyAccess::READ_WRITE,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::WINDOW, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifySteeringWheelDepthPosConfig) {
- verifyProperty(VehicleProperty::STEERING_WHEEL_DEPTH_POS, VehiclePropertyAccess::READ_WRITE,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifySteeringWheelDepthMoveConfig) {
- verifyProperty(VehicleProperty::STEERING_WHEEL_DEPTH_MOVE, VehiclePropertyAccess::READ_WRITE,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifySteeringWheelHeightPosConfig) {
- verifyProperty(VehicleProperty::STEERING_WHEEL_HEIGHT_POS, VehiclePropertyAccess::READ_WRITE,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifySteeringWheelHeightMoveConfig) {
- verifyProperty(VehicleProperty::STEERING_WHEEL_HEIGHT_MOVE, VehiclePropertyAccess::READ_WRITE,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifySteeringWheelTheftLockEnabledConfig) {
- verifyProperty(VehicleProperty::STEERING_WHEEL_THEFT_LOCK_ENABLED,
- VehiclePropertyAccess::READ_WRITE, VehiclePropertyChangeMode::ON_CHANGE,
- VehiclePropertyGroup::SYSTEM, VehicleArea::GLOBAL, VehiclePropertyType::BOOLEAN);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifySteeringWheelLockedConfig) {
- verifyProperty(VehicleProperty::STEERING_WHEEL_LOCKED, VehiclePropertyAccess::READ_WRITE,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::BOOLEAN);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifySteeringWheelEasyAccessEnabledConfig) {
- verifyProperty(VehicleProperty::STEERING_WHEEL_EASY_ACCESS_ENABLED,
- VehiclePropertyAccess::READ_WRITE, VehiclePropertyChangeMode::ON_CHANGE,
- VehiclePropertyGroup::SYSTEM, VehicleArea::GLOBAL, VehiclePropertyType::BOOLEAN);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifySteeringWheelLightsStateConfig) {
- verifyProperty(VehicleProperty::STEERING_WHEEL_LIGHTS_STATE, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifySteeringWheelLightsSwitchConfig) {
- verifyProperty(VehicleProperty::STEERING_WHEEL_LIGHTS_SWITCH, VehiclePropertyAccess::READ_WRITE,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyGloveBoxDoorPosConfig) {
- verifyProperty(VehicleProperty::GLOVE_BOX_DOOR_POS, VehiclePropertyAccess::READ_WRITE,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::SEAT, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyGloveBoxLockedConfig) {
- verifyProperty(VehicleProperty::GLOVE_BOX_LOCKED, VehiclePropertyAccess::READ_WRITE,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::SEAT, VehiclePropertyType::BOOLEAN);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyMirrorAutoFoldEnabledConfig) {
- verifyProperty(VehicleProperty::MIRROR_AUTO_FOLD_ENABLED, VehiclePropertyAccess::READ_WRITE,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::MIRROR, VehiclePropertyType::BOOLEAN);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyMirrorAutoTiltEnabledConfig) {
- verifyProperty(VehicleProperty::MIRROR_AUTO_TILT_ENABLED, VehiclePropertyAccess::READ_WRITE,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::MIRROR, VehiclePropertyType::BOOLEAN);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifySeatHeadrestHeightPosV2Config) {
- verifyProperty(VehicleProperty::SEAT_HEADREST_HEIGHT_POS_V2, VehiclePropertyAccess::READ_WRITE,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::SEAT, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifySeatWalkInPosConfig) {
- verifyProperty(VehicleProperty::SEAT_WALK_IN_POS, VehiclePropertyAccess::READ_WRITE,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::SEAT, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifySeatFootwellLightsStateConfig) {
- verifyProperty(VehicleProperty::SEAT_FOOTWELL_LIGHTS_STATE, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::SEAT, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifySeatFootwellLightsSwitchConfig) {
- verifyProperty(VehicleProperty::SEAT_FOOTWELL_LIGHTS_SWITCH, VehiclePropertyAccess::READ_WRITE,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::SEAT, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifySeatEasyAccessEnabledConfig) {
- verifyProperty(VehicleProperty::SEAT_EASY_ACCESS_ENABLED, VehiclePropertyAccess::READ_WRITE,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::SEAT, VehiclePropertyType::BOOLEAN);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifySeatAirbagEnabledConfig) {
- verifyProperty(VehicleProperty::SEAT_AIRBAG_ENABLED, VehiclePropertyAccess::READ_WRITE,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::SEAT, VehiclePropertyType::BOOLEAN);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifySeatCushionSideSupportPosConfig) {
- verifyProperty(VehicleProperty::SEAT_CUSHION_SIDE_SUPPORT_POS,
- VehiclePropertyAccess::READ_WRITE, VehiclePropertyChangeMode::ON_CHANGE,
- VehiclePropertyGroup::SYSTEM, VehicleArea::SEAT, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifySeatCushionSideSupportMoveConfig) {
- verifyProperty(VehicleProperty::SEAT_CUSHION_SIDE_SUPPORT_MOVE,
- VehiclePropertyAccess::READ_WRITE, VehiclePropertyChangeMode::ON_CHANGE,
- VehiclePropertyGroup::SYSTEM, VehicleArea::SEAT, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifySeatLumbarVerticalPosConfig) {
- verifyProperty(VehicleProperty::SEAT_LUMBAR_VERTICAL_POS, VehiclePropertyAccess::READ_WRITE,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::SEAT, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifySeatLumbarVerticalMoveConfig) {
- verifyProperty(VehicleProperty::SEAT_LUMBAR_VERTICAL_MOVE, VehiclePropertyAccess::READ_WRITE,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::SEAT, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyAutomaticEmergencyBrakingEnabledConfig) {
- verifyProperty(VehicleProperty::AUTOMATIC_EMERGENCY_BRAKING_ENABLED,
- VehiclePropertyAccess::READ_WRITE, VehiclePropertyChangeMode::ON_CHANGE,
- VehiclePropertyGroup::SYSTEM, VehicleArea::GLOBAL, VehiclePropertyType::BOOLEAN);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyAutomaticEmergencyBrakingStateConfig) {
- verifyProperty(VehicleProperty::AUTOMATIC_EMERGENCY_BRAKING_STATE, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyForwardCollisionWarningEnabledConfig) {
- verifyProperty(VehicleProperty::FORWARD_COLLISION_WARNING_ENABLED,
- VehiclePropertyAccess::READ_WRITE, VehiclePropertyChangeMode::ON_CHANGE,
- VehiclePropertyGroup::SYSTEM, VehicleArea::GLOBAL, VehiclePropertyType::BOOLEAN);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyForwardCollisionWarningStateConfig) {
- verifyProperty(VehicleProperty::FORWARD_COLLISION_WARNING_STATE, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyBlindSpotWarningEnabledConfig) {
- verifyProperty(VehicleProperty::BLIND_SPOT_WARNING_ENABLED, VehiclePropertyAccess::READ_WRITE,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::BOOLEAN);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyBlindSpotWarningStateConfig) {
- verifyProperty(VehicleProperty::BLIND_SPOT_WARNING_STATE, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::MIRROR, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyLaneDepartureWarningEnabledConfig) {
- verifyProperty(VehicleProperty::LANE_DEPARTURE_WARNING_ENABLED,
- VehiclePropertyAccess::READ_WRITE, VehiclePropertyChangeMode::ON_CHANGE,
- VehiclePropertyGroup::SYSTEM, VehicleArea::GLOBAL, VehiclePropertyType::BOOLEAN);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyLaneDepartureWarningStateConfig) {
- verifyProperty(VehicleProperty::LANE_DEPARTURE_WARNING_STATE, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyLaneKeepAssistEnabledConfig) {
- verifyProperty(VehicleProperty::LANE_KEEP_ASSIST_ENABLED, VehiclePropertyAccess::READ_WRITE,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::BOOLEAN);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyLaneKeepAssistStateConfig) {
- verifyProperty(VehicleProperty::LANE_KEEP_ASSIST_STATE, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyLaneCenteringAssistEnabledConfig) {
- verifyProperty(VehicleProperty::LANE_CENTERING_ASSIST_ENABLED,
- VehiclePropertyAccess::READ_WRITE, VehiclePropertyChangeMode::ON_CHANGE,
- VehiclePropertyGroup::SYSTEM, VehicleArea::GLOBAL, VehiclePropertyType::BOOLEAN);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyLaneCenteringAssistCommandConfig) {
- verifyProperty(VehicleProperty::LANE_CENTERING_ASSIST_COMMAND, VehiclePropertyAccess::WRITE,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyLaneCenteringAssistStateConfig) {
- verifyProperty(VehicleProperty::LANE_CENTERING_ASSIST_STATE, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyClusterHeartbeatConfig) {
- verifyProperty(VehicleProperty::CLUSTER_HEARTBEAT, VehiclePropertyAccess::WRITE,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::MIXED);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyVehicleDrivingAutomationCurrentLevelConfig) {
- verifyProperty(VehicleProperty::VEHICLE_DRIVING_AUTOMATION_CURRENT_LEVEL,
- VehiclePropertyAccess::READ, VehiclePropertyChangeMode::ON_CHANGE,
- VehiclePropertyGroup::SYSTEM, VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyCameraServiceCurrentStateConfig) {
- verifyProperty(VehicleProperty::CAMERA_SERVICE_CURRENT_STATE, VehiclePropertyAccess::WRITE,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::INT32_VEC);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifySeatAirbagsDeployedConfig) {
- verifyProperty(VehicleProperty::SEAT_AIRBAGS_DEPLOYED, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::SEAT, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifySeatBeltPretensionerDeployedConfig) {
- verifyProperty(VehicleProperty::SEAT_BELT_PRETENSIONER_DEPLOYED, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::SEAT, VehiclePropertyType::BOOLEAN);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyImpactDetectedConfig) {
- verifyProperty(VehicleProperty::IMPACT_DETECTED, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyEvBatteryAverageTemperatureConfig) {
- verifyProperty(VehicleProperty::EV_BATTERY_AVERAGE_TEMPERATURE, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::CONTINUOUS, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::FLOAT);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyLowSpeedCollisionWarningEnabledConfig) {
- verifyProperty(VehicleProperty::LOW_SPEED_COLLISION_WARNING_ENABLED,
- VehiclePropertyAccess::READ_WRITE, VehiclePropertyChangeMode::ON_CHANGE,
- VehiclePropertyGroup::SYSTEM, VehicleArea::GLOBAL, VehiclePropertyType::BOOLEAN);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyLowSpeedCollisionWarningStateConfig) {
- verifyProperty(VehicleProperty::LOW_SPEED_COLLISION_WARNING_STATE, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyValetModeEnabledConfig) {
- verifyProperty(VehicleProperty::VALET_MODE_ENABLED, VehiclePropertyAccess::READ_WRITE,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::BOOLEAN);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyElectronicStabilityControlEnabledConfig) {
- verifyProperty(VehicleProperty::ELECTRONIC_STABILITY_CONTROL_ENABLED,
- VehiclePropertyAccess::READ_WRITE, VehiclePropertyChangeMode::ON_CHANGE,
- VehiclePropertyGroup::SYSTEM, VehicleArea::GLOBAL, VehiclePropertyType::BOOLEAN);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyElectronicStabilityControlStateConfig) {
- verifyProperty(VehicleProperty::ELECTRONIC_STABILITY_CONTROL_STATE, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyCrossTrafficMonitoringEnabledConfig) {
- verifyProperty(VehicleProperty::CROSS_TRAFFIC_MONITORING_ENABLED,
- VehiclePropertyAccess::READ_WRITE, VehiclePropertyChangeMode::ON_CHANGE,
- VehiclePropertyGroup::SYSTEM, VehicleArea::GLOBAL, VehiclePropertyType::BOOLEAN);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyCrossTrafficMonitoringWarningStateConfig) {
- verifyProperty(VehicleProperty::CROSS_TRAFFIC_MONITORING_WARNING_STATE,
- VehiclePropertyAccess::READ, VehiclePropertyChangeMode::ON_CHANGE,
- VehiclePropertyGroup::SYSTEM, VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyHeadUpDisplayEnabledConfig) {
- verifyProperty(VehicleProperty::HEAD_UP_DISPLAY_ENABLED, VehiclePropertyAccess::READ_WRITE,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::SEAT, VehiclePropertyType::BOOLEAN);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyLowSpeedAutomaticEmergencyBrakingEnabledConfig) {
- verifyProperty(VehicleProperty::LOW_SPEED_AUTOMATIC_EMERGENCY_BRAKING_ENABLED,
- VehiclePropertyAccess::READ_WRITE, VehiclePropertyChangeMode::ON_CHANGE,
- VehiclePropertyGroup::SYSTEM, VehicleArea::GLOBAL, VehiclePropertyType::BOOLEAN);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyLowSpeedAutomaticEmergencyBrakingStateConfig) {
- verifyProperty(VehicleProperty::LOW_SPEED_AUTOMATIC_EMERGENCY_BRAKING_STATE,
- VehiclePropertyAccess::READ, VehiclePropertyChangeMode::ON_CHANGE,
- VehiclePropertyGroup::SYSTEM, VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyInfoModelTrimConfig) {
- verifyProperty(VehicleProperty::INFO_MODEL_TRIM, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::STATIC, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::STRING);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyInfoVehicleSizeClassConfig) {
- verifyProperty(VehicleProperty::INFO_VEHICLE_SIZE_CLASS, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::STATIC, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::INT32_VEC);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyTurnSignalLightStateConfig) {
- verifyProperty(VehicleProperty::TURN_SIGNAL_LIGHT_STATE, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyTurnSignalSwitchConfig) {
- verifyProperty(VehicleProperty::TURN_SIGNAL_SWITCH, VehiclePropertyAccess::READ_WRITE,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyInstantaneousFuelEconomyConfig) {
- verifyProperty(VehicleProperty::INSTANTANEOUS_FUEL_ECONOMY, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::CONTINUOUS, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::FLOAT);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyInstantaneousEvEfficiencyConfig) {
- verifyProperty(VehicleProperty::INSTANTANEOUS_EV_EFFICIENCY, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::CONTINUOUS, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::FLOAT);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyVehicleHornEngagedConfig) {
- verifyProperty(VehicleProperty::VEHICLE_HORN_ENGAGED, VehiclePropertyAccess::READ_WRITE,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::BOOLEAN);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyVehicleDrivingAutomationTargetLevelConfig) {
- verifyProperty(VehicleProperty::VEHICLE_DRIVING_AUTOMATION_TARGET_LEVEL,
- VehiclePropertyAccess::READ, VehiclePropertyChangeMode::ON_CHANGE,
- VehiclePropertyGroup::SYSTEM, VehicleArea::GLOBAL, VehiclePropertyType::INT32);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyAcceleratorPedalCompressionPercentageConfig) {
- verifyProperty(VehicleProperty::ACCELERATOR_PEDAL_COMPRESSION_PERCENTAGE,
- VehiclePropertyAccess::READ, VehiclePropertyChangeMode::CONTINUOUS,
- VehiclePropertyGroup::SYSTEM, VehicleArea::GLOBAL, VehiclePropertyType::FLOAT);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyBrakePedalCompressionPercentageConfig) {
- verifyProperty(VehicleProperty::BRAKE_PEDAL_COMPRESSION_PERCENTAGE, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::CONTINUOUS, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::FLOAT);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyBrakePadWearPercentageConfig) {
- verifyProperty(VehicleProperty::BRAKE_PAD_WEAR_PERCENTAGE, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::WHEEL, VehiclePropertyType::FLOAT);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyBrakeFluidLevelLowConfig) {
- verifyProperty(VehicleProperty::BRAKE_FLUID_LEVEL_LOW, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::ON_CHANGE, VehiclePropertyGroup::SYSTEM,
- VehicleArea::GLOBAL, VehiclePropertyType::BOOLEAN);
-}
-
-TEST_P(VtsHalAutomotiveVehicleTargetTest, verifyVehiclePassiveSuspensionHeightConfig) {
- verifyProperty(VehicleProperty::VEHICLE_PASSIVE_SUSPENSION_HEIGHT, VehiclePropertyAccess::READ,
- VehiclePropertyChangeMode::CONTINUOUS, VehiclePropertyGroup::SYSTEM,
- VehicleArea::WHEEL, VehiclePropertyType::INT32);
-}
-
-bool VtsHalAutomotiveVehicleTargetTest::checkIsSupported(int32_t propertyId) {
- auto result = mVhalClient->getPropConfigs({propertyId});
- return result.ok();
+ int propertyType = expectedPropId & toInt(VehiclePropertyType::MASK);
+ verifyPropertyConfigMinMaxValue(config.get(), propertyType);
+ if (annotations.find(ANNOTATION_REQUIRE_MIN_MAX_VALUE) != annotations.end()) {
+ verifyPropertyConfigRequireMinMaxValue(config.get(), propertyType);
+ }
+ if (annotations.find(ANNOTATION_REQUIRE_SUPPORTED_VALUES) != annotations.end()) {
+ verifyPropertyConfigRequireSupportedValues(config.get(), annotations);
+ }
+ if (annotations.find(ANNOTATIONS_DATA_ENUM) != annotations.end()) {
+ verifyPropertyConfigDataEnum(config.get());
+ }
}
std::vector<ServiceDescriptor> getDescriptors() {
@@ -1477,6 +1031,18 @@
return descriptors;
}
+std::vector<PropertyConfigTestParam> getPropertyConfigTestParams() {
+ std::vector<PropertyConfigTestParam> testParams;
+ for (const auto& [propId, accessModes] : AllowedAccessForVehicleProperty) {
+ PropertyConfigTestParam param;
+ param.propId = propId;
+ param.accessModes = accessModes;
+ param.changeMode = ChangeModeForVehicleProperty[propId];
+ testParams.push_back(param);
+ }
+ return testParams;
+}
+
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(VtsHalAutomotiveVehicleTargetTest);
INSTANTIATE_TEST_SUITE_P(PerInstance, VtsHalAutomotiveVehicleTargetTest,
@@ -1492,6 +1058,22 @@
return Sanitize(name);
});
+INSTANTIATE_TEST_SUITE_P(PerInstance, VtsHalAutomotivePropertyConfigTest,
+ testing::Combine(testing::ValuesIn(getPropertyConfigTestParams()),
+ testing::ValuesIn(getDescriptors())),
+ [](const testing::TestParamInfo<
+ std::tuple<PropertyConfigTestParam, ServiceDescriptor>>& info) {
+ std::string name = "";
+ if (std::get<1>(info.param).isAidlService) {
+ name += "aidl_";
+ } else {
+ name += "hidl_";
+ }
+ name += std::get<1>(info.param).name;
+ name += "_" + toString(std::get<0>(info.param).propId);
+ return Sanitize(name);
+ });
+
int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv);
ABinderProcess_setThreadPoolMaxThreadCount(1);
diff --git a/biometrics/face/aidl/vts/VtsHalBiometricsFaceTargetTest.cpp b/biometrics/face/aidl/vts/VtsHalBiometricsFaceTargetTest.cpp
index 686f61e..9ab141a 100644
--- a/biometrics/face/aidl/vts/VtsHalBiometricsFaceTargetTest.cpp
+++ b/biometrics/face/aidl/vts/VtsHalBiometricsFaceTargetTest.cpp
@@ -157,6 +157,11 @@
};
class Face : public testing::TestWithParam<std::string> {
+ static void HalServiceDied(void* cookie) {
+ auto halDeathPromise = static_cast<std::promise<void>*>(cookie);
+ halDeathPromise->set_value();
+ }
+
protected:
void SetUp() override {
// Prepare the callback.
@@ -176,8 +181,23 @@
ASSERT_NE(binder, nullptr);
mHal = IFace::fromBinder(ndk::SpAIBinder(binder));
+ // Create HAL service death notifier
+ auto halDeathPromise = std::make_shared<std::promise<void>>();
+ mHalDeathRecipient = ndk::ScopedAIBinder_DeathRecipient(
+ AIBinder_DeathRecipient_new(&HalServiceDied));
+ ASSERT_EQ(STATUS_OK, AIBinder_linkToDeath(binder, mHalDeathRecipient.get(),
+ static_cast<void*>(halDeathPromise.get())));
+
// Create a session.
isOk = mHal->createSession(kSensorId, kUserId, mCb, &mSession).isOk();
+ if (!isOk) {
+ // Failed to create session on first attempt, it is likely that the HAL service
+ // is dying or dead. Wait for its death notification signal before next try
+ auto future = halDeathPromise->get_future();
+ auto status = future.wait_for(std::chrono::milliseconds(500));
+ EXPECT_EQ(status, std::future_status::ready);
+ }
+
++retries;
} while (!isOk && retries < 2);
@@ -197,6 +217,7 @@
std::shared_ptr<IFace> mHal;
std::shared_ptr<SessionCallback> mCb;
std::shared_ptr<ISession> mSession;
+ ::ndk::ScopedAIBinder_DeathRecipient mHalDeathRecipient;
};
TEST_P(Face, GetSensorPropsWorksTest) {
diff --git a/biometrics/fingerprint/aidl/default/main.cpp b/biometrics/fingerprint/aidl/default/main.cpp
index 8ca44d6..bf3f38e 100644
--- a/biometrics/fingerprint/aidl/default/main.cpp
+++ b/biometrics/fingerprint/aidl/default/main.cpp
@@ -39,8 +39,6 @@
if (strcmp(argv[1], "default") == 0) {
const std::string instance = std::string(Fingerprint::descriptor) + "/default";
auto binder = hal->asBinder();
- auto binder_ext = hal_vhal->asBinder();
- CHECK(STATUS_OK == AIBinder_setExtension(binder.get(), binder_ext.get()));
binder_status_t status =
AServiceManager_registerLazyService(binder.get(), instance.c_str());
CHECK_EQ(status, STATUS_OK);
diff --git a/bluetooth/audio/utils/aidl_session/BluetoothLeAudioAseConfigurationSettingProvider.cpp b/bluetooth/audio/utils/aidl_session/BluetoothLeAudioAseConfigurationSettingProvider.cpp
index 3e18de2..2474916 100644
--- a/bluetooth/audio/utils/aidl_session/BluetoothLeAudioAseConfigurationSettingProvider.cpp
+++ b/bluetooth/audio/utils/aidl_session/BluetoothLeAudioAseConfigurationSettingProvider.cpp
@@ -394,7 +394,8 @@
void AudioSetConfigurationProviderJson::populateAseConfiguration(
const std::string& name, LeAudioAseConfiguration& ase,
const le_audio::AudioSetSubConfiguration* flat_subconfig,
- const le_audio::QosConfiguration* qos_cfg) {
+ const le_audio::QosConfiguration* qos_cfg,
+ ConfigurationFlags& configurationFlags) {
// Target latency
switch (qos_cfg->target_latency()) {
case le_audio::AudioSetConfigurationTargetLatency::
@@ -410,6 +411,7 @@
case le_audio::AudioSetConfigurationTargetLatency::
AudioSetConfigurationTargetLatency_LOW:
ase.targetLatency = LeAudioAseConfiguration::TargetLatency::LOWER;
+ configurationFlags.bitmask |= ConfigurationFlags::LOW_LATENCY;
break;
default:
ase.targetLatency = LeAudioAseConfiguration::TargetLatency::UNDEFINED;
@@ -507,7 +509,8 @@
AudioSetConfigurationProviderJson::SetConfigurationFromFlatSubconfig(
const std::string& name,
const le_audio::AudioSetSubConfiguration* flat_subconfig,
- const le_audio::QosConfiguration* qos_cfg, CodecLocation location) {
+ const le_audio::QosConfiguration* qos_cfg, CodecLocation location,
+ ConfigurationFlags& configurationFlags) {
AseDirectionConfiguration direction_conf;
LeAudioAseConfiguration ase;
@@ -515,7 +518,8 @@
LeAudioDataPathConfiguration path;
// Translate into LeAudioAseConfiguration
- populateAseConfiguration(name, ase, flat_subconfig, qos_cfg);
+ populateAseConfiguration(name, ase, flat_subconfig, qos_cfg,
+ configurationFlags);
// Translate into LeAudioAseQosConfiguration
populateAseQosConfiguration(qos, qos_cfg, ase,
@@ -554,10 +558,10 @@
const le_audio::QosConfiguration* qos_cfg,
std::vector<std::optional<AseDirectionConfiguration>>&
directionAseConfiguration,
- CodecLocation location) {
+ CodecLocation location, ConfigurationFlags& configurationFlags) {
auto ase_cnt = subconfig->ase_cnt();
- auto config =
- SetConfigurationFromFlatSubconfig(name, subconfig, qos_cfg, location);
+ auto config = SetConfigurationFromFlatSubconfig(name, subconfig, qos_cfg,
+ location, configurationFlags);
directionAseConfiguration.push_back(config);
// Put the same setting again.
if (ase_cnt == 2) directionAseConfiguration.push_back(config);
@@ -643,10 +647,10 @@
for (auto subconfig : *codec_cfg->subconfigurations()) {
if (subconfig->direction() == kLeAudioDirectionSink) {
processSubconfig(flat_cfg->name()->str(), subconfig, qos_sink_cfg,
- sinkAseConfiguration, location);
+ sinkAseConfiguration, location, configurationFlags);
} else {
processSubconfig(flat_cfg->name()->str(), subconfig, qos_source_cfg,
- sourceAseConfiguration, location);
+ sourceAseConfiguration, location, configurationFlags);
}
}
diff --git a/bluetooth/audio/utils/aidl_session/BluetoothLeAudioAseConfigurationSettingProvider.h b/bluetooth/audio/utils/aidl_session/BluetoothLeAudioAseConfigurationSettingProvider.h
index fac6152..8e12618 100644
--- a/bluetooth/audio/utils/aidl_session/BluetoothLeAudioAseConfigurationSettingProvider.h
+++ b/bluetooth/audio/utils/aidl_session/BluetoothLeAudioAseConfigurationSettingProvider.h
@@ -75,7 +75,8 @@
static void populateAseConfiguration(
const std::string& name, LeAudioAseConfiguration& ase,
const le_audio::AudioSetSubConfiguration* flat_subconfig,
- const le_audio::QosConfiguration* qos_cfg);
+ const le_audio::QosConfiguration* qos_cfg,
+ ConfigurationFlags& configurationFlags);
static void populateAseQosConfiguration(
LeAudioAseQosConfiguration& qos,
@@ -85,7 +86,8 @@
static AseDirectionConfiguration SetConfigurationFromFlatSubconfig(
const std::string& name,
const le_audio::AudioSetSubConfiguration* flat_subconfig,
- const le_audio::QosConfiguration* qos_cfg, CodecLocation location);
+ const le_audio::QosConfiguration* qos_cfg, CodecLocation location,
+ ConfigurationFlags& configurationFlags);
static void processSubconfig(
const std::string& name,
@@ -93,7 +95,7 @@
const le_audio::QosConfiguration* qos_cfg,
std::vector<std::optional<AseDirectionConfiguration>>&
directionAseConfiguration,
- CodecLocation location);
+ CodecLocation location, ConfigurationFlags& configurationFlags);
static void PopulateAseConfigurationFromFlat(
const le_audio::AudioSetConfiguration* flat_cfg,
diff --git a/bluetooth/ranging/aidl/default/BluetoothChannelSounding.cpp b/bluetooth/ranging/aidl/default/BluetoothChannelSounding.cpp
index e2a8693..4aba874 100644
--- a/bluetooth/ranging/aidl/default/BluetoothChannelSounding.cpp
+++ b/bluetooth/ranging/aidl/default/BluetoothChannelSounding.cpp
@@ -58,7 +58,8 @@
ndk::ScopedAStatus BluetoothChannelSounding::getSupportedCsSecurityLevels(
std::vector<CsSecurityLevel>* _aidl_return) {
- std::vector<CsSecurityLevel> supported_security_levels = {};
+ std::vector<CsSecurityLevel> supported_security_levels = {
+ CsSecurityLevel::NOT_SUPPORTED};
*_aidl_return = supported_security_levels;
return ::ndk::ScopedAStatus::ok();
}
diff --git a/graphics/composer/aidl/include/android/hardware/graphics/composer3/ComposerClientWriter.h b/graphics/composer/aidl/include/android/hardware/graphics/composer3/ComposerClientWriter.h
index 71a04f3..8658921 100644
--- a/graphics/composer/aidl/include/android/hardware/graphics/composer3/ComposerClientWriter.h
+++ b/graphics/composer/aidl/include/android/hardware/graphics/composer3/ComposerClientWriter.h
@@ -297,7 +297,8 @@
DisplayCommand& getDisplayCommand(int64_t display) {
if (!mDisplayCommand.has_value() || mDisplayCommand->display != display) {
- LOG_ALWAYS_FATAL_IF(display != mDisplay);
+ LOG_ALWAYS_FATAL_IF(display != mDisplay, "Expected display %" PRId64 ", got %" PRId64,
+ mDisplay, display);
flushLayerCommand();
flushDisplayCommand();
mDisplayCommand.emplace();
diff --git a/graphics/composer/aidl/libhwc_aidl_test/ComposerClientWrapper.cpp b/graphics/composer/aidl/libhwc_aidl_test/ComposerClientWrapper.cpp
index 8af1fc3..2252ce3 100644
--- a/graphics/composer/aidl/libhwc_aidl_test/ComposerClientWrapper.cpp
+++ b/graphics/composer/aidl/libhwc_aidl_test/ComposerClientWrapper.cpp
@@ -62,8 +62,9 @@
return mComposerClient->registerCallback(mComposerCallback);
}
-bool ComposerClientWrapper::tearDown(ComposerClientWriter* writer) {
- return verifyComposerCallbackParams() && destroyAllLayers(writer);
+bool ComposerClientWrapper::tearDown(
+ std::unordered_map<int64_t, ComposerClientWriter*> displayWriters) {
+ return verifyComposerCallbackParams() && destroyAllLayers(displayWriters);
}
std::pair<ScopedAStatus, int32_t> ComposerClientWrapper::getInterfaceVersion() const {
@@ -663,12 +664,16 @@
return interfaceVersion >= 3;
}
-bool ComposerClientWrapper::destroyAllLayers(ComposerClientWriter* writer) {
+bool ComposerClientWrapper::destroyAllLayers(
+ std::unordered_map<int64_t, ComposerClientWriter*> displayWriters) {
std::unordered_map<int64_t, DisplayResource> physicalDisplays;
while (!mDisplayResources.empty()) {
const auto& it = mDisplayResources.begin();
const auto& [display, resource] = *it;
+ ComposerClientWriter* writer =
+ displayWriters.count(display) > 0 ? displayWriters.at(display) : nullptr;
+
while (!resource.layers.empty()) {
auto layer = *resource.layers.begin();
const auto status = destroyLayer(display, layer, writer);
diff --git a/graphics/composer/aidl/libhwc_aidl_test/include/ComposerClientWrapper.h b/graphics/composer/aidl/libhwc_aidl_test/include/ComposerClientWrapper.h
index 22dd888..5ba52bc 100644
--- a/graphics/composer/aidl/libhwc_aidl_test/include/ComposerClientWrapper.h
+++ b/graphics/composer/aidl/libhwc_aidl_test/include/ComposerClientWrapper.h
@@ -60,7 +60,7 @@
ScopedAStatus createClient();
- bool tearDown(ComposerClientWriter*);
+ bool tearDown(std::unordered_map<int64_t, ComposerClientWriter*> displayWriters);
std::pair<ScopedAStatus, int32_t> getInterfaceVersion() const;
@@ -218,7 +218,7 @@
void removeLayerFromDisplayResources(int64_t display, int64_t layer);
- bool destroyAllLayers(ComposerClientWriter*);
+ bool destroyAllLayers(std::unordered_map<int64_t, ComposerClientWriter*> displayWriters);
bool verifyComposerCallbackParams();
@@ -242,7 +242,7 @@
class DisplayWrapper {
public:
- DisplayWrapper(int64_t displayId)
+ explicit DisplayWrapper(int64_t displayId)
: mDisplayId(displayId), mDisplayWidth(0), mDisplayHeight(0) {}
int64_t getDisplayId() const { return mDisplayId; }
diff --git a/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_ReadbackTest.cpp b/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_ReadbackTest.cpp
index dff044d..4f2ed2f 100644
--- a/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_ReadbackTest.cpp
+++ b/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_ReadbackTest.cpp
@@ -27,6 +27,8 @@
#include <ui/GraphicBuffer.h>
#include <ui/PixelFormat.h>
#include <ui/Rect.h>
+#include <cstdint>
+#include <unordered_map>
#include "ComposerClientWrapper.h"
#include "GraphicsComposerCallback.h"
#include "Readback.h"
@@ -49,74 +51,122 @@
const auto& [status, displays] = mComposerClient->getDisplays();
ASSERT_TRUE(status.isOk());
- mDisplays = displays;
- mWriter.reset(new ComposerClientWriter(getPrimaryDisplayId()));
+ mAllDisplays = displays;
- setTestColorModes();
+ setUpDisplayProperties();
- // explicitly disable vsync
- for (const auto& display : mDisplays) {
+ for (const auto& display : mAllDisplays) {
+ // explicitly disable vsync
EXPECT_TRUE(mComposerClient->setVsync(display.getDisplayId(), /*enable*/ false).isOk());
+
+ DisplayProperties& displayProperties = mDisplayProperties.at(display.getDisplayId());
+ if (ReadbackHelper::readbackSupported(displayProperties.pixelFormat,
+ displayProperties.dataspace)) {
+ mDisplaysWithReadbackBuffers.push_back(&display);
+ }
}
+
mComposerClient->setVsyncAllowed(/*isAllowed*/ false);
-
- EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
-
- const auto format = getHasReadbackBuffer() ? mPixelFormat : common::PixelFormat::RGBA_8888;
-
- ASSERT_NO_FATAL_FAILURE(
- mTestRenderEngine = std::unique_ptr<TestRenderEngine>(new TestRenderEngine(
- ::android::renderengine::RenderEngineCreationArgs::Builder()
- .setPixelFormat(static_cast<int>(format))
- .setImageCacheSize(TestRenderEngine::sMaxFrameBufferAcquireBuffers)
- .setEnableProtectedContext(false)
- .setPrecacheToneMapperShaderOnly(false)
- .setContextPriority(::android::renderengine::RenderEngine::
- ContextPriority::HIGH)
- .build())));
-
- mClientCompositionDisplaySettings.physicalDisplay =
- Rect(getDisplayWidth(), getDisplayHeight());
- mClientCompositionDisplaySettings.clip = mClientCompositionDisplaySettings.physicalDisplay;
-
- mTestRenderEngine->initGraphicBuffer(
- static_cast<uint32_t>(getDisplayWidth()), static_cast<uint32_t>(getDisplayHeight()),
- /*layerCount*/ 1U,
- static_cast<uint64_t>(
- static_cast<uint64_t>(common::BufferUsage::CPU_READ_OFTEN) |
- static_cast<uint64_t>(common::BufferUsage::CPU_WRITE_OFTEN) |
- static_cast<uint64_t>(common::BufferUsage::GPU_RENDER_TARGET)));
- mTestRenderEngine->setDisplaySettings(mClientCompositionDisplaySettings);
}
void TearDown() override {
- ASSERT_FALSE(mDisplays.empty());
- ASSERT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
- ASSERT_TRUE(mComposerClient->tearDown(mWriter.get()));
+ std::unordered_map<int64_t, ComposerClientWriter*> displayWriters;
+
+ ASSERT_FALSE(mAllDisplays.empty());
+ for (const auto& display : mAllDisplays) {
+ ASSERT_TRUE(
+ mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::OFF).isOk());
+
+ const auto errors = mDisplayProperties.at(display.getDisplayId()).reader.takeErrors();
+ ASSERT_TRUE(mDisplayProperties.at(display.getDisplayId()).reader.takeErrors().empty());
+ ASSERT_TRUE(mDisplayProperties.at(display.getDisplayId())
+ .reader.takeChangedCompositionTypes(display.getDisplayId())
+ .empty());
+ displayWriters[display.getDisplayId()] =
+ &mDisplayProperties.at(display.getDisplayId()).writer;
+ }
+
+ ASSERT_TRUE(mComposerClient->tearDown(displayWriters));
mComposerClient.reset();
- const auto errors = mReader.takeErrors();
- ASSERT_TRUE(mReader.takeErrors().empty());
- ASSERT_TRUE(mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty());
}
- const DisplayWrapper& getPrimaryDisplay() const { return mDisplays[0]; }
+ void setUpDisplayProperties() {
+ for (const auto& display : mAllDisplays) {
+ int64_t displayId = display.getDisplayId();
- int64_t getPrimaryDisplayId() const { return getPrimaryDisplay().getDisplayId(); }
+ // Set testColorModes
+ const auto& [status, modes] = mComposerClient->getColorModes(displayId);
+ ASSERT_TRUE(status.isOk());
+ std::vector<ColorMode> testColorModes;
+ for (ColorMode mode : modes) {
+ if (std::find(ReadbackHelper::colorModes.begin(), ReadbackHelper::colorModes.end(),
+ mode) != ReadbackHelper::colorModes.end()) {
+ testColorModes.push_back(mode);
+ }
+ }
+
+ // Set pixelFormat and dataspace
+ auto [readbackStatus, readBackBufferAttributes] =
+ mComposerClient->getReadbackBufferAttributes(displayId);
+ if (readbackStatus.isOk()) {
+ } else {
+ EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(
+ readbackStatus, IComposerClient::EX_UNSUPPORTED));
+ }
+
+ // Set testRenderEngine and clientCompositionDisplaySettings
+ EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
+ const auto format = readbackStatus.isOk() ? readBackBufferAttributes.format
+ : common::PixelFormat::RGBA_8888;
+ std::unique_ptr<TestRenderEngine> testRenderEngine;
+ ASSERT_NO_FATAL_FAILURE(
+ testRenderEngine = std::unique_ptr<TestRenderEngine>(new TestRenderEngine(
+ ::android::renderengine::RenderEngineCreationArgs::Builder()
+ .setPixelFormat(static_cast<int>(format))
+ .setImageCacheSize(
+ TestRenderEngine::sMaxFrameBufferAcquireBuffers)
+ .setEnableProtectedContext(false)
+ .setPrecacheToneMapperShaderOnly(false)
+ .setContextPriority(::android::renderengine::RenderEngine::
+ ContextPriority::HIGH)
+ .build())));
+
+ ::android::renderengine::DisplaySettings clientCompositionDisplaySettings;
+ clientCompositionDisplaySettings.physicalDisplay =
+ Rect(display.getDisplayWidth(), display.getDisplayHeight());
+ clientCompositionDisplaySettings.clip =
+ clientCompositionDisplaySettings.physicalDisplay;
+
+ testRenderEngine->initGraphicBuffer(
+ static_cast<uint32_t>(display.getDisplayWidth()),
+ static_cast<uint32_t>(display.getDisplayHeight()),
+ /*layerCount*/ 1U,
+ static_cast<uint64_t>(
+ static_cast<uint64_t>(common::BufferUsage::CPU_READ_OFTEN) |
+ static_cast<uint64_t>(common::BufferUsage::CPU_WRITE_OFTEN) |
+ static_cast<uint64_t>(common::BufferUsage::GPU_RENDER_TARGET)));
+ testRenderEngine->setDisplaySettings(clientCompositionDisplaySettings);
+
+ DisplayProperties displayProperties(displayId, testColorModes,
+ std::move(testRenderEngine),
+ std::move(clientCompositionDisplaySettings),
+ std::move(readBackBufferAttributes));
+
+ mDisplayProperties.emplace(displayId, std::move(displayProperties));
+ }
+ }
int64_t getInvalidDisplayId() const { return mComposerClient->getInvalidDisplayId(); }
- int32_t getDisplayWidth() const { return getPrimaryDisplay().getDisplayWidth(); }
-
- int32_t getDisplayHeight() const { return getPrimaryDisplay().getDisplayHeight(); }
-
void assertServiceSpecificError(const ScopedAStatus& status, int32_t serviceSpecificError) {
ASSERT_EQ(status.getExceptionCode(), EX_SERVICE_SPECIFIC);
ASSERT_EQ(status.getServiceSpecificError(), serviceSpecificError);
}
- std::pair<bool, ::android::sp<::android::GraphicBuffer>> allocateBuffer(uint32_t usage) {
- const auto width = static_cast<uint32_t>(getDisplayWidth());
- const auto height = static_cast<uint32_t>(getDisplayHeight());
+ std::pair<bool, ::android::sp<::android::GraphicBuffer>> allocateBuffer(
+ const DisplayWrapper& display, uint32_t usage) {
+ const auto width = static_cast<uint32_t>(display.getDisplayWidth());
+ const auto height = static_cast<uint32_t>(display.getDisplayHeight());
const auto& graphicBuffer = ::android::sp<::android::GraphicBuffer>::make(
width, height, ::android::PIXEL_FORMAT_RGBA_8888,
@@ -128,15 +178,15 @@
return {false, graphicBuffer};
}
- void writeLayers(const std::vector<std::shared_ptr<TestLayer>>& layers) {
+ void writeLayers(const std::vector<std::shared_ptr<TestLayer>>& layers, int64_t displayId) {
for (const auto& layer : layers) {
- layer->write(*mWriter);
+ layer->write(mDisplayProperties.at(displayId).writer);
}
- execute();
+ execute(displayId);
}
- void execute() {
- auto commands = mWriter->takePendingCommands();
+ void execute(int64_t displayId) {
+ auto commands = mDisplayProperties.at(displayId).writer.takePendingCommands();
if (commands.empty()) {
return;
}
@@ -144,48 +194,37 @@
auto [status, results] = mComposerClient->executeCommands(commands);
ASSERT_TRUE(status.isOk()) << "executeCommands failed " << status.getDescription();
- mReader.parse(std::move(results));
+ mDisplayProperties.at(displayId).reader.parse(std::move(results));
}
- bool getHasReadbackBuffer() {
- auto [status, readBackBufferAttributes] =
- mComposerClient->getReadbackBufferAttributes(getPrimaryDisplayId());
- if (status.isOk()) {
- mPixelFormat = readBackBufferAttributes.format;
- mDataspace = readBackBufferAttributes.dataspace;
- return ReadbackHelper::readbackSupported(mPixelFormat, mDataspace);
- }
- EXPECT_NO_FATAL_FAILURE(
- assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
- return false;
- }
+ struct DisplayProperties {
+ DisplayProperties(int64_t displayId, std::vector<ColorMode> testColorModes,
+ std::unique_ptr<TestRenderEngine> testRenderEngine,
+ ::android::renderengine::DisplaySettings clientCompositionDisplaySettings,
+ ReadbackBufferAttributes readBackBufferAttributes)
+ : testColorModes(testColorModes),
+ pixelFormat(readBackBufferAttributes.format),
+ dataspace(readBackBufferAttributes.dataspace),
+ testRenderEngine(std::move(testRenderEngine)),
+ clientCompositionDisplaySettings(std::move(clientCompositionDisplaySettings)),
+ writer(displayId),
+ reader(displayId) {}
+
+ std::vector<ColorMode> testColorModes = {};
+ common::PixelFormat pixelFormat = common::PixelFormat::UNSPECIFIED;
+ common::Dataspace dataspace = common::Dataspace::UNKNOWN;
+ std::unique_ptr<TestRenderEngine> testRenderEngine = nullptr;
+ ::android::renderengine::DisplaySettings clientCompositionDisplaySettings = {};
+ ComposerClientWriter writer;
+ ComposerClientReader reader;
+ };
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;
- ComposerClientReader mReader;
- std::unique_ptr<TestRenderEngine> mTestRenderEngine;
- common::PixelFormat mPixelFormat;
- common::Dataspace mDataspace;
- ::android::renderengine::DisplaySettings mClientCompositionDisplaySettings;
+ std::vector<DisplayWrapper> mAllDisplays;
+ std::vector<const DisplayWrapper*> mDisplaysWithReadbackBuffers;
+ std::unordered_map<int64_t, DisplayProperties> mDisplayProperties;
static constexpr uint32_t kClientTargetSlotCount = 64;
-
- private:
- void setTestColorModes() {
- mTestColorModes.clear();
- const auto& [status, modes] = mComposerClient->getColorModes(getPrimaryDisplayId());
- ASSERT_TRUE(status.isOk());
-
- for (ColorMode mode : modes) {
- if (std::find(ReadbackHelper::colorModes.begin(), ReadbackHelper::colorModes.end(),
- mode) != ReadbackHelper::colorModes.end()) {
- mTestColorModes.push_back(mode);
- }
- }
- }
};
class GraphicsCompositionTest : public GraphicsCompositionTestBase,
@@ -195,338 +234,374 @@
};
TEST_P(GraphicsCompositionTest, SingleSolidColorLayer) {
- for (ColorMode mode : mTestColorModes) {
- EXPECT_TRUE(mComposerClient
- ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
- .isOk());
+ for (const DisplayWrapper* display : mDisplaysWithReadbackBuffers) {
+ auto& testColorModes = mDisplayProperties.at(display->getDisplayId()).testColorModes;
+ for (ColorMode mode : testColorModes) {
+ EXPECT_TRUE(mComposerClient
+ ->setColorMode(display->getDisplayId(), mode,
+ RenderIntent::COLORIMETRIC)
+ .isOk());
- bool isSupported;
- ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
- if (!isSupported) {
- GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
- return;
+ auto layer = std::make_shared<TestColorLayer>(
+ mComposerClient, display->getDisplayId(),
+ mDisplayProperties.at(display->getDisplayId()).writer);
+ common::Rect coloredSquare(
+ {0, 0, display->getDisplayWidth(), display->getDisplayHeight()});
+ layer->setColor(BLUE);
+ layer->setDisplayFrame(coloredSquare);
+ layer->setZOrder(10);
+
+ std::vector<std::shared_ptr<TestLayer>> layers = {layer};
+
+ // expected color for each pixel
+ std::vector<Color> expectedColors(
+ static_cast<size_t>(display->getDisplayWidth() * display->getDisplayHeight()));
+ ReadbackHelper::fillColorsArea(expectedColors, display->getDisplayWidth(),
+ coloredSquare, BLUE);
+
+ ReadbackBuffer readbackBuffer(
+ display->getDisplayId(), mComposerClient, display->getDisplayWidth(),
+ display->getDisplayHeight(),
+ mDisplayProperties.at(display->getDisplayId()).pixelFormat,
+ mDisplayProperties.at(display->getDisplayId()).dataspace);
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
+
+ writeLayers(layers, display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.validateDisplay(display->getDisplayId(),
+ ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
+ execute(display->getDisplayId());
+ // if hwc cannot handle and asks for composition change, just skip the test on this
+ // display->
+ if (!mDisplayProperties.at(display->getDisplayId())
+ .reader.takeChangedCompositionTypes(display->getDisplayId())
+ .empty()) {
+ continue;
+ }
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.presentDisplay(display->getDisplayId());
+ execute(display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
+ auto& testRenderEngine =
+ mDisplayProperties.at(display->getDisplayId()).testRenderEngine;
+ testRenderEngine->setRenderLayers(layers);
+ ASSERT_NO_FATAL_FAILURE(testRenderEngine->drawLayers());
+ ASSERT_NO_FATAL_FAILURE(testRenderEngine->checkColorBuffer(expectedColors));
}
-
- auto layer =
- std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId(), *mWriter);
- common::Rect coloredSquare({0, 0, getDisplayWidth(), getDisplayHeight()});
- layer->setColor(BLUE);
- layer->setDisplayFrame(coloredSquare);
- layer->setZOrder(10);
-
- std::vector<std::shared_ptr<TestLayer>> layers = {layer};
-
- // expected color for each pixel
- std::vector<Color> expectedColors(
- static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
- ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), coloredSquare, BLUE);
-
- ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
- getDisplayHeight(), mPixelFormat, mDataspace);
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
-
- writeLayers(layers);
- ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- ComposerClientWrapper::kNoFrameIntervalNs);
- execute();
- // if hwc cannot handle and asks for composition change,
- // just succeed the test
- if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
- GTEST_SUCCEED();
- return;
- }
- ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter->presentDisplay(getPrimaryDisplayId());
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
-
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
- mTestRenderEngine->setRenderLayers(layers);
- ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->drawLayers());
- ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->checkColorBuffer(expectedColors));
}
}
TEST_P(GraphicsCompositionTest, SetLayerBuffer) {
- for (ColorMode mode : mTestColorModes) {
- EXPECT_TRUE(mComposerClient
- ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
- .isOk());
+ for (const DisplayWrapper* display : mDisplaysWithReadbackBuffers) {
+ auto& testColorModes = mDisplayProperties.at(display->getDisplayId()).testColorModes;
+ for (ColorMode mode : testColorModes) {
+ EXPECT_TRUE(mComposerClient
+ ->setColorMode(display->getDisplayId(), mode,
+ RenderIntent::COLORIMETRIC)
+ .isOk());
- bool isSupported;
- ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
- if (!isSupported) {
- GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
- return;
+ ReadbackBuffer readbackBuffer(
+ display->getDisplayId(), mComposerClient, display->getDisplayWidth(),
+ display->getDisplayHeight(),
+ mDisplayProperties.at(display->getDisplayId()).pixelFormat,
+ mDisplayProperties.at(display->getDisplayId()).dataspace);
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
+ std::vector<Color> expectedColors(
+ static_cast<size_t>(display->getDisplayWidth() * display->getDisplayHeight()));
+ ReadbackHelper::fillColorsArea(
+ expectedColors, display->getDisplayWidth(),
+ {0, 0, display->getDisplayWidth(), display->getDisplayHeight() / 4}, RED);
+ ReadbackHelper::fillColorsArea(
+ expectedColors, display->getDisplayWidth(),
+ {0, display->getDisplayHeight() / 4, display->getDisplayWidth(),
+ display->getDisplayHeight() / 2},
+ GREEN);
+ ReadbackHelper::fillColorsArea(
+ expectedColors, display->getDisplayWidth(),
+ {0, display->getDisplayHeight() / 2, display->getDisplayWidth(),
+ display->getDisplayHeight()},
+ BLUE);
+
+ auto layer = std::make_shared<TestBufferLayer>(
+ mComposerClient,
+ *mDisplayProperties.at(display->getDisplayId()).testRenderEngine,
+ display->getDisplayId(), display->getDisplayWidth(),
+ display->getDisplayHeight(), common::PixelFormat::RGBA_8888,
+ mDisplayProperties.at(display->getDisplayId()).writer);
+ layer->setDisplayFrame({0, 0, display->getDisplayWidth(), display->getDisplayHeight()});
+ layer->setZOrder(10);
+ layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode));
+ ASSERT_NO_FATAL_FAILURE(layer->setBuffer(expectedColors));
+
+ std::vector<std::shared_ptr<TestLayer>> layers = {layer};
+
+ writeLayers(layers, display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.validateDisplay(display->getDisplayId(),
+ ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
+ execute(display->getDisplayId());
+
+ if (!mDisplayProperties.at(display->getDisplayId())
+ .reader.takeChangedCompositionTypes(display->getDisplayId())
+ .empty()) {
+ continue;
+ }
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.presentDisplay(display->getDisplayId());
+ execute(display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
+ auto& testRenderEngine =
+ mDisplayProperties.at(display->getDisplayId()).testRenderEngine;
+ testRenderEngine->setRenderLayers(layers);
+ ASSERT_NO_FATAL_FAILURE(testRenderEngine->drawLayers());
+ ASSERT_NO_FATAL_FAILURE(testRenderEngine->checkColorBuffer(expectedColors));
}
-
- ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
- getDisplayHeight(), mPixelFormat, mDataspace);
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
- std::vector<Color> expectedColors(
- static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
- ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(),
- {0, 0, getDisplayWidth(), getDisplayHeight() / 4}, RED);
- ReadbackHelper::fillColorsArea(
- expectedColors, getDisplayWidth(),
- {0, getDisplayHeight() / 4, getDisplayWidth(), getDisplayHeight() / 2}, GREEN);
- ReadbackHelper::fillColorsArea(
- expectedColors, getDisplayWidth(),
- {0, getDisplayHeight() / 2, getDisplayWidth(), getDisplayHeight()}, BLUE);
-
- auto layer = std::make_shared<TestBufferLayer>(
- mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), getDisplayWidth(),
- getDisplayHeight(), common::PixelFormat::RGBA_8888, *mWriter);
- layer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
- layer->setZOrder(10);
- layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode));
- ASSERT_NO_FATAL_FAILURE(layer->setBuffer(expectedColors));
-
- std::vector<std::shared_ptr<TestLayer>> layers = {layer};
-
- writeLayers(layers);
- ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- ComposerClientWrapper::kNoFrameIntervalNs);
- execute();
-
- if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
- GTEST_SUCCEED();
- return;
- }
- ASSERT_TRUE(mReader.takeErrors().empty());
-
- mWriter->presentDisplay(getPrimaryDisplayId());
- execute();
-
- ASSERT_TRUE(mReader.takeErrors().empty());
-
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
- mTestRenderEngine->setRenderLayers(layers);
- ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->drawLayers());
- ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->checkColorBuffer(expectedColors));
}
}
TEST_P(GraphicsCompositionTest, SetLayerBufferNoEffect) {
- for (ColorMode mode : mTestColorModes) {
- EXPECT_TRUE(mComposerClient
- ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
- .isOk());
+ for (const DisplayWrapper* display : mDisplaysWithReadbackBuffers) {
+ auto& testColorModes = mDisplayProperties.at(display->getDisplayId()).testColorModes;
+ for (ColorMode mode : testColorModes) {
+ EXPECT_TRUE(mComposerClient
+ ->setColorMode(display->getDisplayId(), mode,
+ RenderIntent::COLORIMETRIC)
+ .isOk());
- bool isSupported;
- ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
- if (!isSupported) {
- GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
- return;
+ auto& writer = mDisplayProperties.at(display->getDisplayId()).writer;
+ auto layer = std::make_shared<TestColorLayer>(mComposerClient, display->getDisplayId(),
+ writer);
+ common::Rect coloredSquare(
+ {0, 0, display->getDisplayWidth(), display->getDisplayHeight()});
+ layer->setColor(BLUE);
+ layer->setDisplayFrame(coloredSquare);
+ layer->setZOrder(10);
+ layer->write(mDisplayProperties.at(display->getDisplayId()).writer);
+
+ // This following buffer call should have no effect
+ const auto usage = static_cast<uint32_t>(common::BufferUsage::CPU_WRITE_OFTEN) |
+ static_cast<uint32_t>(common::BufferUsage::CPU_READ_OFTEN);
+ const auto& [graphicBufferStatus, graphicBuffer] = allocateBuffer(*display, usage);
+ ASSERT_TRUE(graphicBufferStatus);
+ const auto& buffer = graphicBuffer->handle;
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.setLayerBuffer(display->getDisplayId(), layer->getLayer(), /*slot*/ 0,
+ buffer,
+ /*acquireFence*/ -1);
+
+ // expected color for each pixel
+ std::vector<Color> expectedColors(
+ static_cast<size_t>(display->getDisplayWidth() * display->getDisplayHeight()));
+ ReadbackHelper::fillColorsArea(expectedColors, display->getDisplayWidth(),
+ coloredSquare, BLUE);
+
+ ReadbackBuffer readbackBuffer(
+ display->getDisplayId(), mComposerClient, display->getDisplayWidth(),
+ display->getDisplayHeight(),
+ mDisplayProperties.at(display->getDisplayId()).pixelFormat,
+ mDisplayProperties.at(display->getDisplayId()).dataspace);
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
+
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.validateDisplay(display->getDisplayId(),
+ ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
+ execute(display->getDisplayId());
+
+ if (!mDisplayProperties.at(display->getDisplayId())
+ .reader.takeChangedCompositionTypes(display->getDisplayId())
+ .empty()) {
+ continue;
+ }
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.presentDisplay(display->getDisplayId());
+ execute(display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
}
-
- auto layer =
- std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId(), *mWriter);
- common::Rect coloredSquare({0, 0, getDisplayWidth(), getDisplayHeight()});
- layer->setColor(BLUE);
- layer->setDisplayFrame(coloredSquare);
- layer->setZOrder(10);
- layer->write(*mWriter);
-
- // This following buffer call should have no effect
- const auto usage = static_cast<uint32_t>(common::BufferUsage::CPU_WRITE_OFTEN) |
- static_cast<uint32_t>(common::BufferUsage::CPU_READ_OFTEN);
- const auto& [graphicBufferStatus, graphicBuffer] = allocateBuffer(usage);
- ASSERT_TRUE(graphicBufferStatus);
- const auto& buffer = graphicBuffer->handle;
- mWriter->setLayerBuffer(getPrimaryDisplayId(), layer->getLayer(), /*slot*/ 0, buffer,
- /*acquireFence*/ -1);
-
- // expected color for each pixel
- std::vector<Color> expectedColors(
- static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
- ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), coloredSquare, BLUE);
-
- ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
- getDisplayHeight(), mPixelFormat, mDataspace);
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
-
- mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- ComposerClientWrapper::kNoFrameIntervalNs);
- execute();
-
- if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
- GTEST_SUCCEED();
- return;
- }
- ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter->presentDisplay(getPrimaryDisplayId());
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
-
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
}
}
TEST_P(GraphicsCompositionTest, SetReadbackBuffer) {
- bool isSupported;
- ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
- if (!isSupported) {
- GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
- return;
+ for (const DisplayWrapper* display : mDisplaysWithReadbackBuffers) {
+ ReadbackBuffer readbackBuffer(display->getDisplayId(), mComposerClient,
+ display->getDisplayWidth(), display->getDisplayHeight(),
+ mDisplayProperties.at(display->getDisplayId()).pixelFormat,
+ mDisplayProperties.at(display->getDisplayId()).dataspace);
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
}
-
- ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
- getDisplayHeight(), mPixelFormat, mDataspace);
-
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
}
TEST_P(GraphicsCompositionTest, SetReadbackBuffer_BadDisplay) {
- bool isSupported;
- ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
- if (!isSupported) {
- GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
- return;
+ for (const DisplayWrapper* display : mDisplaysWithReadbackBuffers) {
+ const auto usage = static_cast<uint32_t>(common::BufferUsage::CPU_WRITE_OFTEN) |
+ static_cast<uint32_t>(common::BufferUsage::CPU_READ_OFTEN);
+ const auto& [graphicBufferStatus, graphicBuffer] = allocateBuffer(*display, usage);
+ ASSERT_TRUE(graphicBufferStatus);
+ const auto& bufferHandle = graphicBuffer->handle;
+ ::ndk::ScopedFileDescriptor fence = ::ndk::ScopedFileDescriptor(-1);
+
+ const auto status =
+ mComposerClient->setReadbackBuffer(getInvalidDisplayId(), bufferHandle, fence);
+
+ EXPECT_FALSE(status.isOk());
+ EXPECT_NO_FATAL_FAILURE(
+ assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
}
-
- const auto usage = static_cast<uint32_t>(common::BufferUsage::CPU_WRITE_OFTEN) |
- static_cast<uint32_t>(common::BufferUsage::CPU_READ_OFTEN);
- const auto& [graphicBufferStatus, graphicBuffer] = allocateBuffer(usage);
- ASSERT_TRUE(graphicBufferStatus);
- const auto& bufferHandle = graphicBuffer->handle;
- ::ndk::ScopedFileDescriptor fence = ::ndk::ScopedFileDescriptor(-1);
-
- const auto status =
- mComposerClient->setReadbackBuffer(getInvalidDisplayId(), bufferHandle, fence);
-
- EXPECT_FALSE(status.isOk());
- EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
}
TEST_P(GraphicsCompositionTest, SetReadbackBuffer_BadParameter) {
- bool isSupported;
- ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
- if (!isSupported) {
- GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
- return;
+ for (const DisplayWrapper* display : mDisplaysWithReadbackBuffers) {
+ const native_handle_t bufferHandle{};
+ ndk::ScopedFileDescriptor releaseFence = ndk::ScopedFileDescriptor(-1);
+ const auto status = mComposerClient->setReadbackBuffer(display->getDisplayId(),
+ &bufferHandle, releaseFence);
+
+ EXPECT_FALSE(status.isOk());
+ EXPECT_NO_FATAL_FAILURE(
+ assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
}
-
- const native_handle_t bufferHandle{};
- ndk::ScopedFileDescriptor releaseFence = ndk::ScopedFileDescriptor(-1);
- const auto status =
- mComposerClient->setReadbackBuffer(getPrimaryDisplayId(), &bufferHandle, releaseFence);
-
- EXPECT_FALSE(status.isOk());
- EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
}
TEST_P(GraphicsCompositionTest, GetReadbackBufferFenceInactive) {
- bool isSupported;
- ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
- if (!isSupported) {
- GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
- return;
+ for (const DisplayWrapper* display : mDisplaysWithReadbackBuffers) {
+ const auto& [status, releaseFence] =
+ mComposerClient->getReadbackBufferFence(display->getDisplayId());
+
+ EXPECT_FALSE(status.isOk());
+ EXPECT_NO_FATAL_FAILURE(
+ assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
+ EXPECT_EQ(-1, releaseFence.get());
}
-
- const auto& [status, releaseFence] =
- mComposerClient->getReadbackBufferFence(getPrimaryDisplayId());
-
- EXPECT_FALSE(status.isOk());
- EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
- EXPECT_EQ(-1, releaseFence.get());
}
TEST_P(GraphicsCompositionTest, ClientComposition) {
- EXPECT_TRUE(
- mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kClientTargetSlotCount)
- .isOk());
+ for (const DisplayWrapper* display : mDisplaysWithReadbackBuffers) {
+ EXPECT_TRUE(
+ mComposerClient
+ ->setClientTargetSlotCount(display->getDisplayId(), kClientTargetSlotCount)
+ .isOk());
- for (ColorMode mode : mTestColorModes) {
- EXPECT_TRUE(mComposerClient
- ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
- .isOk());
+ for (ColorMode mode : mDisplayProperties.at(display->getDisplayId()).testColorModes) {
+ EXPECT_TRUE(mComposerClient
+ ->setColorMode(display->getDisplayId(), mode,
+ RenderIntent::COLORIMETRIC)
+ .isOk());
- bool isSupported;
- ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
- if (!isSupported) {
- GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
- return;
+ std::vector<Color> expectedColors(
+ static_cast<size_t>(display->getDisplayWidth() * display->getDisplayHeight()));
+ ReadbackHelper::fillColorsArea(
+ expectedColors, display->getDisplayWidth(),
+ {0, 0, display->getDisplayWidth(), display->getDisplayHeight() / 4}, RED);
+ ReadbackHelper::fillColorsArea(
+ expectedColors, display->getDisplayWidth(),
+ {0, display->getDisplayHeight() / 4, display->getDisplayWidth(),
+ display->getDisplayHeight() / 2},
+ GREEN);
+ ReadbackHelper::fillColorsArea(
+ expectedColors, display->getDisplayWidth(),
+ {0, display->getDisplayHeight() / 2, display->getDisplayWidth(),
+ display->getDisplayHeight()},
+ BLUE);
+
+ auto layer = std::make_shared<TestBufferLayer>(
+ mComposerClient,
+ *mDisplayProperties.at(display->getDisplayId()).testRenderEngine,
+ display->getDisplayId(), display->getDisplayWidth(),
+ display->getDisplayHeight(), PixelFormat::RGBA_8888,
+ mDisplayProperties.at(display->getDisplayId()).writer);
+ layer->setDisplayFrame({0, 0, display->getDisplayWidth(), display->getDisplayHeight()});
+ layer->setZOrder(10);
+ layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode));
+
+ std::vector<std::shared_ptr<TestLayer>> layers = {layer};
+
+ ReadbackBuffer readbackBuffer(
+ display->getDisplayId(), mComposerClient, display->getDisplayWidth(),
+ display->getDisplayHeight(),
+ mDisplayProperties.at(display->getDisplayId()).pixelFormat,
+ mDisplayProperties.at(display->getDisplayId()).dataspace);
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
+
+ writeLayers(layers, display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.validateDisplay(display->getDisplayId(),
+ ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
+ execute(display->getDisplayId());
+
+ auto changedCompositionTypes =
+ mDisplayProperties.at(display->getDisplayId())
+ .reader.takeChangedCompositionTypes(display->getDisplayId());
+ if (!changedCompositionTypes.empty()) {
+ ASSERT_EQ(1, changedCompositionTypes.size());
+ ASSERT_EQ(Composition::CLIENT, changedCompositionTypes[0].composition);
+
+ PixelFormat clientFormat = PixelFormat::RGBA_8888;
+ auto clientUsage = static_cast<uint32_t>(
+ static_cast<uint32_t>(common::BufferUsage::CPU_READ_OFTEN) |
+ static_cast<uint32_t>(common::BufferUsage::CPU_WRITE_OFTEN) |
+ static_cast<uint32_t>(common::BufferUsage::COMPOSER_CLIENT_TARGET));
+ Dataspace clientDataspace = ReadbackHelper::getDataspaceForColorMode(mode);
+ common::Rect damage{0, 0, display->getDisplayWidth(), display->getDisplayHeight()};
+
+ // create client target buffer
+ const auto& [graphicBufferStatus, graphicBuffer] =
+ allocateBuffer(*display, clientUsage);
+ ASSERT_TRUE(graphicBufferStatus);
+ const auto& buffer = graphicBuffer->handle;
+ void* clientBufData;
+ const auto stride = static_cast<uint32_t>(graphicBuffer->stride);
+ int bytesPerPixel = -1;
+ int bytesPerStride = -1;
+ graphicBuffer->lock(clientUsage, layer->getAccessRegion(), &clientBufData,
+ &bytesPerPixel, &bytesPerStride);
+
+ ASSERT_NO_FATAL_FAILURE(ReadbackHelper::fillBuffer(
+ layer->getWidth(), layer->getHeight(), stride, bytesPerPixel, clientBufData,
+ clientFormat, expectedColors));
+ int32_t clientFence;
+ const auto unlockStatus = graphicBuffer->unlockAsync(&clientFence);
+ ASSERT_EQ(::android::OK, unlockStatus);
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.setClientTarget(display->getDisplayId(), /*slot*/ 0, buffer,
+ clientFence, clientDataspace,
+ std::vector<common::Rect>(1, damage), 1.f);
+ layer->setToClientComposition(
+ mDisplayProperties.at(display->getDisplayId()).writer);
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.validateDisplay(display->getDisplayId(),
+ ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
+ execute(display->getDisplayId());
+ changedCompositionTypes =
+ mDisplayProperties.at(display->getDisplayId())
+ .reader.takeChangedCompositionTypes(display->getDisplayId());
+ ASSERT_TRUE(changedCompositionTypes.empty());
+ }
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.presentDisplay(display->getDisplayId());
+ execute(display->getDisplayId());
+
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
}
-
- std::vector<Color> expectedColors(
- static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
- ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(),
- {0, 0, getDisplayWidth(), getDisplayHeight() / 4}, RED);
- ReadbackHelper::fillColorsArea(
- expectedColors, getDisplayWidth(),
- {0, getDisplayHeight() / 4, getDisplayWidth(), getDisplayHeight() / 2}, GREEN);
- ReadbackHelper::fillColorsArea(
- expectedColors, getDisplayWidth(),
- {0, getDisplayHeight() / 2, getDisplayWidth(), getDisplayHeight()}, BLUE);
-
- auto layer = std::make_shared<TestBufferLayer>(
- mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), getDisplayWidth(),
- getDisplayHeight(), PixelFormat::RGBA_8888, *mWriter);
- layer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
- layer->setZOrder(10);
- layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode));
-
- std::vector<std::shared_ptr<TestLayer>> layers = {layer};
-
- ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
- getDisplayHeight(), mPixelFormat, mDataspace);
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
- writeLayers(layers);
- ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- ComposerClientWrapper::kNoFrameIntervalNs);
- execute();
-
- auto changedCompositionTypes = mReader.takeChangedCompositionTypes(getPrimaryDisplayId());
- if (!changedCompositionTypes.empty()) {
- ASSERT_EQ(1, changedCompositionTypes.size());
- ASSERT_EQ(Composition::CLIENT, changedCompositionTypes[0].composition);
-
- PixelFormat clientFormat = PixelFormat::RGBA_8888;
- auto clientUsage = static_cast<uint32_t>(
- static_cast<uint32_t>(common::BufferUsage::CPU_READ_OFTEN) |
- static_cast<uint32_t>(common::BufferUsage::CPU_WRITE_OFTEN) |
- static_cast<uint32_t>(common::BufferUsage::COMPOSER_CLIENT_TARGET));
- Dataspace clientDataspace = ReadbackHelper::getDataspaceForColorMode(mode);
- common::Rect damage{0, 0, getDisplayWidth(), getDisplayHeight()};
-
- // create client target buffer
- const auto& [graphicBufferStatus, graphicBuffer] = allocateBuffer(clientUsage);
- ASSERT_TRUE(graphicBufferStatus);
- const auto& buffer = graphicBuffer->handle;
- void* clientBufData;
- const auto stride = static_cast<uint32_t>(graphicBuffer->stride);
- int bytesPerPixel = -1;
- int bytesPerStride = -1;
- graphicBuffer->lock(clientUsage, layer->getAccessRegion(), &clientBufData,
- &bytesPerPixel, &bytesPerStride);
-
- ASSERT_NO_FATAL_FAILURE(ReadbackHelper::fillBuffer(
- layer->getWidth(), layer->getHeight(), stride, bytesPerPixel, clientBufData,
- clientFormat, expectedColors));
- int32_t clientFence;
- const auto unlockStatus = graphicBuffer->unlockAsync(&clientFence);
- ASSERT_EQ(::android::OK, unlockStatus);
- mWriter->setClientTarget(getPrimaryDisplayId(), /*slot*/ 0, buffer, clientFence,
- clientDataspace, std::vector<common::Rect>(1, damage), 1.f);
- layer->setToClientComposition(*mWriter);
- mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- ComposerClientWrapper::kNoFrameIntervalNs);
- execute();
- changedCompositionTypes = mReader.takeChangedCompositionTypes(getPrimaryDisplayId());
- ASSERT_TRUE(changedCompositionTypes.empty());
- }
- ASSERT_TRUE(mReader.takeErrors().empty());
-
- mWriter->presentDisplay(getPrimaryDisplayId());
- execute();
-
- ASSERT_TRUE(mReader.takeErrors().empty());
-
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
}
}
@@ -547,626 +622,734 @@
// @VsrTest = 4.4-016
TEST_P(GraphicsCompositionTest, Luts) {
- ASSERT_TRUE(
- mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kClientTargetSlotCount)
- .isOk());
const auto& [status, properties] = mComposerClient->getOverlaySupport();
if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
- GTEST_SKIP() << "getOverlaySupport is not supported";
- return;
+ ALOGI("getOverlaySupport is not supported");
+ GTEST_SKIP();
}
if (!properties.lutProperties) {
- GTEST_SKIP() << "lutProperties is not supported";
- return;
+ ALOGI("lutProperties are not supported");
+ GTEST_SKIP();
}
- for (const auto& lutProperties : *properties.lutProperties) {
- if (!lutProperties) {
- continue;
- }
- auto& l = *lutProperties;
+ for (const DisplayWrapper* display : mDisplaysWithReadbackBuffers) {
+ ASSERT_TRUE(
+ mComposerClient
+ ->setClientTargetSlotCount(display->getDisplayId(), kClientTargetSlotCount)
+ .isOk());
+ auto& testColorModes = mDisplayProperties.at(display->getDisplayId()).testColorModes;
- for (const auto& key : l.samplingKeys) {
- for (ColorMode mode : mTestColorModes) {
- EXPECT_TRUE(mComposerClient
- ->setColorMode(getPrimaryDisplayId(), mode,
- RenderIntent::COLORIMETRIC)
- .isOk());
+ for (const auto& lutProperties : *properties.lutProperties) {
+ if (!lutProperties) {
+ continue;
+ }
+ auto& l = *lutProperties;
- bool isSupported;
- ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
- if (!isSupported) {
- GTEST_SUCCEED()
- << "Readback not supported or unsupported pixelFormat/dataspace";
- return;
+ for (const auto& key : l.samplingKeys) {
+ for (ColorMode mode : testColorModes) {
+ EXPECT_TRUE(mComposerClient
+ ->setColorMode(display->getDisplayId(), mode,
+ RenderIntent::COLORIMETRIC)
+ .isOk());
+
+ common::Rect coloredSquare(
+ {0, 0, display->getDisplayWidth(), display->getDisplayHeight()});
+
+ // expected color for each pixel
+ std::vector<Color> expectedColors(static_cast<size_t>(
+ display->getDisplayWidth() * display->getDisplayHeight()));
+ ReadbackHelper::fillColorsArea(expectedColors, display->getDisplayWidth(),
+ coloredSquare, WHITE);
+
+ auto layer = std::make_shared<TestBufferLayer>(
+ mComposerClient,
+ *mDisplayProperties.at(display->getDisplayId()).testRenderEngine,
+ display->getDisplayId(), display->getDisplayWidth(),
+ display->getDisplayHeight(), PixelFormat::RGBA_8888,
+ mDisplayProperties.at(display->getDisplayId()).writer);
+ layer->setDisplayFrame(coloredSquare);
+ layer->setZOrder(10);
+ layer->setDataspace(Dataspace::SRGB);
+
+ Luts luts;
+ generateLuts(&luts, l.dimension, l.size, key);
+ layer->setLuts(std::move(luts));
+
+ ASSERT_NO_FATAL_FAILURE(layer->setBuffer(expectedColors));
+
+ std::vector<std::shared_ptr<TestLayer>> layers = {layer};
+
+ ReadbackBuffer readbackBuffer(
+ display->getDisplayId(), mComposerClient, display->getDisplayWidth(),
+ display->getDisplayHeight(),
+ mDisplayProperties.at(display->getDisplayId()).pixelFormat,
+ mDisplayProperties.at(display->getDisplayId()).dataspace);
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
+
+ writeLayers(layers, display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId())
+ .reader.takeErrors()
+ .empty());
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.validateDisplay(display->getDisplayId(),
+ ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
+ execute(display->getDisplayId());
+ if (!mDisplayProperties.at(display->getDisplayId())
+ .reader.takeChangedCompositionTypes(display->getDisplayId())
+ .empty()) {
+ continue;
+ }
+
+ auto changedCompositionTypes =
+ mDisplayProperties.at(display->getDisplayId())
+ .reader.takeChangedCompositionTypes(display->getDisplayId());
+ ASSERT_TRUE(changedCompositionTypes.empty());
+
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.presentDisplay(display->getDisplayId());
+ execute(display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId())
+ .reader.takeErrors()
+ .empty());
+
+ ReadbackHelper::fillColorsArea(
+ expectedColors, display->getDisplayWidth(), coloredSquare,
+ {188.f / 255.f, 188.f / 255.f, 188.f / 255.f, 1.0f});
+
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
+ auto& testRenderEngine =
+ mDisplayProperties.at(display->getDisplayId()).testRenderEngine;
+ testRenderEngine->setRenderLayers(layers);
+ ASSERT_NO_FATAL_FAILURE(testRenderEngine->drawLayers());
+ ASSERT_NO_FATAL_FAILURE(testRenderEngine->checkColorBuffer(expectedColors));
}
-
- common::Rect coloredSquare({0, 0, getDisplayWidth(), getDisplayHeight()});
-
- // expected color for each pixel
- std::vector<Color> expectedColors(
- static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
- ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), coloredSquare,
- WHITE);
-
- auto layer = std::make_shared<TestBufferLayer>(
- mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(),
- getDisplayWidth(), getDisplayHeight(), PixelFormat::RGBA_8888, *mWriter);
- layer->setDisplayFrame(coloredSquare);
- layer->setZOrder(10);
- layer->setDataspace(Dataspace::SRGB);
-
- Luts luts;
- generateLuts(&luts, l.dimension, l.size, key);
- layer->setLuts(std::move(luts));
-
- ASSERT_NO_FATAL_FAILURE(layer->setBuffer(expectedColors));
-
- std::vector<std::shared_ptr<TestLayer>> layers = {layer};
-
- ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient,
- getDisplayWidth(), getDisplayHeight(), mPixelFormat,
- mDataspace);
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
-
- writeLayers(layers);
- ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- ComposerClientWrapper::kNoFrameIntervalNs);
- execute();
- // if hwc cannot handle and asks for composition change,
- // just succeed the test
- if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
- GTEST_SUCCEED();
- return;
- }
-
- auto changedCompositionTypes =
- mReader.takeChangedCompositionTypes(getPrimaryDisplayId());
- ASSERT_TRUE(changedCompositionTypes.empty());
-
- mWriter->presentDisplay(getPrimaryDisplayId());
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
-
- ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), coloredSquare,
- {188.f / 255.f, 188.f / 255.f, 188.f / 255.f, 1.0f});
-
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
- mTestRenderEngine->setRenderLayers(layers);
- ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->drawLayers());
- ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->checkColorBuffer(expectedColors));
}
}
}
}
TEST_P(GraphicsCompositionTest, MixedColorSpaces) {
- ASSERT_TRUE(
- mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kClientTargetSlotCount)
- .isOk());
const auto& [status, properties] = mComposerClient->getOverlaySupport();
if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
- GTEST_SUCCEED() << "getOverlaySupport is not supported";
- return;
+ ALOGI("getOverlaySupport is not supported");
+ GTEST_SKIP();
}
if (properties.supportMixedColorSpaces == false) {
- GTEST_SUCCEED() << "supportMixedColorSpaces is not supported";
- return;
+ ALOGI("supportMixedColorSpaces is not supported");
+ GTEST_SKIP();
}
- for (ColorMode mode : mTestColorModes) {
- EXPECT_TRUE(mComposerClient
- ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
- .isOk());
+ for (const DisplayWrapper* display : mDisplaysWithReadbackBuffers) {
+ ASSERT_TRUE(
+ mComposerClient
+ ->setClientTargetSlotCount(display->getDisplayId(), kClientTargetSlotCount)
+ .isOk());
- bool isSupported;
- ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
- if (!isSupported) {
- GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
- return;
+ for (ColorMode mode : mDisplayProperties.at(display->getDisplayId()).testColorModes) {
+ EXPECT_TRUE(mComposerClient
+ ->setColorMode(display->getDisplayId(), mode,
+ RenderIntent::COLORIMETRIC)
+ .isOk());
+
+ // sRGB layer
+ auto srgbLayer = std::make_shared<TestBufferLayer>(
+ mComposerClient,
+ *mDisplayProperties.at(display->getDisplayId()).testRenderEngine,
+ display->getDisplayId(), display->getDisplayWidth(),
+ display->getDisplayHeight() / 2, PixelFormat::RGBA_8888,
+ mDisplayProperties.at(display->getDisplayId()).writer);
+ std::vector<Color> sRgbDeviceColors(srgbLayer->getWidth() * srgbLayer->getHeight());
+ ReadbackHelper::fillColorsArea(sRgbDeviceColors, display->getDisplayWidth(),
+ {0, 0, static_cast<int32_t>(srgbLayer->getWidth()),
+ static_cast<int32_t>(srgbLayer->getHeight())},
+ GREEN);
+ srgbLayer->setDisplayFrame({0, 0, static_cast<int32_t>(srgbLayer->getWidth()),
+ static_cast<int32_t>(srgbLayer->getHeight())});
+ srgbLayer->setZOrder(10);
+ srgbLayer->setDataspace(Dataspace::SRGB);
+ ASSERT_NO_FATAL_FAILURE(srgbLayer->setBuffer(sRgbDeviceColors));
+
+ // display P3 layer
+ auto displayP3Layer = std::make_shared<TestBufferLayer>(
+ mComposerClient,
+ *mDisplayProperties.at(display->getDisplayId()).testRenderEngine,
+ display->getDisplayId(), display->getDisplayWidth(),
+ display->getDisplayHeight() / 2, PixelFormat::RGBA_8888,
+ mDisplayProperties.at(display->getDisplayId()).writer);
+ std::vector<Color> displayP3DeviceColors(
+ static_cast<size_t>(displayP3Layer->getWidth() * displayP3Layer->getHeight()));
+ ReadbackHelper::fillColorsArea(displayP3DeviceColors, display->getDisplayWidth(),
+ {0, 0, static_cast<int32_t>(displayP3Layer->getWidth()),
+ static_cast<int32_t>(displayP3Layer->getHeight())},
+ RED);
+ displayP3Layer->setDisplayFrame({0, display->getDisplayHeight() / 2,
+ display->getDisplayWidth(),
+ display->getDisplayHeight()});
+ displayP3Layer->setZOrder(10);
+ displayP3Layer->setDataspace(Dataspace::DISPLAY_P3);
+ ASSERT_NO_FATAL_FAILURE(displayP3Layer->setBuffer(displayP3DeviceColors));
+
+ writeLayers({srgbLayer, displayP3Layer}, display->getDisplayId());
+
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.validateDisplay(display->getDisplayId(),
+ ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
+ execute(display->getDisplayId());
+
+ auto changedCompositionTypes =
+ mDisplayProperties.at(display->getDisplayId())
+ .reader.takeChangedCompositionTypes(display->getDisplayId());
+ ASSERT_TRUE(changedCompositionTypes.empty());
+
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.presentDisplay(display->getDisplayId());
+ execute(display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ changedCompositionTypes =
+ mDisplayProperties.at(display->getDisplayId())
+ .reader.takeChangedCompositionTypes(display->getDisplayId());
+ ASSERT_TRUE(changedCompositionTypes.empty());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
}
-
- // sRGB layer
- auto srgbLayer = std::make_shared<TestBufferLayer>(
- mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), getDisplayWidth(),
- getDisplayHeight() / 2, PixelFormat::RGBA_8888, *mWriter);
- std::vector<Color> sRgbDeviceColors(srgbLayer->getWidth() * srgbLayer->getHeight());
- ReadbackHelper::fillColorsArea(sRgbDeviceColors, getDisplayWidth(),
- {0, 0, static_cast<int32_t>(srgbLayer->getWidth()),
- static_cast<int32_t>(srgbLayer->getHeight())},
- GREEN);
- srgbLayer->setDisplayFrame({0, 0, static_cast<int32_t>(srgbLayer->getWidth()),
- static_cast<int32_t>(srgbLayer->getHeight())});
- srgbLayer->setZOrder(10);
- srgbLayer->setDataspace(Dataspace::SRGB);
- ASSERT_NO_FATAL_FAILURE(srgbLayer->setBuffer(sRgbDeviceColors));
-
- // display P3 layer
- auto displayP3Layer = std::make_shared<TestBufferLayer>(
- mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), getDisplayWidth(),
- getDisplayHeight() / 2, PixelFormat::RGBA_8888, *mWriter);
- std::vector<Color> displayP3DeviceColors(
- static_cast<size_t>(displayP3Layer->getWidth() * displayP3Layer->getHeight()));
- ReadbackHelper::fillColorsArea(displayP3DeviceColors, getDisplayWidth(),
- {0, 0, static_cast<int32_t>(displayP3Layer->getWidth()),
- static_cast<int32_t>(displayP3Layer->getHeight())},
- RED);
- displayP3Layer->setDisplayFrame(
- {0, getDisplayHeight() / 2, getDisplayWidth(), getDisplayHeight()});
- displayP3Layer->setZOrder(10);
- displayP3Layer->setDataspace(Dataspace::DISPLAY_P3);
- ASSERT_NO_FATAL_FAILURE(displayP3Layer->setBuffer(displayP3DeviceColors));
-
- writeLayers({srgbLayer, displayP3Layer});
-
- mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- ComposerClientWrapper::kNoFrameIntervalNs);
- execute();
-
- auto changedCompositionTypes = mReader.takeChangedCompositionTypes(getPrimaryDisplayId());
- ASSERT_TRUE(changedCompositionTypes.empty());
-
- mWriter->presentDisplay(getPrimaryDisplayId());
- execute();
-
- changedCompositionTypes = mReader.takeChangedCompositionTypes(getPrimaryDisplayId());
- ASSERT_TRUE(changedCompositionTypes.empty());
- ASSERT_TRUE(mReader.takeErrors().empty());
}
}
TEST_P(GraphicsCompositionTest, DeviceAndClientComposition) {
- ASSERT_TRUE(
- mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kClientTargetSlotCount)
- .isOk());
+ for (const DisplayWrapper* display : mDisplaysWithReadbackBuffers) {
+ ASSERT_TRUE(
+ mComposerClient
+ ->setClientTargetSlotCount(display->getDisplayId(), kClientTargetSlotCount)
+ .isOk());
- for (ColorMode mode : mTestColorModes) {
- EXPECT_TRUE(mComposerClient
- ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
- .isOk());
+ for (ColorMode mode : mDisplayProperties.at(display->getDisplayId()).testColorModes) {
+ EXPECT_TRUE(mComposerClient
+ ->setColorMode(display->getDisplayId(), mode,
+ RenderIntent::COLORIMETRIC)
+ .isOk());
- bool isSupported;
- ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
- if (!isSupported) {
- GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
- return;
+ std::vector<Color> expectedColors(
+ static_cast<size_t>(display->getDisplayWidth() * display->getDisplayHeight()));
+ ReadbackHelper::fillColorsArea(
+ expectedColors, display->getDisplayWidth(),
+ {0, 0, display->getDisplayWidth(), display->getDisplayHeight() / 2}, GREEN);
+ ReadbackHelper::fillColorsArea(
+ expectedColors, display->getDisplayWidth(),
+ {0, display->getDisplayHeight() / 2, display->getDisplayWidth(),
+ display->getDisplayHeight()},
+ RED);
+
+ ReadbackBuffer readbackBuffer(
+ display->getDisplayId(), mComposerClient, display->getDisplayWidth(),
+ display->getDisplayHeight(),
+ mDisplayProperties.at(display->getDisplayId()).pixelFormat,
+ mDisplayProperties.at(display->getDisplayId()).dataspace);
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
+
+ auto deviceLayer = std::make_shared<TestBufferLayer>(
+ mComposerClient,
+ *mDisplayProperties.at(display->getDisplayId()).testRenderEngine,
+ display->getDisplayId(), display->getDisplayWidth(),
+ display->getDisplayHeight() / 2, PixelFormat::RGBA_8888,
+ mDisplayProperties.at(display->getDisplayId()).writer);
+ std::vector<Color> deviceColors(deviceLayer->getWidth() * deviceLayer->getHeight());
+ ReadbackHelper::fillColorsArea(deviceColors,
+ static_cast<int32_t>(deviceLayer->getWidth()),
+ {0, 0, static_cast<int32_t>(deviceLayer->getWidth()),
+ static_cast<int32_t>(deviceLayer->getHeight())},
+ GREEN);
+ deviceLayer->setDisplayFrame({0, 0, static_cast<int32_t>(deviceLayer->getWidth()),
+ static_cast<int32_t>(deviceLayer->getHeight())});
+ deviceLayer->setZOrder(10);
+ deviceLayer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode));
+ ASSERT_NO_FATAL_FAILURE(deviceLayer->setBuffer(deviceColors));
+ deviceLayer->write(mDisplayProperties.at(display->getDisplayId()).writer);
+
+ PixelFormat clientFormat = PixelFormat::RGBA_8888;
+ auto clientUsage = static_cast<uint32_t>(
+ static_cast<uint64_t>(common::BufferUsage::CPU_READ_OFTEN) |
+ static_cast<uint32_t>(common::BufferUsage::CPU_WRITE_OFTEN) |
+ static_cast<uint32_t>(common::BufferUsage::COMPOSER_CLIENT_TARGET));
+ Dataspace clientDataspace = ReadbackHelper::getDataspaceForColorMode(mode);
+ int32_t clientWidth = display->getDisplayWidth();
+ int32_t clientHeight = display->getDisplayHeight() / 2;
+
+ auto clientLayer = std::make_shared<TestBufferLayer>(
+ mComposerClient,
+ *mDisplayProperties.at(display->getDisplayId()).testRenderEngine,
+ display->getDisplayId(), clientWidth, clientHeight, PixelFormat::RGBA_FP16,
+ mDisplayProperties.at(display->getDisplayId()).writer, Composition::DEVICE);
+ common::Rect clientFrame = {0, display->getDisplayHeight() / 2,
+ display->getDisplayWidth(), display->getDisplayHeight()};
+ clientLayer->setDisplayFrame(clientFrame);
+ clientLayer->setZOrder(0);
+ clientLayer->write(mDisplayProperties.at(display->getDisplayId()).writer);
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.validateDisplay(display->getDisplayId(),
+ ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
+ execute(display->getDisplayId());
+
+ auto changedCompositionTypes =
+ mDisplayProperties.at(display->getDisplayId())
+ .reader.takeChangedCompositionTypes(display->getDisplayId());
+ if (changedCompositionTypes.size() != 1) {
+ continue;
+ }
+ // create client target buffer
+ ASSERT_EQ(Composition::CLIENT, changedCompositionTypes[0].composition);
+ const auto& [graphicBufferStatus, graphicBuffer] =
+ allocateBuffer(*display, clientUsage);
+ ASSERT_TRUE(graphicBufferStatus);
+ const auto& buffer = graphicBuffer->handle;
+
+ void* clientBufData;
+ int bytesPerPixel = -1;
+ int bytesPerStride = -1;
+ graphicBuffer->lock(clientUsage,
+ {0, 0, display->getDisplayWidth(), display->getDisplayHeight()},
+ &clientBufData, &bytesPerPixel, &bytesPerStride);
+
+ std::vector<Color> clientColors(
+ static_cast<size_t>(display->getDisplayWidth() * display->getDisplayHeight()));
+ ReadbackHelper::fillColorsArea(clientColors, display->getDisplayWidth(), clientFrame,
+ RED);
+ ASSERT_NO_FATAL_FAILURE(ReadbackHelper::fillBuffer(
+ static_cast<uint32_t>(display->getDisplayWidth()),
+ static_cast<uint32_t>(display->getDisplayHeight()), graphicBuffer->getStride(),
+ bytesPerPixel, clientBufData, clientFormat, clientColors));
+ int32_t clientFence;
+ const auto unlockStatus = graphicBuffer->unlockAsync(&clientFence);
+ ASSERT_EQ(::android::OK, unlockStatus);
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.setClientTarget(display->getDisplayId(), /*slot*/ 0, buffer,
+ clientFence, clientDataspace,
+ std::vector<common::Rect>(1, clientFrame), 1.f);
+ clientLayer->setToClientComposition(
+ mDisplayProperties.at(display->getDisplayId()).writer);
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.validateDisplay(display->getDisplayId(),
+ ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
+ execute(display->getDisplayId());
+ changedCompositionTypes =
+ mDisplayProperties.at(display->getDisplayId())
+ .reader.takeChangedCompositionTypes(display->getDisplayId());
+ ASSERT_TRUE(changedCompositionTypes.empty());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.presentDisplay(display->getDisplayId());
+ execute(display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
}
-
- std::vector<Color> expectedColors(
- static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
- ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(),
- {0, 0, getDisplayWidth(), getDisplayHeight() / 2}, GREEN);
- ReadbackHelper::fillColorsArea(
- expectedColors, getDisplayWidth(),
- {0, getDisplayHeight() / 2, getDisplayWidth(), getDisplayHeight()}, RED);
-
- ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
- getDisplayHeight(), mPixelFormat, mDataspace);
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
-
- auto deviceLayer = std::make_shared<TestBufferLayer>(
- mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), getDisplayWidth(),
- getDisplayHeight() / 2, PixelFormat::RGBA_8888, *mWriter);
- std::vector<Color> deviceColors(deviceLayer->getWidth() * deviceLayer->getHeight());
- ReadbackHelper::fillColorsArea(deviceColors, static_cast<int32_t>(deviceLayer->getWidth()),
- {0, 0, static_cast<int32_t>(deviceLayer->getWidth()),
- static_cast<int32_t>(deviceLayer->getHeight())},
- GREEN);
- deviceLayer->setDisplayFrame({0, 0, static_cast<int32_t>(deviceLayer->getWidth()),
- static_cast<int32_t>(deviceLayer->getHeight())});
- deviceLayer->setZOrder(10);
- deviceLayer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode));
- ASSERT_NO_FATAL_FAILURE(deviceLayer->setBuffer(deviceColors));
- deviceLayer->write(*mWriter);
-
- PixelFormat clientFormat = PixelFormat::RGBA_8888;
- auto clientUsage = static_cast<uint32_t>(
- static_cast<uint64_t>(common::BufferUsage::CPU_READ_OFTEN) |
- static_cast<uint32_t>(common::BufferUsage::CPU_WRITE_OFTEN) |
- static_cast<uint32_t>(common::BufferUsage::COMPOSER_CLIENT_TARGET));
- Dataspace clientDataspace = ReadbackHelper::getDataspaceForColorMode(mode);
- int32_t clientWidth = getDisplayWidth();
- int32_t clientHeight = getDisplayHeight() / 2;
-
- auto clientLayer = std::make_shared<TestBufferLayer>(
- mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), clientWidth,
- clientHeight, PixelFormat::RGBA_FP16, *mWriter, Composition::DEVICE);
- common::Rect clientFrame = {0, getDisplayHeight() / 2, getDisplayWidth(),
- getDisplayHeight()};
- clientLayer->setDisplayFrame(clientFrame);
- clientLayer->setZOrder(0);
- clientLayer->write(*mWriter);
- mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- ComposerClientWrapper::kNoFrameIntervalNs);
- execute();
-
- auto changedCompositionTypes = mReader.takeChangedCompositionTypes(getPrimaryDisplayId());
- if (changedCompositionTypes.size() != 1) {
- continue;
- }
- // create client target buffer
- ASSERT_EQ(Composition::CLIENT, changedCompositionTypes[0].composition);
- const auto& [graphicBufferStatus, graphicBuffer] = allocateBuffer(clientUsage);
- ASSERT_TRUE(graphicBufferStatus);
- const auto& buffer = graphicBuffer->handle;
-
- void* clientBufData;
- int bytesPerPixel = -1;
- int bytesPerStride = -1;
- graphicBuffer->lock(clientUsage, {0, 0, getDisplayWidth(), getDisplayHeight()},
- &clientBufData, &bytesPerPixel, &bytesPerStride);
-
- std::vector<Color> clientColors(
- static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
- ReadbackHelper::fillColorsArea(clientColors, getDisplayWidth(), clientFrame, RED);
- ASSERT_NO_FATAL_FAILURE(ReadbackHelper::fillBuffer(
- static_cast<uint32_t>(getDisplayWidth()), static_cast<uint32_t>(getDisplayHeight()),
- graphicBuffer->getStride(), bytesPerPixel, clientBufData, clientFormat,
- clientColors));
- int32_t clientFence;
- const auto unlockStatus = graphicBuffer->unlockAsync(&clientFence);
- ASSERT_EQ(::android::OK, unlockStatus);
- mWriter->setClientTarget(getPrimaryDisplayId(), /*slot*/ 0, buffer, clientFence,
- clientDataspace, std::vector<common::Rect>(1, clientFrame), 1.f);
- clientLayer->setToClientComposition(*mWriter);
- mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- ComposerClientWrapper::kNoFrameIntervalNs);
- execute();
- changedCompositionTypes = mReader.takeChangedCompositionTypes(getPrimaryDisplayId());
- ASSERT_TRUE(changedCompositionTypes.empty());
- ASSERT_TRUE(mReader.takeErrors().empty());
-
- mWriter->presentDisplay(getPrimaryDisplayId());
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
}
}
TEST_P(GraphicsCompositionTest, SetLayerDamage) {
- for (ColorMode mode : mTestColorModes) {
- EXPECT_TRUE(mComposerClient
- ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
- .isOk());
+ for (const DisplayWrapper* display : mDisplaysWithReadbackBuffers) {
+ for (ColorMode mode : mDisplayProperties.at(display->getDisplayId()).testColorModes) {
+ EXPECT_TRUE(mComposerClient
+ ->setColorMode(display->getDisplayId(), mode,
+ RenderIntent::COLORIMETRIC)
+ .isOk());
- bool isSupported;
- ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
- if (!isSupported) {
- GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
- return;
+ common::Rect redRect = {0, 0, display->getDisplayWidth() / 4,
+ display->getDisplayHeight() / 4};
+
+ std::vector<Color> expectedColors(
+ static_cast<size_t>(display->getDisplayWidth() * display->getDisplayHeight()));
+ ReadbackHelper::fillColorsArea(expectedColors, display->getDisplayWidth(), redRect,
+ RED);
+
+ auto layer = std::make_shared<TestBufferLayer>(
+ mComposerClient,
+ *mDisplayProperties.at(display->getDisplayId()).testRenderEngine,
+ display->getDisplayId(), display->getDisplayWidth(),
+ display->getDisplayHeight(), PixelFormat::RGBA_8888,
+ mDisplayProperties.at(display->getDisplayId()).writer);
+ layer->setDisplayFrame({0, 0, display->getDisplayWidth(), display->getDisplayHeight()});
+ layer->setZOrder(10);
+ layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode));
+ ASSERT_NO_FATAL_FAILURE(layer->setBuffer(expectedColors));
+
+ std::vector<std::shared_ptr<TestLayer>> layers = {layer};
+
+ ReadbackBuffer readbackBuffer(
+ display->getDisplayId(), mComposerClient, display->getDisplayWidth(),
+ display->getDisplayHeight(),
+ mDisplayProperties.at(display->getDisplayId()).pixelFormat,
+ mDisplayProperties.at(display->getDisplayId()).dataspace);
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
+
+ writeLayers(layers, display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.validateDisplay(display->getDisplayId(),
+ ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
+ execute(display->getDisplayId());
+ if (!mDisplayProperties.at(display->getDisplayId())
+ .reader.takeChangedCompositionTypes(display->getDisplayId())
+ .empty()) {
+ continue;
+ }
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.presentDisplay(display->getDisplayId());
+ execute(display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
+
+ // update surface damage and recheck
+ redRect = {display->getDisplayWidth() / 4, display->getDisplayHeight() / 4,
+ display->getDisplayWidth() / 2, display->getDisplayHeight() / 2};
+ ReadbackHelper::clearColors(expectedColors, display->getDisplayWidth(),
+ display->getDisplayHeight(), display->getDisplayWidth());
+ ReadbackHelper::fillColorsArea(expectedColors, display->getDisplayWidth(), redRect,
+ RED);
+
+ ASSERT_NO_FATAL_FAILURE(layer->fillBuffer(expectedColors));
+ layer->setSurfaceDamage(std::vector<common::Rect>(
+ 1, {0, 0, display->getDisplayWidth() / 2, display->getDisplayWidth() / 2}));
+
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
+
+ writeLayers(layers, display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.validateDisplay(display->getDisplayId(),
+ ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
+ execute(display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId())
+ .reader.takeChangedCompositionTypes(display->getDisplayId())
+ .empty());
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.presentDisplay(display->getDisplayId());
+ execute(display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
}
-
- common::Rect redRect = {0, 0, getDisplayWidth() / 4, getDisplayHeight() / 4};
-
- std::vector<Color> expectedColors(
- static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
- ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), redRect, RED);
-
- auto layer = std::make_shared<TestBufferLayer>(
- mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), getDisplayWidth(),
- getDisplayHeight(), PixelFormat::RGBA_8888, *mWriter);
- layer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
- layer->setZOrder(10);
- layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode));
- ASSERT_NO_FATAL_FAILURE(layer->setBuffer(expectedColors));
-
- std::vector<std::shared_ptr<TestLayer>> layers = {layer};
-
- ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
- getDisplayHeight(), mPixelFormat, mDataspace);
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
-
- writeLayers(layers);
- ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- ComposerClientWrapper::kNoFrameIntervalNs);
- execute();
- if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
- GTEST_SUCCEED();
- return;
- }
- ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter->presentDisplay(getPrimaryDisplayId());
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
-
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
-
- // update surface damage and recheck
- redRect = {getDisplayWidth() / 4, getDisplayHeight() / 4, getDisplayWidth() / 2,
- getDisplayHeight() / 2};
- ReadbackHelper::clearColors(expectedColors, getDisplayWidth(), getDisplayHeight(),
- getDisplayWidth());
- ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), redRect, RED);
-
- ASSERT_NO_FATAL_FAILURE(layer->fillBuffer(expectedColors));
- layer->setSurfaceDamage(
- std::vector<common::Rect>(1, {0, 0, getDisplayWidth() / 2, getDisplayWidth() / 2}));
-
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
-
- writeLayers(layers);
- ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- ComposerClientWrapper::kNoFrameIntervalNs);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
- ASSERT_TRUE(mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty());
- mWriter->presentDisplay(getPrimaryDisplayId());
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
-
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
}
}
TEST_P(GraphicsCompositionTest, SetLayerPlaneAlpha) {
- for (ColorMode mode : mTestColorModes) {
- EXPECT_TRUE(mComposerClient
- ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
- .isOk());
+ for (const DisplayWrapper* display : mDisplaysWithReadbackBuffers) {
+ for (ColorMode mode : mDisplayProperties.at(display->getDisplayId()).testColorModes) {
+ EXPECT_TRUE(mComposerClient
+ ->setColorMode(display->getDisplayId(), mode,
+ RenderIntent::COLORIMETRIC)
+ .isOk());
- bool isSupported;
- ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
- if (!isSupported) {
- GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
- return;
+ auto layer = std::make_shared<TestColorLayer>(
+ mComposerClient, display->getDisplayId(),
+ mDisplayProperties.at(display->getDisplayId()).writer);
+ layer->setColor(RED);
+ layer->setDisplayFrame({0, 0, display->getDisplayWidth(), display->getDisplayHeight()});
+ layer->setZOrder(10);
+ layer->setAlpha(0);
+ layer->setBlendMode(BlendMode::PREMULTIPLIED);
+
+ std::vector<std::shared_ptr<TestLayer>> layers = {layer};
+
+ ReadbackBuffer readbackBuffer(
+ display->getDisplayId(), mComposerClient, display->getDisplayWidth(),
+ display->getDisplayHeight(),
+ mDisplayProperties.at(display->getDisplayId()).pixelFormat,
+ mDisplayProperties.at(display->getDisplayId()).dataspace);
+
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
+
+ writeLayers(layers, display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.validateDisplay(display->getDisplayId(),
+ ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
+ execute(display->getDisplayId());
+ if (!mDisplayProperties.at(display->getDisplayId())
+ .reader.takeChangedCompositionTypes(display->getDisplayId())
+ .empty()) {
+ continue;
+ }
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.presentDisplay(display->getDisplayId());
+ execute(display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+
+ std::vector<Color> expectedColors(
+ static_cast<size_t>(display->getDisplayWidth() * display->getDisplayHeight()));
+
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
+ auto& testRenderEngine =
+ mDisplayProperties.at(display->getDisplayId()).testRenderEngine;
+ testRenderEngine->setRenderLayers(layers);
+ ASSERT_NO_FATAL_FAILURE(testRenderEngine->drawLayers());
+ ASSERT_NO_FATAL_FAILURE(testRenderEngine->checkColorBuffer(expectedColors));
}
-
- auto layer =
- std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId(), *mWriter);
- layer->setColor(RED);
- layer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
- layer->setZOrder(10);
- layer->setAlpha(0);
- layer->setBlendMode(BlendMode::PREMULTIPLIED);
-
- std::vector<std::shared_ptr<TestLayer>> layers = {layer};
-
- ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
- getDisplayHeight(), mPixelFormat, mDataspace);
-
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
-
- writeLayers(layers);
- ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- ComposerClientWrapper::kNoFrameIntervalNs);
- execute();
- if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
- GTEST_SUCCEED();
- return;
- }
- ASSERT_TRUE(mReader.takeErrors().empty());
-
- mWriter->presentDisplay(getPrimaryDisplayId());
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
-
- std::vector<Color> expectedColors(
- static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
-
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
- mTestRenderEngine->setRenderLayers(layers);
- ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->drawLayers());
- ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->checkColorBuffer(expectedColors));
}
}
TEST_P(GraphicsCompositionTest, SetLayerSourceCrop) {
- for (ColorMode mode : mTestColorModes) {
- EXPECT_TRUE(mComposerClient
- ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
- .isOk());
+ for (const DisplayWrapper* display : mDisplaysWithReadbackBuffers) {
+ for (ColorMode mode : mDisplayProperties.at(display->getDisplayId()).testColorModes) {
+ EXPECT_TRUE(mComposerClient
+ ->setColorMode(display->getDisplayId(), mode,
+ RenderIntent::COLORIMETRIC)
+ .isOk());
- bool isSupported;
- ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
- if (!isSupported) {
- GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
- return;
+ std::vector<Color> expectedColors(
+ static_cast<size_t>(display->getDisplayWidth() * display->getDisplayHeight()));
+ ReadbackHelper::fillColorsArea(
+ expectedColors, display->getDisplayWidth(),
+ {0, 0, display->getDisplayWidth(), display->getDisplayHeight() / 4}, RED);
+ ReadbackHelper::fillColorsArea(
+ expectedColors, display->getDisplayWidth(),
+ {0, display->getDisplayHeight() / 2, display->getDisplayWidth(),
+ display->getDisplayHeight()},
+ BLUE);
+
+ auto layer = std::make_shared<TestBufferLayer>(
+ mComposerClient,
+ *mDisplayProperties.at(display->getDisplayId()).testRenderEngine,
+ display->getDisplayId(), display->getDisplayWidth(),
+ display->getDisplayHeight(), PixelFormat::RGBA_8888,
+ mDisplayProperties.at(display->getDisplayId()).writer);
+ layer->setDisplayFrame({0, 0, display->getDisplayWidth(), display->getDisplayHeight()});
+ layer->setZOrder(10);
+ layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode));
+ layer->setSourceCrop({0, static_cast<float>(display->getDisplayHeight() / 2),
+ static_cast<float>(display->getDisplayWidth()),
+ static_cast<float>(display->getDisplayHeight())});
+ ASSERT_NO_FATAL_FAILURE(layer->setBuffer(expectedColors));
+
+ std::vector<std::shared_ptr<TestLayer>> layers = {layer};
+
+ // update expected colors to match crop
+ ReadbackHelper::fillColorsArea(
+ expectedColors, display->getDisplayWidth(),
+ {0, 0, display->getDisplayWidth(), display->getDisplayHeight()}, BLUE);
+ ReadbackBuffer readbackBuffer(
+ display->getDisplayId(), mComposerClient, display->getDisplayWidth(),
+ display->getDisplayHeight(),
+ mDisplayProperties.at(display->getDisplayId()).pixelFormat,
+ mDisplayProperties.at(display->getDisplayId()).dataspace);
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
+ writeLayers(layers, display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.validateDisplay(display->getDisplayId(),
+ ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
+ execute(display->getDisplayId());
+ if (!mDisplayProperties.at(display->getDisplayId())
+ .reader.takeChangedCompositionTypes(display->getDisplayId())
+ .empty()) {
+ continue;
+ }
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.presentDisplay(display->getDisplayId());
+ execute(display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
+ auto& testRenderEngine =
+ mDisplayProperties.at(display->getDisplayId()).testRenderEngine;
+ testRenderEngine->setRenderLayers(layers);
+ ASSERT_NO_FATAL_FAILURE(testRenderEngine->drawLayers());
+ ASSERT_NO_FATAL_FAILURE(testRenderEngine->checkColorBuffer(expectedColors));
}
-
- std::vector<Color> expectedColors(
- static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
- ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(),
- {0, 0, getDisplayWidth(), getDisplayHeight() / 4}, RED);
- ReadbackHelper::fillColorsArea(
- expectedColors, getDisplayWidth(),
- {0, getDisplayHeight() / 2, getDisplayWidth(), getDisplayHeight()}, BLUE);
-
- auto layer = std::make_shared<TestBufferLayer>(
- mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), getDisplayWidth(),
- getDisplayHeight(), PixelFormat::RGBA_8888, *mWriter);
- layer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
- layer->setZOrder(10);
- layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode));
- layer->setSourceCrop({0, static_cast<float>(getDisplayHeight() / 2),
- static_cast<float>(getDisplayWidth()),
- static_cast<float>(getDisplayHeight())});
- ASSERT_NO_FATAL_FAILURE(layer->setBuffer(expectedColors));
-
- std::vector<std::shared_ptr<TestLayer>> layers = {layer};
-
- // update expected colors to match crop
- ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(),
- {0, 0, getDisplayWidth(), getDisplayHeight()}, BLUE);
- ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
- getDisplayHeight(), mPixelFormat, mDataspace);
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
- writeLayers(layers);
- ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- ComposerClientWrapper::kNoFrameIntervalNs);
- execute();
- if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
- GTEST_SUCCEED();
- return;
- }
- ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter->presentDisplay(getPrimaryDisplayId());
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
- mTestRenderEngine->setRenderLayers(layers);
- ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->drawLayers());
- ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->checkColorBuffer(expectedColors));
}
}
TEST_P(GraphicsCompositionTest, SetLayerZOrder) {
- for (ColorMode mode : mTestColorModes) {
- EXPECT_TRUE(mComposerClient
- ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
- .isOk());
+ for (const DisplayWrapper* display : mDisplaysWithReadbackBuffers) {
+ for (ColorMode mode : mDisplayProperties.at(display->getDisplayId()).testColorModes) {
+ EXPECT_TRUE(mComposerClient
+ ->setColorMode(display->getDisplayId(), mode,
+ RenderIntent::COLORIMETRIC)
+ .isOk());
- bool isSupported;
- ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
- if (!isSupported) {
- GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
- return;
+ common::Rect redRect = {0, 0, display->getDisplayWidth(),
+ display->getDisplayHeight() / 2};
+ common::Rect blueRect = {0, display->getDisplayHeight() / 4, display->getDisplayWidth(),
+ display->getDisplayHeight()};
+ auto redLayer = std::make_shared<TestColorLayer>(
+ mComposerClient, display->getDisplayId(),
+ mDisplayProperties.at(display->getDisplayId()).writer);
+ redLayer->setColor(RED);
+ redLayer->setDisplayFrame(redRect);
+
+ auto blueLayer = std::make_shared<TestColorLayer>(
+ mComposerClient, display->getDisplayId(),
+ mDisplayProperties.at(display->getDisplayId()).writer);
+ blueLayer->setColor(BLUE);
+ blueLayer->setDisplayFrame(blueRect);
+ blueLayer->setZOrder(5);
+
+ std::vector<std::shared_ptr<TestLayer>> layers = {redLayer, blueLayer};
+ std::vector<Color> expectedColors(
+ static_cast<size_t>(display->getDisplayWidth() * display->getDisplayHeight()));
+
+ // red in front of blue
+ redLayer->setZOrder(10);
+
+ // fill blue first so that red will overwrite on overlap
+ ReadbackHelper::fillColorsArea(expectedColors, display->getDisplayWidth(), blueRect,
+ BLUE);
+ ReadbackHelper::fillColorsArea(expectedColors, display->getDisplayWidth(), redRect,
+ RED);
+
+ ReadbackBuffer readbackBuffer(
+ display->getDisplayId(), mComposerClient, display->getDisplayWidth(),
+ display->getDisplayHeight(),
+ mDisplayProperties.at(display->getDisplayId()).pixelFormat,
+ mDisplayProperties.at(display->getDisplayId()).dataspace);
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
+
+ writeLayers(layers, display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.validateDisplay(display->getDisplayId(),
+ ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
+ execute(display->getDisplayId());
+ if (!mDisplayProperties.at(display->getDisplayId())
+ .reader.takeChangedCompositionTypes(display->getDisplayId())
+ .empty()) {
+ continue;
+ }
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.presentDisplay(display->getDisplayId());
+ execute(display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
+
+ redLayer->setZOrder(1);
+ ReadbackHelper::clearColors(expectedColors, display->getDisplayWidth(),
+ display->getDisplayHeight(), display->getDisplayWidth());
+ ReadbackHelper::fillColorsArea(expectedColors, display->getDisplayWidth(), redRect,
+ RED);
+ ReadbackHelper::fillColorsArea(expectedColors, display->getDisplayWidth(), blueRect,
+ BLUE);
+
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
+
+ writeLayers(layers, display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.validateDisplay(display->getDisplayId(),
+ ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
+ execute(display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId())
+ .reader.takeChangedCompositionTypes(display->getDisplayId())
+ .empty());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.presentDisplay(display->getDisplayId());
+ execute(display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
+ auto& testRenderEngine =
+ mDisplayProperties.at(display->getDisplayId()).testRenderEngine;
+ testRenderEngine->setRenderLayers(layers);
+ ASSERT_NO_FATAL_FAILURE(testRenderEngine->drawLayers());
+ ASSERT_NO_FATAL_FAILURE(testRenderEngine->checkColorBuffer(expectedColors));
}
-
- common::Rect redRect = {0, 0, getDisplayWidth(), getDisplayHeight() / 2};
- common::Rect blueRect = {0, getDisplayHeight() / 4, getDisplayWidth(), getDisplayHeight()};
- auto redLayer =
- std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId(), *mWriter);
- redLayer->setColor(RED);
- redLayer->setDisplayFrame(redRect);
-
- auto blueLayer =
- std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId(), *mWriter);
- blueLayer->setColor(BLUE);
- blueLayer->setDisplayFrame(blueRect);
- blueLayer->setZOrder(5);
-
- std::vector<std::shared_ptr<TestLayer>> layers = {redLayer, blueLayer};
- std::vector<Color> expectedColors(
- static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
-
- // red in front of blue
- redLayer->setZOrder(10);
-
- // fill blue first so that red will overwrite on overlap
- ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), blueRect, BLUE);
- ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), redRect, RED);
-
- ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
- getDisplayHeight(), mPixelFormat, mDataspace);
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
-
- writeLayers(layers);
- ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- ComposerClientWrapper::kNoFrameIntervalNs);
- execute();
- if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
- GTEST_SUCCEED();
- return;
- }
- mWriter->presentDisplay(getPrimaryDisplayId());
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
-
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
-
- redLayer->setZOrder(1);
- ReadbackHelper::clearColors(expectedColors, getDisplayWidth(), getDisplayHeight(),
- getDisplayWidth());
- ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), redRect, RED);
- ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), blueRect, BLUE);
-
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
-
- writeLayers(layers);
- ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- ComposerClientWrapper::kNoFrameIntervalNs);
- execute();
- ASSERT_TRUE(mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty());
- ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter->presentDisplay(getPrimaryDisplayId());
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
-
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
- mTestRenderEngine->setRenderLayers(layers);
- ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->drawLayers());
- ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->checkColorBuffer(expectedColors));
}
}
TEST_P(GraphicsCompositionTest, SetLayerBrightnessDims) {
- for (ColorMode mode : mTestColorModes) {
- EXPECT_TRUE(mComposerClient
- ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
- .isOk());
+ for (const DisplayWrapper* display : mDisplaysWithReadbackBuffers) {
+ for (ColorMode mode : mDisplayProperties.at(display->getDisplayId()).testColorModes) {
+ EXPECT_TRUE(mComposerClient
+ ->setColorMode(display->getDisplayId(), mode,
+ RenderIntent::COLORIMETRIC)
+ .isOk());
- bool isSupported;
- ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
- if (!isSupported) {
- GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace for "
- "color mode: "
- << toString(mode);
- continue;
+ const common::Rect redRect = {0, 0, display->getDisplayWidth(),
+ display->getDisplayHeight() / 2};
+ const common::Rect dimmerRedRect = {0, display->getDisplayHeight() / 2,
+ display->getDisplayWidth(),
+ display->getDisplayHeight()};
+
+ static constexpr float kMaxBrightnessNits = 300.f;
+
+ const auto redLayer = std::make_shared<TestColorLayer>(
+ mComposerClient, display->getDisplayId(),
+ mDisplayProperties.at(display->getDisplayId()).writer);
+ redLayer->setColor(RED);
+ redLayer->setDisplayFrame(redRect);
+ redLayer->setWhitePointNits(kMaxBrightnessNits);
+ redLayer->setBrightness(1.f);
+
+ const auto dimmerRedLayer = std::make_shared<TestColorLayer>(
+ mComposerClient, display->getDisplayId(),
+ mDisplayProperties.at(display->getDisplayId()).writer);
+ dimmerRedLayer->setColor(RED);
+ dimmerRedLayer->setDisplayFrame(dimmerRedRect);
+ // Intentionally use a small dimming ratio as some implementations may be more likely
+ // to kick into GPU composition to apply dithering when the dimming ratio is high.
+ static constexpr float kDimmingRatio = 0.9f;
+ dimmerRedLayer->setWhitePointNits(kMaxBrightnessNits * kDimmingRatio);
+ dimmerRedLayer->setBrightness(kDimmingRatio);
+
+ const std::vector<std::shared_ptr<TestLayer>> layers = {redLayer, dimmerRedLayer};
+ std::vector<Color> expectedColors(
+ static_cast<size_t>(display->getDisplayWidth() * display->getDisplayHeight()));
+
+ ReadbackHelper::fillColorsArea(expectedColors, display->getDisplayWidth(), redRect,
+ RED);
+ ReadbackHelper::fillColorsArea(expectedColors, display->getDisplayWidth(),
+ dimmerRedRect, DIM_RED);
+
+ ReadbackBuffer readbackBuffer(
+ display->getDisplayId(), mComposerClient, display->getDisplayWidth(),
+ display->getDisplayHeight(),
+ mDisplayProperties.at(display->getDisplayId()).pixelFormat,
+ mDisplayProperties.at(display->getDisplayId()).dataspace);
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
+
+ writeLayers(layers, display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.validateDisplay(display->getDisplayId(),
+ ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
+ execute(display->getDisplayId());
+ if (!mDisplayProperties.at(display->getDisplayId())
+ .reader.takeChangedCompositionTypes(display->getDisplayId())
+ .empty()) {
+ ALOGI(" Readback verification not supported for GPU composition for color mode %d",
+ mode);
+ continue;
+ }
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.presentDisplay(display->getDisplayId());
+ execute(display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
+ auto& testRenderEngine =
+ mDisplayProperties.at(display->getDisplayId()).testRenderEngine;
+ testRenderEngine->setRenderLayers(layers);
+ ASSERT_NO_FATAL_FAILURE(testRenderEngine->drawLayers());
+ ASSERT_NO_FATAL_FAILURE(testRenderEngine->checkColorBuffer(expectedColors));
}
- const common::Rect redRect = {0, 0, getDisplayWidth(), getDisplayHeight() / 2};
- const common::Rect dimmerRedRect = {0, getDisplayHeight() / 2, getDisplayWidth(),
- getDisplayHeight()};
-
- static constexpr float kMaxBrightnessNits = 300.f;
-
- const auto redLayer =
- std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId(), *mWriter);
- redLayer->setColor(RED);
- redLayer->setDisplayFrame(redRect);
- redLayer->setWhitePointNits(kMaxBrightnessNits);
- redLayer->setBrightness(1.f);
-
- const auto dimmerRedLayer =
- std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId(), *mWriter);
- dimmerRedLayer->setColor(RED);
- dimmerRedLayer->setDisplayFrame(dimmerRedRect);
- // Intentionally use a small dimming ratio as some implementations may be more likely to
- // kick into GPU composition to apply dithering when the dimming ratio is high.
- static constexpr float kDimmingRatio = 0.9f;
- dimmerRedLayer->setWhitePointNits(kMaxBrightnessNits * kDimmingRatio);
- dimmerRedLayer->setBrightness(kDimmingRatio);
-
- const std::vector<std::shared_ptr<TestLayer>> layers = {redLayer, dimmerRedLayer};
- std::vector<Color> expectedColors(
- static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
-
- ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), redRect, RED);
- ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), dimmerRedRect, DIM_RED);
-
- ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
- getDisplayHeight(), mPixelFormat, mDataspace);
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
-
- writeLayers(layers);
- ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- ComposerClientWrapper::kNoFrameIntervalNs);
- execute();
- if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
- GTEST_SUCCEED()
- << "Readback verification not supported for GPU composition for color mode: "
- << toString(mode);
- continue;
- }
- mWriter->presentDisplay(getPrimaryDisplayId());
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
-
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
- mTestRenderEngine->setRenderLayers(layers);
- ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->drawLayers());
- ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->checkColorBuffer(expectedColors));
}
}
@@ -1176,38 +1359,49 @@
public:
void SetUp() override {
SetUpBase(std::get<0>(GetParam()));
- // TODO(b/219590743) we should remove the below SRGB color mode
- // once we have the BlendMode test fix for all the versions of the ColorMode
- mTestColorModes.erase(
- std::remove_if(mTestColorModes.begin(), mTestColorModes.end(),
- [](ColorMode mode) { return mode != ColorMode::SRGB; }),
- mTestColorModes.end());
- mBackgroundColor = BLACK;
- mTopLayerColor = RED;
+ for (const DisplayWrapper& display : mAllDisplays) {
+ // TODO(b/219590743) we should remove the below SRGB color mode
+ // once we have the BlendMode test fix for all the versions of the ColorMode
+ auto& testColorModes = mDisplayProperties.at(display.getDisplayId()).testColorModes;
+ testColorModes.erase(
+ std::remove_if(testColorModes.begin(), testColorModes.end(),
+ [](ColorMode mode) { return mode != ColorMode::SRGB; }),
+ testColorModes.end());
+ }
}
- void setBackgroundColor(Color color) { mBackgroundColor = color; }
+ void setBackgroundColor(int64_t displayId, Color color) {
+ mDisplayGfx[displayId].backgroundColor = color;
+ }
- void setTopLayerColor(Color color) { mTopLayerColor = color; }
+ void setTopLayerColor(int64_t displayId, Color color) {
+ mDisplayGfx[displayId].topLayerColor = color;
+ }
- void setUpLayers(BlendMode blendMode) {
- mLayers.clear();
+ void setUpLayers(const DisplayWrapper& display, BlendMode blendMode) {
+ auto& layers = mDisplayGfx[display.getDisplayId()].layers;
+ layers.clear();
+
std::vector<Color> topLayerPixelColors(
- static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
- ReadbackHelper::fillColorsArea(topLayerPixelColors, getDisplayWidth(),
- {0, 0, getDisplayWidth(), getDisplayHeight()},
- mTopLayerColor);
+ static_cast<size_t>(display.getDisplayWidth() * display.getDisplayHeight()));
+ ReadbackHelper::fillColorsArea(
+ topLayerPixelColors, display.getDisplayWidth(),
+ {0, 0, display.getDisplayWidth(), display.getDisplayHeight()},
+ mDisplayGfx[display.getDisplayId()].topLayerColor);
- auto backgroundLayer =
- std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId(), *mWriter);
- backgroundLayer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
+ auto backgroundLayer = std::make_shared<TestColorLayer>(
+ mComposerClient, display.getDisplayId(),
+ mDisplayProperties.at(display.getDisplayId()).writer);
+ backgroundLayer->setDisplayFrame(
+ {0, 0, display.getDisplayWidth(), display.getDisplayHeight()});
backgroundLayer->setZOrder(0);
- backgroundLayer->setColor(mBackgroundColor);
+ backgroundLayer->setColor(mDisplayGfx[display.getDisplayId()].backgroundColor);
auto layer = std::make_shared<TestBufferLayer>(
- mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), getDisplayWidth(),
- getDisplayHeight(), PixelFormat::RGBA_8888, *mWriter);
- layer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
+ mComposerClient, *mDisplayProperties.at(display.getDisplayId()).testRenderEngine,
+ display.getDisplayId(), display.getDisplayWidth(), display.getDisplayHeight(),
+ PixelFormat::RGBA_8888, mDisplayProperties.at(display.getDisplayId()).writer);
+ layer->setDisplayFrame({0, 0, display.getDisplayWidth(), display.getDisplayHeight()});
layer->setZOrder(10);
layer->setDataspace(Dataspace::UNKNOWN);
ASSERT_NO_FATAL_FAILURE(layer->setBuffer(topLayerPixelColors));
@@ -1215,179 +1409,202 @@
layer->setBlendMode(blendMode);
layer->setAlpha(std::stof(std::get<1>(GetParam())));
- mLayers.push_back(backgroundLayer);
- mLayers.push_back(layer);
+ layers.push_back(backgroundLayer);
+ layers.push_back(layer);
}
- void setExpectedColors(std::vector<Color>& expectedColors) {
- ASSERT_EQ(2, mLayers.size());
- ReadbackHelper::clearColors(expectedColors, getDisplayWidth(), getDisplayHeight(),
- getDisplayWidth());
+ void setExpectedColors(const DisplayWrapper& display, std::vector<Color>& expectedColors) {
+ auto& layers = mDisplayGfx[display.getDisplayId()].layers;
+ ASSERT_EQ(2, layers.size());
+ ReadbackHelper::clearColors(expectedColors, display.getDisplayWidth(),
+ display.getDisplayHeight(), display.getDisplayWidth());
- auto layer = mLayers[1];
+ auto layer = layers[1];
BlendMode blendMode = layer->getBlendMode();
- float alpha = mTopLayerColor.a * layer->getAlpha();
+ auto& topLayerColor = mDisplayGfx[display.getDisplayId()].topLayerColor;
+ auto& backgroundColor = mDisplayGfx[display.getDisplayId()].backgroundColor;
+ float alpha = topLayerColor.a * layer->getAlpha();
if (blendMode == BlendMode::NONE) {
for (auto& expectedColor : expectedColors) {
- expectedColor.r = mTopLayerColor.r * layer->getAlpha();
- expectedColor.g = mTopLayerColor.g * layer->getAlpha();
- expectedColor.b = mTopLayerColor.b * layer->getAlpha();
+ expectedColor.r = topLayerColor.r * layer->getAlpha();
+ expectedColor.g = topLayerColor.g * layer->getAlpha();
+ expectedColor.b = topLayerColor.b * layer->getAlpha();
expectedColor.a = alpha;
}
} else if (blendMode == BlendMode::PREMULTIPLIED) {
for (auto& expectedColor : expectedColors) {
expectedColor.r =
- mTopLayerColor.r * layer->getAlpha() + mBackgroundColor.r * (1.0f - alpha);
+ topLayerColor.r * layer->getAlpha() + backgroundColor.r * (1.0f - alpha);
expectedColor.g =
- mTopLayerColor.g * layer->getAlpha() + mBackgroundColor.g * (1.0f - alpha);
+ topLayerColor.g * layer->getAlpha() + backgroundColor.g * (1.0f - alpha);
expectedColor.b =
- mTopLayerColor.b * layer->getAlpha() + mBackgroundColor.b * (1.0f - alpha);
- expectedColor.a = alpha + mBackgroundColor.a * (1.0f - alpha);
+ topLayerColor.b * layer->getAlpha() + backgroundColor.b * (1.0f - alpha);
+ expectedColor.a = alpha + backgroundColor.a * (1.0f - alpha);
}
} else if (blendMode == BlendMode::COVERAGE) {
for (auto& expectedColor : expectedColors) {
- expectedColor.r = mTopLayerColor.r * alpha + mBackgroundColor.r * (1.0f - alpha);
- expectedColor.g = mTopLayerColor.g * alpha + mBackgroundColor.g * (1.0f - alpha);
- expectedColor.b = mTopLayerColor.b * alpha + mBackgroundColor.b * (1.0f - alpha);
- expectedColor.a = mTopLayerColor.a * alpha + mBackgroundColor.a * (1.0f - alpha);
+ expectedColor.r = topLayerColor.r * alpha + backgroundColor.r * (1.0f - alpha);
+ expectedColor.g = topLayerColor.g * alpha + backgroundColor.g * (1.0f - alpha);
+ expectedColor.b = topLayerColor.b * alpha + backgroundColor.b * (1.0f - alpha);
+ expectedColor.a = topLayerColor.a * alpha + backgroundColor.a * (1.0f - alpha);
}
}
}
protected:
- std::vector<std::shared_ptr<TestLayer>> mLayers;
- Color mBackgroundColor;
- Color mTopLayerColor;
+ struct DisplayGraphics {
+ std::vector<std::shared_ptr<TestLayer>> layers;
+ Color backgroundColor = BLACK;
+ Color topLayerColor = RED;
+ };
+
+ std::unordered_map<int64_t, struct DisplayGraphics> mDisplayGfx;
};
TEST_P(GraphicsBlendModeCompositionTest, None) {
- for (ColorMode mode : mTestColorModes) {
- EXPECT_TRUE(mComposerClient
- ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
- .isOk());
+ for (const DisplayWrapper* display : mDisplaysWithReadbackBuffers) {
+ for (ColorMode mode : mDisplayProperties.at(display->getDisplayId()).testColorModes) {
+ EXPECT_TRUE(mComposerClient
+ ->setColorMode(display->getDisplayId(), mode,
+ RenderIntent::COLORIMETRIC)
+ .isOk());
- bool isSupported;
- ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
- if (!isSupported) {
- GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
- return;
+ std::vector<Color> expectedColors(
+ static_cast<size_t>(display->getDisplayWidth() * display->getDisplayHeight()));
+
+ setBackgroundColor(display->getDisplayId(), BLACK);
+ setTopLayerColor(display->getDisplayId(), TRANSLUCENT_RED);
+ setUpLayers(*display, BlendMode::NONE);
+ setExpectedColors(*display, expectedColors);
+
+ ReadbackBuffer readbackBuffer(
+ display->getDisplayId(), mComposerClient, display->getDisplayWidth(),
+ display->getDisplayHeight(),
+ mDisplayProperties.at(display->getDisplayId()).pixelFormat,
+ mDisplayProperties.at(display->getDisplayId()).dataspace);
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
+ auto& layers = mDisplayGfx[display->getDisplayId()].layers;
+ writeLayers(layers, display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.validateDisplay(display->getDisplayId(),
+ ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
+ execute(display->getDisplayId());
+ if (!mDisplayProperties.at(display->getDisplayId())
+ .reader.takeChangedCompositionTypes(display->getDisplayId())
+ .empty()) {
+ continue;
+ }
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.presentDisplay(display->getDisplayId());
+ execute(display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
+ auto& testRenderEngine =
+ mDisplayProperties.at(display->getDisplayId()).testRenderEngine;
+ testRenderEngine->setRenderLayers(layers);
+ ASSERT_NO_FATAL_FAILURE(testRenderEngine->drawLayers());
+ ASSERT_NO_FATAL_FAILURE(testRenderEngine->checkColorBuffer(expectedColors));
}
-
- std::vector<Color> expectedColors(
- static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
-
- setBackgroundColor(BLACK);
- setTopLayerColor(TRANSLUCENT_RED);
- setUpLayers(BlendMode::NONE);
- setExpectedColors(expectedColors);
-
- ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
- getDisplayHeight(), mPixelFormat, mDataspace);
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
- writeLayers(mLayers);
- ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- ComposerClientWrapper::kNoFrameIntervalNs);
- execute();
- if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
- GTEST_SUCCEED();
- return;
- }
- ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter->presentDisplay(getPrimaryDisplayId());
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
-
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
- mTestRenderEngine->setRenderLayers(mLayers);
- ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->drawLayers());
- ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->checkColorBuffer(expectedColors));
}
}
TEST_P(GraphicsBlendModeCompositionTest, Coverage) {
- for (ColorMode mode : mTestColorModes) {
- EXPECT_TRUE(mComposerClient
- ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
- .isOk());
+ for (const DisplayWrapper* display : mDisplaysWithReadbackBuffers) {
+ for (ColorMode mode : mDisplayProperties.at(display->getDisplayId()).testColorModes) {
+ EXPECT_TRUE(mComposerClient
+ ->setColorMode(display->getDisplayId(), mode,
+ RenderIntent::COLORIMETRIC)
+ .isOk());
- bool isSupported;
- ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
- if (!isSupported) {
- GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
- return;
+ std::vector<Color> expectedColors(
+ static_cast<size_t>(display->getDisplayWidth() * display->getDisplayHeight()));
+
+ setBackgroundColor(display->getDisplayId(), BLACK);
+ setTopLayerColor(display->getDisplayId(), TRANSLUCENT_RED);
+
+ setUpLayers(*display, BlendMode::COVERAGE);
+ setExpectedColors(*display, expectedColors);
+
+ ReadbackBuffer readbackBuffer(
+ display->getDisplayId(), mComposerClient, display->getDisplayWidth(),
+ display->getDisplayHeight(),
+ mDisplayProperties.at(display->getDisplayId()).pixelFormat,
+ mDisplayProperties.at(display->getDisplayId()).dataspace);
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
+ auto& layers = mDisplayGfx[display->getDisplayId()].layers;
+ writeLayers(layers, display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.validateDisplay(display->getDisplayId(),
+ ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
+ execute(display->getDisplayId());
+ if (!mDisplayProperties.at(display->getDisplayId())
+ .reader.takeChangedCompositionTypes(display->getDisplayId())
+ .empty()) {
+ continue;
+ }
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.presentDisplay(display->getDisplayId());
+ execute(display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
}
-
- std::vector<Color> expectedColors(
- static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
-
- setBackgroundColor(BLACK);
- setTopLayerColor(TRANSLUCENT_RED);
-
- setUpLayers(BlendMode::COVERAGE);
- setExpectedColors(expectedColors);
-
- ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
- getDisplayHeight(), mPixelFormat, mDataspace);
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
- writeLayers(mLayers);
- ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- ComposerClientWrapper::kNoFrameIntervalNs);
- execute();
- if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
- GTEST_SUCCEED();
- return;
- }
- ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter->presentDisplay(getPrimaryDisplayId());
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
}
}
TEST_P(GraphicsBlendModeCompositionTest, Premultiplied) {
- for (ColorMode mode : mTestColorModes) {
- EXPECT_TRUE(mComposerClient
- ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
- .isOk());
+ for (const DisplayWrapper* display : mDisplaysWithReadbackBuffers) {
+ for (ColorMode mode : mDisplayProperties.at(display->getDisplayId()).testColorModes) {
+ EXPECT_TRUE(mComposerClient
+ ->setColorMode(display->getDisplayId(), mode,
+ RenderIntent::COLORIMETRIC)
+ .isOk());
- bool isSupported;
- ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
- if (!isSupported) {
- GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
- return;
+ std::vector<Color> expectedColors(
+ static_cast<size_t>(display->getDisplayWidth() * display->getDisplayHeight()));
+
+ setBackgroundColor(display->getDisplayId(), BLACK);
+ setTopLayerColor(display->getDisplayId(), TRANSLUCENT_RED);
+ setUpLayers(*display, BlendMode::PREMULTIPLIED);
+ setExpectedColors(*display, expectedColors);
+
+ ReadbackBuffer readbackBuffer(
+ display->getDisplayId(), mComposerClient, display->getDisplayWidth(),
+ display->getDisplayHeight(),
+ mDisplayProperties.at(display->getDisplayId()).pixelFormat,
+ mDisplayProperties.at(display->getDisplayId()).dataspace);
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
+ auto& layers = mDisplayGfx[display->getDisplayId()].layers;
+ writeLayers(layers, display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.validateDisplay(display->getDisplayId(),
+ ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
+ execute(display->getDisplayId());
+ if (!mDisplayProperties.at(display->getDisplayId())
+ .reader.takeChangedCompositionTypes(display->getDisplayId())
+ .empty()) {
+ continue;
+ }
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.presentDisplay(display->getDisplayId());
+ execute(display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
+ auto& testRenderEngine =
+ mDisplayProperties.at(display->getDisplayId()).testRenderEngine;
+ testRenderEngine->setRenderLayers(layers);
+ ASSERT_NO_FATAL_FAILURE(testRenderEngine->drawLayers());
+ ASSERT_NO_FATAL_FAILURE(testRenderEngine->checkColorBuffer(expectedColors));
}
-
- std::vector<Color> expectedColors(
- static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
-
- setBackgroundColor(BLACK);
- setTopLayerColor(TRANSLUCENT_RED);
- setUpLayers(BlendMode::PREMULTIPLIED);
- setExpectedColors(expectedColors);
-
- ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
- getDisplayHeight(), mPixelFormat, mDataspace);
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
- writeLayers(mLayers);
- ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- ComposerClientWrapper::kNoFrameIntervalNs);
- execute();
- if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
- GTEST_SUCCEED();
- return;
- }
- ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter->presentDisplay(getPrimaryDisplayId());
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
- mTestRenderEngine->setRenderLayers(mLayers);
- ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->drawLayers());
- ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->checkColorBuffer(expectedColors));
}
}
@@ -1396,177 +1613,219 @@
void SetUp() override {
GraphicsCompositionTest::SetUp();
- auto backgroundLayer =
- std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId(), *mWriter);
- backgroundLayer->setColor({0.0f, 0.0f, 0.0f, 0.0f});
- backgroundLayer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
- backgroundLayer->setZOrder(0);
+ for (const DisplayWrapper& display : mAllDisplays) {
+ auto backgroundLayer = std::make_shared<TestColorLayer>(
+ mComposerClient, display.getDisplayId(),
+ mDisplayProperties.at(display.getDisplayId()).writer);
+ backgroundLayer->setColor({0.0f, 0.0f, 0.0f, 0.0f});
+ backgroundLayer->setDisplayFrame(
+ {0, 0, display.getDisplayWidth(), display.getDisplayHeight()});
+ backgroundLayer->setZOrder(0);
- mSideLength =
- getDisplayWidth() < getDisplayHeight() ? getDisplayWidth() : getDisplayHeight();
- common::Rect redRect = {0, 0, mSideLength / 2, mSideLength / 2};
- common::Rect blueRect = {mSideLength / 2, mSideLength / 2, mSideLength, mSideLength};
+ int& sideLength = mDisplayGfx[display.getDisplayId()].sideLength;
+ sideLength = display.getDisplayWidth() < display.getDisplayHeight()
+ ? display.getDisplayWidth()
+ : display.getDisplayHeight();
+ common::Rect redRect = {0, 0, sideLength / 2, sideLength / 2};
+ common::Rect blueRect = {sideLength / 2, sideLength / 2, sideLength, sideLength};
- mLayer = std::make_shared<TestBufferLayer>(mComposerClient, *mTestRenderEngine,
- getPrimaryDisplayId(), mSideLength, mSideLength,
- PixelFormat::RGBA_8888, *mWriter);
- mLayer->setDisplayFrame({0, 0, mSideLength, mSideLength});
- mLayer->setZOrder(10);
+ auto& bufferLayer = mDisplayGfx[display.getDisplayId()].bufferLayer;
+ bufferLayer = std::make_shared<TestBufferLayer>(
+ mComposerClient,
+ *mDisplayProperties.at(display.getDisplayId()).testRenderEngine,
+ display.getDisplayId(), static_cast<uint32_t>(sideLength),
+ static_cast<uint32_t>(sideLength), PixelFormat::RGBA_8888,
+ mDisplayProperties.at(display.getDisplayId()).writer);
+ bufferLayer->setDisplayFrame({0, 0, sideLength, sideLength});
+ bufferLayer->setZOrder(10);
- std::vector<Color> baseColors(static_cast<size_t>(mSideLength * mSideLength));
- ReadbackHelper::fillColorsArea(baseColors, mSideLength, redRect, RED);
- ReadbackHelper::fillColorsArea(baseColors, mSideLength, blueRect, BLUE);
- ASSERT_NO_FATAL_FAILURE(mLayer->setBuffer(baseColors));
- mLayers = {backgroundLayer, mLayer};
+ std::vector<Color> baseColors(static_cast<size_t>(sideLength * sideLength));
+ ReadbackHelper::fillColorsArea(baseColors, sideLength, redRect, RED);
+ ReadbackHelper::fillColorsArea(baseColors, sideLength, blueRect, BLUE);
+ ASSERT_NO_FATAL_FAILURE(bufferLayer->setBuffer(baseColors));
+ mDisplayGfx[display.getDisplayId()].layers = {backgroundLayer, bufferLayer};
+ }
}
protected:
- std::shared_ptr<TestBufferLayer> mLayer;
- std::vector<std::shared_ptr<TestLayer>> mLayers;
- int mSideLength;
+ struct DisplayGraphics {
+ std::shared_ptr<TestBufferLayer> bufferLayer;
+ std::vector<std::shared_ptr<TestLayer>> layers;
+ int sideLength;
+ };
+
+ std::unordered_map<int64_t, struct DisplayGraphics> mDisplayGfx;
};
TEST_P(GraphicsTransformCompositionTest, FLIP_H) {
- for (ColorMode mode : mTestColorModes) {
- auto status = mComposerClient->setColorMode(getPrimaryDisplayId(), mode,
- RenderIntent::COLORIMETRIC);
- if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
- (status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED ||
- status.getServiceSpecificError() == IComposerClient::EX_BAD_PARAMETER)) {
- SUCCEED() << "ColorMode not supported, skip test";
- return;
+ for (const DisplayWrapper* display : mDisplaysWithReadbackBuffers) {
+ for (ColorMode mode : mDisplayProperties.at(display->getDisplayId()).testColorModes) {
+ auto status = mComposerClient->setColorMode(display->getDisplayId(), mode,
+ RenderIntent::COLORIMETRIC);
+ if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
+ (status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED ||
+ status.getServiceSpecificError() == IComposerClient::EX_BAD_PARAMETER)) {
+ ALOGI("ColorMode not supported on Display %" PRId64 " for ColorMode %d",
+ display->getDisplayId(), mode);
+ continue;
+ }
+
+ ReadbackBuffer readbackBuffer(
+ display->getDisplayId(), mComposerClient, display->getDisplayWidth(),
+ display->getDisplayHeight(),
+ mDisplayProperties.at(display->getDisplayId()).pixelFormat,
+ mDisplayProperties.at(display->getDisplayId()).dataspace);
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
+ auto& bufferLayer = mDisplayGfx[display->getDisplayId()].bufferLayer;
+ bufferLayer->setTransform(Transform::FLIP_H);
+ bufferLayer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode));
+
+ std::vector<Color> expectedColors(
+ static_cast<size_t>(display->getDisplayWidth() * display->getDisplayHeight()));
+ int& sideLength = mDisplayGfx[display->getDisplayId()].sideLength;
+ ReadbackHelper::fillColorsArea(expectedColors, display->getDisplayWidth(),
+ {sideLength / 2, 0, sideLength, sideLength / 2}, RED);
+ ReadbackHelper::fillColorsArea(expectedColors, display->getDisplayWidth(),
+ {0, sideLength / 2, sideLength / 2, sideLength}, BLUE);
+
+ auto& layers = mDisplayGfx[display->getDisplayId()].layers;
+ writeLayers(layers, display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.validateDisplay(display->getDisplayId(),
+ ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
+ execute(display->getDisplayId());
+ if (!mDisplayProperties.at(display->getDisplayId())
+ .reader.takeChangedCompositionTypes(display->getDisplayId())
+ .empty()) {
+ continue;
+ }
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.presentDisplay(display->getDisplayId());
+ execute(display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
+ auto& testRenderEngine =
+ mDisplayProperties.at(display->getDisplayId()).testRenderEngine;
+ testRenderEngine->setRenderLayers(layers);
+ ASSERT_NO_FATAL_FAILURE(testRenderEngine->drawLayers());
+ ASSERT_NO_FATAL_FAILURE(testRenderEngine->checkColorBuffer(expectedColors));
}
-
- bool isSupported;
- ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
- if (!isSupported) {
- GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
- return;
- }
- ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
- getDisplayHeight(), mPixelFormat, mDataspace);
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
- mLayer->setTransform(Transform::FLIP_H);
- mLayer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode));
-
- std::vector<Color> expectedColors(
- static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
- ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(),
- {mSideLength / 2, 0, mSideLength, mSideLength / 2}, RED);
- ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(),
- {0, mSideLength / 2, mSideLength / 2, mSideLength}, BLUE);
-
- writeLayers(mLayers);
- ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- ComposerClientWrapper::kNoFrameIntervalNs);
- execute();
- if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
- GTEST_SUCCEED();
- return;
- }
- ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter->presentDisplay(getPrimaryDisplayId());
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
-
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
- mTestRenderEngine->setRenderLayers(mLayers);
- ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->drawLayers());
- ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->checkColorBuffer(expectedColors));
}
}
TEST_P(GraphicsTransformCompositionTest, FLIP_V) {
- for (ColorMode mode : mTestColorModes) {
- EXPECT_TRUE(mComposerClient
- ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
- .isOk());
+ for (const DisplayWrapper* display : mDisplaysWithReadbackBuffers) {
+ for (ColorMode mode : mDisplayProperties.at(display->getDisplayId()).testColorModes) {
+ EXPECT_TRUE(mComposerClient
+ ->setColorMode(display->getDisplayId(), mode,
+ RenderIntent::COLORIMETRIC)
+ .isOk());
- bool isSupported;
- ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
- if (!isSupported) {
- GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
- return;
+ ReadbackBuffer readbackBuffer(
+ display->getDisplayId(), mComposerClient, display->getDisplayWidth(),
+ display->getDisplayHeight(),
+ mDisplayProperties.at(display->getDisplayId()).pixelFormat,
+ mDisplayProperties.at(display->getDisplayId()).dataspace);
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
+
+ auto& bufferLayer = mDisplayGfx[display->getDisplayId()].bufferLayer;
+ bufferLayer->setTransform(Transform::FLIP_V);
+ bufferLayer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode));
+
+ std::vector<Color> expectedColors(
+ static_cast<size_t>(display->getDisplayWidth() * display->getDisplayHeight()));
+ int& sideLength = mDisplayGfx[display->getDisplayId()].sideLength;
+ ReadbackHelper::fillColorsArea(expectedColors, display->getDisplayWidth(),
+ {0, sideLength / 2, sideLength / 2, sideLength}, RED);
+ ReadbackHelper::fillColorsArea(expectedColors, display->getDisplayWidth(),
+ {sideLength / 2, 0, sideLength, sideLength / 2}, BLUE);
+
+ auto& layers = mDisplayGfx[display->getDisplayId()].layers;
+ writeLayers(layers, display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.validateDisplay(display->getDisplayId(),
+ ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
+ execute(display->getDisplayId());
+ if (!mDisplayProperties.at(display->getDisplayId())
+ .reader.takeChangedCompositionTypes(display->getDisplayId())
+ .empty()) {
+ continue;
+ }
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.presentDisplay(display->getDisplayId());
+ execute(display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
+ auto& testRenderEngine =
+ mDisplayProperties.at(display->getDisplayId()).testRenderEngine;
+ testRenderEngine->setRenderLayers(layers);
+ ASSERT_NO_FATAL_FAILURE(testRenderEngine->drawLayers());
+ ASSERT_NO_FATAL_FAILURE(testRenderEngine->checkColorBuffer(expectedColors));
}
- ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
- getDisplayHeight(), mPixelFormat, mDataspace);
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
-
- mLayer->setTransform(Transform::FLIP_V);
- mLayer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode));
-
- std::vector<Color> expectedColors(
- static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
- ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(),
- {0, mSideLength / 2, mSideLength / 2, mSideLength}, RED);
- ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(),
- {mSideLength / 2, 0, mSideLength, mSideLength / 2}, BLUE);
-
- writeLayers(mLayers);
- ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- ComposerClientWrapper::kNoFrameIntervalNs);
- execute();
- if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
- GTEST_SUCCEED();
- return;
- }
- ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter->presentDisplay(getPrimaryDisplayId());
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
- mTestRenderEngine->setRenderLayers(mLayers);
- ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->drawLayers());
- ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->checkColorBuffer(expectedColors));
}
}
TEST_P(GraphicsTransformCompositionTest, ROT_180) {
- for (ColorMode mode : mTestColorModes) {
- EXPECT_TRUE(mComposerClient
- ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
- .isOk());
+ for (const DisplayWrapper* display : mDisplaysWithReadbackBuffers) {
+ for (ColorMode mode : mDisplayProperties.at(display->getDisplayId()).testColorModes) {
+ EXPECT_TRUE(mComposerClient
+ ->setColorMode(display->getDisplayId(), mode,
+ RenderIntent::COLORIMETRIC)
+ .isOk());
- bool isSupported;
- ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
- if (!isSupported) {
- GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
- return;
+ ReadbackBuffer readbackBuffer(
+ display->getDisplayId(), mComposerClient, display->getDisplayWidth(),
+ display->getDisplayHeight(),
+ mDisplayProperties.at(display->getDisplayId()).pixelFormat,
+ mDisplayProperties.at(display->getDisplayId()).dataspace);
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
+
+ auto& bufferLayer = mDisplayGfx[display->getDisplayId()].bufferLayer;
+ bufferLayer->setTransform(Transform::ROT_180);
+ bufferLayer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode));
+
+ std::vector<Color> expectedColors(
+ static_cast<size_t>(display->getDisplayWidth() * display->getDisplayHeight()));
+ int& sideLength = mDisplayGfx[display->getDisplayId()].sideLength;
+ ReadbackHelper::fillColorsArea(expectedColors, display->getDisplayWidth(),
+ {sideLength / 2, sideLength / 2, sideLength, sideLength},
+ RED);
+ ReadbackHelper::fillColorsArea(expectedColors, display->getDisplayWidth(),
+ {0, 0, sideLength / 2, sideLength / 2}, BLUE);
+
+ auto& layers = mDisplayGfx[display->getDisplayId()].layers;
+ writeLayers(layers, display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.validateDisplay(display->getDisplayId(),
+ ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
+ execute(display->getDisplayId());
+ if (!mDisplayProperties.at(display->getDisplayId())
+ .reader.takeChangedCompositionTypes(display->getDisplayId())
+ .empty()) {
+ continue;
+ }
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.presentDisplay(display->getDisplayId());
+ execute(display->getDisplayId());
+ ASSERT_TRUE(mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
+ auto& testRenderEngine =
+ mDisplayProperties.at(display->getDisplayId()).testRenderEngine;
+ testRenderEngine->setRenderLayers(layers);
+ ASSERT_NO_FATAL_FAILURE(testRenderEngine->drawLayers());
+ ASSERT_NO_FATAL_FAILURE(testRenderEngine->checkColorBuffer(expectedColors));
}
- ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
- getDisplayHeight(), mPixelFormat, mDataspace);
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
-
- mLayer->setTransform(Transform::ROT_180);
- mLayer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode));
-
- std::vector<Color> expectedColors(
- static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
- ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(),
- {mSideLength / 2, mSideLength / 2, mSideLength, mSideLength},
- RED);
- ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(),
- {0, 0, mSideLength / 2, mSideLength / 2}, BLUE);
-
- writeLayers(mLayers);
- ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- ComposerClientWrapper::kNoFrameIntervalNs);
- execute();
- if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
- GTEST_SUCCEED();
- return;
- }
- ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter->presentDisplay(getPrimaryDisplayId());
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
- mTestRenderEngine->setRenderLayers(mLayers);
- ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->drawLayers());
- ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->checkColorBuffer(expectedColors));
}
}
@@ -1576,92 +1835,117 @@
public:
void SetUp() override {
SetUpBase(std::get<0>(GetParam()));
- // for some reason only sRGB reliably works
- mTestColorModes.erase(
- std::remove_if(mTestColorModes.begin(), mTestColorModes.end(),
- [](ColorMode mode) { return mode != ColorMode::SRGB; }),
- mTestColorModes.end());
- auto standard = std::get<1>(GetParam());
- auto transfer = std::get<2>(GetParam());
- auto range = std::get<3>(GetParam());
+ for (const DisplayWrapper& display : mAllDisplays) {
+ // for some reason only sRGB reliably works
+ auto& testColorModes = mDisplayProperties.at(display.getDisplayId()).testColorModes;
+ testColorModes.erase(
+ std::remove_if(testColorModes.begin(), testColorModes.end(),
+ [](ColorMode mode) { return mode != ColorMode::SRGB; }),
+ testColorModes.end());
+ auto standard = std::get<1>(GetParam());
+ auto transfer = std::get<2>(GetParam());
+ auto range = std::get<3>(GetParam());
- mLayerDataspace = static_cast<Dataspace>(static_cast<int32_t>(standard) |
- static_cast<int32_t>(transfer) |
- static_cast<int32_t>(range));
- ALOGD("Invoking test for dataspace: {%s, %s, %s}", toString(standard).c_str(),
- toString(transfer).c_str(), toString(range).c_str());
+ mDisplayGfx[display.getDisplayId()].layerDataspace = static_cast<Dataspace>(
+ static_cast<int32_t>(standard) | static_cast<int32_t>(transfer) |
+ static_cast<int32_t>(range));
+ ALOGD("Invoking test for dataspace: {%s, %s, %s}", toString(standard).c_str(),
+ toString(transfer).c_str(), toString(range).c_str());
+ }
}
- void makeLayer() {
- mLayer = std::make_shared<TestBufferLayer>(
- mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), getDisplayWidth(),
- getDisplayHeight(), common::PixelFormat::RGBA_8888, *mWriter);
- mLayer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
- mLayer->setZOrder(10);
- mLayer->setAlpha(1.f);
- mLayer->setDataspace(mLayerDataspace);
+ void makeLayer(const DisplayWrapper& display) {
+ auto& layer = mDisplayGfx[display.getDisplayId()].layer;
+ layer = std::make_shared<TestBufferLayer>(
+ mComposerClient, *mDisplayProperties.at(display.getDisplayId()).testRenderEngine,
+ display.getDisplayId(), display.getDisplayWidth(), display.getDisplayHeight(),
+ common::PixelFormat::RGBA_8888,
+ mDisplayProperties.at(display.getDisplayId()).writer);
+ layer->setDisplayFrame({0, 0, display.getDisplayWidth(), display.getDisplayHeight()});
+ layer->setZOrder(10);
+ layer->setAlpha(1.f);
+ layer->setDataspace(mDisplayGfx[display.getDisplayId()].layerDataspace);
}
- void fillColor(Color color) {
- std::vector<Color> baseColors(static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
- ReadbackHelper::fillColorsArea(baseColors, getDisplayWidth(),
+ void fillColor(const DisplayWrapper& display, Color color) {
+ std::vector<Color> baseColors(
+ static_cast<size_t>(display.getDisplayWidth() * display.getDisplayHeight()));
+ ReadbackHelper::fillColorsArea(baseColors, display.getDisplayWidth(),
common::Rect{.left = 0,
.top = 0,
- .right = getDisplayWidth(),
- .bottom = getDisplayHeight()},
+ .right = display.getDisplayWidth(),
+ .bottom = display.getDisplayHeight()},
color);
- ASSERT_NO_FATAL_FAILURE(mLayer->setBuffer(baseColors));
+ ASSERT_NO_FATAL_FAILURE(mDisplayGfx[display.getDisplayId()].layer->setBuffer(baseColors));
}
- Dataspace mLayerDataspace;
- std::shared_ptr<TestBufferLayer> mLayer;
+ struct DisplayGraphics {
+ Dataspace layerDataspace;
+ std::shared_ptr<TestBufferLayer> layer;
+ };
+ std::unordered_map<int64_t, struct DisplayGraphics> mDisplayGfx;
};
// @VsrTest = 4.4-015
TEST_P(GraphicsColorManagementCompositionTest, ColorConversion) {
- for (ColorMode mode : mTestColorModes) {
- EXPECT_TRUE(mComposerClient
- ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
- .isOk());
+ for (const DisplayWrapper* display : mDisplaysWithReadbackBuffers) {
+ for (ColorMode mode : mDisplayProperties.at(display->getDisplayId()).testColorModes) {
+ EXPECT_TRUE(mComposerClient
+ ->setColorMode(display->getDisplayId(), mode,
+ RenderIntent::COLORIMETRIC)
+ .isOk());
- bool isSupported;
- ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
- if (!isSupported) {
- GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
- return;
- }
+ auto& clientCompositionDisplaySettings =
+ mDisplayProperties.at(display->getDisplayId()).clientCompositionDisplaySettings;
+ clientCompositionDisplaySettings.outputDataspace =
+ static_cast<::android::ui::Dataspace>(
+ mDisplayProperties.at(display->getDisplayId()).dataspace);
+ mDisplayProperties.at(display->getDisplayId())
+ .testRenderEngine->setDisplaySettings(clientCompositionDisplaySettings);
- mClientCompositionDisplaySettings.outputDataspace =
- static_cast<::android::ui::Dataspace>(mDataspace);
- mTestRenderEngine->setDisplaySettings(mClientCompositionDisplaySettings);
+ makeLayer(*display);
+ for (auto color : {LIGHT_RED, LIGHT_GREEN, LIGHT_BLUE}) {
+ ALOGD("Testing color: %f, %f, %f, %f with color mode: %d", color.r, color.g,
+ color.b, color.a, mode);
+ ReadbackBuffer readbackBuffer(
+ display->getDisplayId(), mComposerClient, display->getDisplayWidth(),
+ display->getDisplayHeight(),
+ mDisplayProperties.at(display->getDisplayId()).pixelFormat,
+ mDisplayProperties.at(display->getDisplayId()).dataspace);
+ ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
+ fillColor(*display, color);
+ auto& layer = mDisplayGfx[display->getDisplayId()].layer;
+ writeLayers({layer}, display->getDisplayId());
+ EXPECT_TRUE(mComposerClient->setPowerMode(display->getDisplayId(), PowerMode::ON)
+ .isOk());
- makeLayer();
- for (auto color : {LIGHT_RED, LIGHT_GREEN, LIGHT_BLUE}) {
- ALOGD("Testing color: %f, %f, %f, %f with color mode: %d", color.r, color.g, color.b,
- color.a, mode);
- ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
- getDisplayHeight(), mPixelFormat, mDataspace);
- ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
- fillColor(color);
- writeLayers({mLayer});
- EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
+ ASSERT_TRUE(
+ mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.validateDisplay(display->getDisplayId(),
+ ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
+ execute(display->getDisplayId());
+ if (!mDisplayProperties.at(display->getDisplayId())
+ .reader.takeChangedCompositionTypes(display->getDisplayId())
+ .empty()) {
+ continue;
+ }
+ ASSERT_TRUE(
+ mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
+ mDisplayProperties.at(display->getDisplayId())
+ .writer.presentDisplay(display->getDisplayId());
+ execute(display->getDisplayId());
+ ASSERT_TRUE(
+ mDisplayProperties.at(display->getDisplayId()).reader.takeErrors().empty());
- ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- ComposerClientWrapper::kNoFrameIntervalNs);
- execute();
- if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
- continue;
+ auto& testRenderEngine =
+ mDisplayProperties.at(display->getDisplayId()).testRenderEngine;
+ testRenderEngine->setRenderLayers({layer});
+ ASSERT_NO_FATAL_FAILURE(testRenderEngine->drawLayers());
+ ASSERT_NO_FATAL_FAILURE(
+ testRenderEngine->checkColorBuffer(readbackBuffer.getBuffer()));
}
- ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter->presentDisplay(getPrimaryDisplayId());
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
-
- mTestRenderEngine->setRenderLayers({mLayer});
- ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->drawLayers());
- ASSERT_NO_FATAL_FAILURE(
- mTestRenderEngine->checkColorBuffer(readbackBuffer.getBuffer()));
}
}
}
diff --git a/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_TargetTest.cpp b/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_TargetTest.cpp
index 88e5cb5..2ff3b2b 100644
--- a/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_TargetTest.cpp
+++ b/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_TargetTest.cpp
@@ -75,7 +75,8 @@
}
void TearDown() override {
- ASSERT_TRUE(mComposerClient->tearDown(nullptr));
+ ASSERT_TRUE(
+ mComposerClient->tearDown(std::unordered_map<int64_t, ComposerClientWriter*>{}));
mComposerClient.reset();
}
@@ -1481,21 +1482,24 @@
protected:
void TearDown() override {
ASSERT_FALSE(mDisplays.empty());
- ASSERT_TRUE(mReader.takeErrors().empty());
+ std::unordered_map<int64_t, ComposerClientWriter*> displayWriters;
for (const auto& display : mDisplays) {
- ASSERT_TRUE(mReader.takeChangedCompositionTypes(display.getDisplayId()).empty());
- ASSERT_TRUE(mComposerClient->tearDown(&getWriter(display.getDisplayId())));
+ auto& reader = getReader(display.getDisplayId());
+ ASSERT_TRUE(reader.takeErrors().empty());
+ ASSERT_TRUE(reader.takeChangedCompositionTypes(display.getDisplayId()).empty());
+ displayWriters.emplace(display.getDisplayId(), &getWriter(display.getDisplayId()));
}
+ ASSERT_TRUE(mComposerClient->tearDown(displayWriters));
ASSERT_NO_FATAL_FAILURE(GraphicsComposerAidlTest::TearDown());
}
void execute() {
- std::vector<CommandResultPayload> payloads;
- for (auto& [_, writer] : mWriters) {
+ for (auto& [displayId, writer] : mWriters) {
+ std::vector<CommandResultPayload> payloads;
executeInternal(writer, payloads);
+ getReader(displayId).parse(std::move(payloads));
}
- mReader.parse(std::move(payloads));
}
void execute(ComposerClientWriter& writer, ComposerClientReader& reader) {
@@ -1545,21 +1549,18 @@
});
}
- sp<GraphicBuffer> allocate(uint32_t width, uint32_t height,
+ sp<GraphicBuffer> allocate(int32_t displayWidth, int32_t displayHeight,
::android::PixelFormat pixelFormat) {
return sp<GraphicBuffer>::make(
- width, height, pixelFormat, /*layerCount*/ 1U,
+ static_cast<uint32_t>(displayWidth), static_cast<uint32_t>(displayHeight),
+ pixelFormat,
+ /*layerCount*/ 1U,
static_cast<uint64_t>(common::BufferUsage::CPU_WRITE_OFTEN) |
static_cast<uint64_t>(common::BufferUsage::CPU_READ_OFTEN) |
static_cast<uint64_t>(common::BufferUsage::COMPOSER_OVERLAY),
"VtsHalGraphicsComposer3_TargetTest");
}
- sp<GraphicBuffer> allocate(::android::PixelFormat pixelFormat, const DisplayWrapper& display) {
- return allocate(static_cast<uint32_t>(display.getDisplayWidth()),
- static_cast<uint32_t>(display.getDisplayHeight()), pixelFormat);
- }
-
void sendRefreshFrame(const DisplayWrapper& display,
const VsyncPeriodChangeTimeline* timeline) {
if (timeline != nullptr) {
@@ -1580,7 +1581,8 @@
mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
EXPECT_TRUE(status.isOk());
{
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
+ const auto buffer = allocate(display.getDisplayWidth(), display.getDisplayHeight(),
+ ::android::PIXEL_FORMAT_RGBA_8888);
ASSERT_NE(nullptr, buffer);
ASSERT_EQ(::android::OK, buffer->initCheck());
ASSERT_NE(nullptr, buffer->handle);
@@ -1594,15 +1596,16 @@
writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp,
ComposerClientWrapper::kNoFrameIntervalNs);
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
writer.presentDisplay(display.getDisplayId());
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
}
{
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
+ const auto buffer = allocate(display.getDisplayWidth(), display.getDisplayHeight(),
+ ::android::PIXEL_FORMAT_RGBA_8888);
ASSERT_NE(nullptr, buffer->handle);
writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, buffer->handle,
@@ -1612,7 +1615,7 @@
writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp,
ComposerClientWrapper::kNoFrameIntervalNs);
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
writer.presentDisplay(display.getDisplayId());
execute();
@@ -1627,13 +1630,13 @@
auto& writer = getWriter(displayId);
writer.validateDisplay(displayId, expectedPresentTime, frameIntervalNs);
execute();
- EXPECT_TRUE(mReader.takeErrors().empty());
+ EXPECT_TRUE(getReader(displayId).takeErrors().empty());
writer.presentDisplay(displayId);
execute();
- EXPECT_TRUE(mReader.takeErrors().empty());
+ EXPECT_TRUE(getReader(displayId).takeErrors().empty());
- auto presentFence = mReader.takePresentFence(displayId);
+ auto presentFence = getReader(displayId).takePresentFence(displayId);
// take ownership
const int fenceOwner = presentFence.get();
*presentFence.getR() = -1;
@@ -1665,8 +1668,10 @@
return layer;
}
- void sendBufferUpdate(int64_t layer, int64_t displayId) {
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, displayId);
+ void sendBufferUpdate(int64_t layer, int64_t displayId, int32_t displayWidth,
+ int32_t displayHeight) {
+ const auto buffer =
+ allocate(displayWidth, displayHeight, ::android::PIXEL_FORMAT_RGBA_8888);
ASSERT_NE(nullptr, buffer->handle);
auto& writer = getWriter(displayId);
@@ -1776,8 +1781,10 @@
const auto vsyncPeriod = getVsyncPeriod(display.getDisplayId());
- const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
- const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
+ const auto buffer1 = allocate(display.getDisplayWidth(), display.getDisplayHeight(),
+ ::android::PIXEL_FORMAT_RGBA_8888);
+ const auto buffer2 = allocate(display.getDisplayWidth(), display.getDisplayHeight(),
+ ::android::PIXEL_FORMAT_RGBA_8888);
ASSERT_NE(nullptr, buffer1);
ASSERT_NE(nullptr, buffer2);
@@ -1874,12 +1881,16 @@
// clang-format on
ComposerClientWriter& getWriter(int64_t display) {
- std::lock_guard guard{mWritersMutex};
+ std::lock_guard guard{mReadersWritersMutex};
auto [it, _] = mWriters.try_emplace(display, display);
return it->second;
}
- ComposerClientReader mReader;
+ ComposerClientReader& getReader(int64_t display) {
+ std::lock_guard guard{mReadersWritersMutex};
+ auto [it, _] = mReaders.try_emplace(display, display);
+ return it->second;
+ }
private:
void executeInternal(ComposerClientWriter& writer,
@@ -1901,8 +1912,9 @@
// - modify the same writer from multiple threads
// - insert a new writer into the map during concurrent access, which would invalidate
// references from other threads
- std::mutex mWritersMutex;
- std::unordered_map<int64_t, ComposerClientWriter> mWriters GUARDED_BY(mWritersMutex);
+ std::mutex mReadersWritersMutex;
+ std::unordered_map<int64_t, ComposerClientWriter> mWriters GUARDED_BY(mReadersWritersMutex);
+ std::unordered_map<int64_t, ComposerClientReader> mReaders GUARDED_BY(mReadersWritersMutex);
};
TEST_P(GraphicsComposerAidlCommandTest, SetColorTransform) {
@@ -1922,9 +1934,10 @@
writer.setLayerColorTransform(display.getDisplayId(), layer, kIdentity.data());
execute();
- const auto errors = mReader.takeErrors();
+ const auto errors = getReader(display.getDisplayId()).takeErrors();
if (errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_UNSUPPORTED) {
- GTEST_SUCCEED() << "setLayerColorTransform is not supported";
+ ALOGI("setLayerColorTransform is not supported on display %" PRId64,
+ display.getDisplayId());
continue;
}
}
@@ -1932,6 +1945,7 @@
TEST_P(GraphicsComposerAidlCommandTest, SetDisplayBrightness) {
for (const auto& display : mDisplays) {
+ EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::ON).isOk());
const auto& [status, capabilities] =
mComposerClient->getDisplayCapabilities(display.getDisplayId());
ASSERT_TRUE(status.isOk());
@@ -1941,33 +1955,34 @@
if (!brightnessSupport) {
writer.setDisplayBrightness(display.getDisplayId(), /*brightness*/ 0.5f, -1.f);
execute();
- const auto errors = mReader.takeErrors();
+ const auto errors = getReader(display.getDisplayId()).takeErrors();
ASSERT_EQ(1, errors.size());
EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, errors[0].errorCode);
- GTEST_SUCCEED() << "SetDisplayBrightness is not supported";
+ ALOGI("SetDisplayBrightness is not supported on display %" PRId64,
+ display.getDisplayId());
continue;
}
writer.setDisplayBrightness(display.getDisplayId(), /*brightness*/ 0.0f, -1.f);
execute();
- EXPECT_TRUE(mReader.takeErrors().empty());
+ EXPECT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
writer.setDisplayBrightness(display.getDisplayId(), /*brightness*/ 0.5f, -1.f);
execute();
- EXPECT_TRUE(mReader.takeErrors().empty());
+ EXPECT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
writer.setDisplayBrightness(display.getDisplayId(), /*brightness*/ 1.0f, -1.f);
execute();
- EXPECT_TRUE(mReader.takeErrors().empty());
+ EXPECT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
writer.setDisplayBrightness(display.getDisplayId(), /*brightness*/ -1.0f, -1.f);
execute();
- EXPECT_TRUE(mReader.takeErrors().empty());
+ EXPECT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
writer.setDisplayBrightness(display.getDisplayId(), /*brightness*/ 2.0f, -1.f);
execute();
{
- const auto errors = mReader.takeErrors();
+ const auto errors = getReader(display.getDisplayId()).takeErrors();
ASSERT_EQ(1, errors.size());
EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
}
@@ -1975,7 +1990,7 @@
writer.setDisplayBrightness(display.getDisplayId(), /*brightness*/ 2.0f, -1.f);
execute();
{
- const auto errors = mReader.takeErrors();
+ const auto errors = getReader(display.getDisplayId()).takeErrors();
ASSERT_EQ(1, errors.size());
EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
}
@@ -2011,7 +2026,8 @@
// Use dimensions from the primary display
const DisplayWrapper& primary = mDisplays[0];
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, primary);
+ const auto buffer = allocate(primary.getDisplayWidth(), primary.getDisplayHeight(),
+ ::android::PIXEL_FORMAT_RGBA_8888);
const auto handle = buffer->handle;
auto& writer = getWriter(display.display);
writer.setOutputBuffer(display.display, /*slot*/ 0, handle,
@@ -2068,7 +2084,8 @@
mComposerClient->setColorMode(display.getDisplayId(), ColorMode::NATIVE, intent)
.isOk());
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
+ const auto buffer = allocate(display.getDisplayWidth(), display.getDisplayHeight(),
+ ::android::PIXEL_FORMAT_RGBA_8888);
const auto handle = buffer->handle;
ASSERT_NE(nullptr, handle);
@@ -2086,17 +2103,20 @@
writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp,
ComposerClientWrapper::kNoFrameIntervalNs);
execute();
- if (!mReader.takeChangedCompositionTypes(display.getDisplayId()).empty()) {
+ if (!getReader(display.getDisplayId())
+ .takeChangedCompositionTypes(display.getDisplayId())
+ .empty()) {
GTEST_SUCCEED() << "Composition change requested, skipping test";
return;
}
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
writer.presentDisplay(display.getDisplayId());
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
- const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
+ const auto buffer2 = allocate(display.getDisplayWidth(), display.getDisplayHeight(),
+ ::android::PIXEL_FORMAT_RGBA_8888);
const auto handle2 = buffer2->handle;
ASSERT_NE(nullptr, handle2);
writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, handle2,
@@ -2116,7 +2136,8 @@
mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
EXPECT_TRUE(layerStatus.isOk());
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
+ const auto buffer = allocate(display.getDisplayWidth(), display.getDisplayHeight(),
+ ::android::PIXEL_FORMAT_RGBA_8888);
const auto handle = buffer->handle;
ASSERT_NE(nullptr, handle);
@@ -2132,11 +2153,13 @@
execute();
- if (!mReader.takeChangedCompositionTypes(display.getDisplayId()).empty()) {
+ if (!getReader(display.getDisplayId())
+ .takeChangedCompositionTypes(display.getDisplayId())
+ .empty()) {
continue; // Skip this display if composition change requested
}
writer.presentDisplay(display.getDisplayId());
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
writer.setLayerCursorPosition(display.getDisplayId(), layer, /*x*/ 1, /*y*/ 1);
execute();
@@ -2150,7 +2173,8 @@
TEST_P(GraphicsComposerAidlCommandTest, SetLayerBuffer) {
for (const auto& display : mDisplays) {
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
+ const auto buffer = allocate(display.getDisplayWidth(), display.getDisplayHeight(),
+ ::android::PIXEL_FORMAT_RGBA_8888);
const auto handle = buffer->handle;
ASSERT_NE(nullptr, handle);
@@ -2177,29 +2201,32 @@
// This is used on HALs that don't support setLayerBufferSlotsToClear (version <= 3.1).
- const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
+ const auto buffer1 = allocate(display.getDisplayWidth(), display.getDisplayHeight(),
+ ::android::PIXEL_FORMAT_RGBA_8888);
ASSERT_NE(nullptr, buffer1);
const auto handle1 = buffer1->handle;
writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, handle1,
/*acquireFence*/ -1);
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
- const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
+ const auto buffer2 = allocate(display.getDisplayWidth(), display.getDisplayHeight(),
+ ::android::PIXEL_FORMAT_RGBA_8888);
ASSERT_NE(nullptr, buffer2);
const auto handle2 = buffer2->handle;
writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 1, handle2,
/*acquireFence*/ -1);
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
- const auto buffer3 = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
+ const auto buffer3 = allocate(display.getDisplayWidth(), display.getDisplayHeight(),
+ ::android::PIXEL_FORMAT_RGBA_8888);
ASSERT_NE(nullptr, buffer3);
const auto handle3 = buffer3->handle;
writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 2, handle3,
/*acquireFence*/ -1);
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
// Older versions of the HAL clear all but the active buffer slot with a placeholder buffer,
// and then restoring the current active buffer at the end
@@ -2216,7 +2243,7 @@
writer.setLayerBufferWithNewCommand(display.getDisplayId(), layer, /*slot*/ 2, nullptr,
/*acquireFence*/ -1);
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
}
}
@@ -2232,15 +2259,15 @@
writer.setLayerSurfaceDamage(display.getDisplayId(), layer, std::vector<Rect>(1, empty));
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
writer.setLayerSurfaceDamage(display.getDisplayId(), layer, std::vector<Rect>(1, unit));
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
writer.setLayerSurfaceDamage(display.getDisplayId(), layer, std::vector<Rect>());
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
}
}
@@ -2256,15 +2283,15 @@
writer.setLayerBlockingRegion(display.getDisplayId(), layer, std::vector<Rect>(1, empty));
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
writer.setLayerBlockingRegion(display.getDisplayId(), layer, std::vector<Rect>(1, unit));
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
writer.setLayerBlockingRegion(display.getDisplayId(), layer, std::vector<Rect>());
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
}
}
@@ -2277,15 +2304,15 @@
writer.setLayerBlendMode(display.getDisplayId(), layer, BlendMode::NONE);
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
writer.setLayerBlendMode(display.getDisplayId(), layer, BlendMode::PREMULTIPLIED);
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
writer.setLayerBlendMode(display.getDisplayId(), layer, BlendMode::COVERAGE);
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
}
}
@@ -2298,11 +2325,11 @@
writer.setLayerColor(display.getDisplayId(), layer, Color{1.0f, 1.0f, 1.0f, 1.0f});
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
writer.setLayerColor(display.getDisplayId(), layer, Color{0.0f, 0.0f, 0.0f, 0.0f});
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
}
}
@@ -2315,15 +2342,15 @@
writer.setLayerCompositionType(display.getDisplayId(), layer, Composition::CLIENT);
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
writer.setLayerCompositionType(display.getDisplayId(), layer, Composition::DEVICE);
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
writer.setLayerCompositionType(display.getDisplayId(), layer, Composition::SOLID_COLOR);
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
writer.setLayerCompositionType(display.getDisplayId(), layer, Composition::CURSOR);
execute();
@@ -2342,7 +2369,8 @@
const auto format = (error.isOk() && support) ? support->format
: aidl::android::hardware::graphics::common::PixelFormat::RGBA_8888;
- const auto decorBuffer = allocate(static_cast<::android::PixelFormat>(format), display);
+ const auto decorBuffer = allocate(display.getDisplayHeight(), display.getDisplayWidth(),
+ static_cast<::android::PixelFormat>(format));
ASSERT_NE(nullptr, decorBuffer);
if (::android::OK != decorBuffer->initCheck()) {
if (support) {
@@ -2364,9 +2392,9 @@
ComposerClientWrapper::kNoFrameIntervalNs);
execute();
if (support) {
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
} else {
- const auto errors = mReader.takeErrors();
+ const auto errors = getReader(display.getDisplayId()).takeErrors();
ASSERT_EQ(1, errors.size());
EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, errors[0].errorCode);
}
@@ -2405,11 +2433,11 @@
writer.setLayerPlaneAlpha(display.getDisplayId(), layer, /*alpha*/ 0.0f);
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
writer.setLayerPlaneAlpha(display.getDisplayId(), layer, /*alpha*/ 1.0f);
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
}
}
@@ -2420,7 +2448,8 @@
}
for (const auto& display : mDisplays) {
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
+ const auto buffer = allocate(display.getDisplayWidth(), display.getDisplayHeight(),
+ ::android::PIXEL_FORMAT_RGBA_8888);
const auto handle = buffer->handle;
ASSERT_NE(nullptr, handle);
@@ -2455,39 +2484,39 @@
writer.setLayerTransform(display.getDisplayId(), layer, static_cast<Transform>(0));
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
writer.setLayerTransform(display.getDisplayId(), layer, Transform::FLIP_H);
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
writer.setLayerTransform(display.getDisplayId(), layer, Transform::FLIP_V);
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
writer.setLayerTransform(display.getDisplayId(), layer, Transform::ROT_90);
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
writer.setLayerTransform(display.getDisplayId(), layer, Transform::ROT_180);
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
writer.setLayerTransform(display.getDisplayId(), layer, Transform::ROT_270);
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
writer.setLayerTransform(display.getDisplayId(), layer,
static_cast<Transform>(static_cast<int>(Transform::FLIP_H) |
static_cast<int>(Transform::ROT_90)));
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
writer.setLayerTransform(display.getDisplayId(), layer,
static_cast<Transform>(static_cast<int>(Transform::FLIP_V) |
static_cast<int>(Transform::ROT_90)));
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
}
}
@@ -2503,15 +2532,15 @@
writer.setLayerVisibleRegion(display.getDisplayId(), layer, std::vector<Rect>(1, empty));
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
writer.setLayerVisibleRegion(display.getDisplayId(), layer, std::vector<Rect>(1, unit));
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
writer.setLayerVisibleRegion(display.getDisplayId(), layer, std::vector<Rect>());
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
}
}
@@ -2525,11 +2554,11 @@
writer.setLayerZOrder(display.getDisplayId(), layer, /*z*/ 10);
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
writer.setLayerZOrder(display.getDisplayId(), layer, /*z*/ 0);
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
}
}
@@ -2568,7 +2597,7 @@
writer.setLayerPerFrameMetadata(display.getDisplayId(), layer, aidlMetadata);
execute();
- const auto errors = mReader.takeErrors();
+ const auto errors = getReader(display.getDisplayId()).takeErrors();
if (errors.size() == 1 && errors[0].errorCode == EX_UNSUPPORTED_OPERATION) {
GTEST_SUCCEED() << "SetLayerPerFrameMetadata is not supported";
EXPECT_TRUE(
@@ -2589,20 +2618,20 @@
writer.setLayerBrightness(display.getDisplayId(), layer, 0.2f);
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
writer.setLayerBrightness(display.getDisplayId(), layer, 1.f);
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
writer.setLayerBrightness(display.getDisplayId(), layer, 0.f);
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
writer.setLayerBrightness(display.getDisplayId(), layer, -1.f);
execute();
{
- const auto errors = mReader.takeErrors();
+ const auto errors = getReader(display.getDisplayId()).takeErrors();
ASSERT_EQ(1, errors.size());
EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
}
@@ -2610,7 +2639,7 @@
writer.setLayerBrightness(display.getDisplayId(), layer, std::nanf(""));
execute();
{
- const auto errors = mReader.takeErrors();
+ const auto errors = getReader(display.getDisplayId()).takeErrors();
ASSERT_EQ(1, errors.size());
EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
}
@@ -2777,7 +2806,8 @@
EXPECT_TRUE(
mComposerClient->setIdleTimerEnabled(display.getDisplayId(), /*timeout*/ 0).isOk());
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
+ const auto buffer = allocate(display.getDisplayWidth(), display.getDisplayHeight(),
+ ::android::PIXEL_FORMAT_RGBA_8888);
ASSERT_NE(nullptr, buffer->handle);
const auto layer = createOnScreenLayer(display);
@@ -2837,36 +2867,39 @@
// setup 3 buffers in the buffer cache, with the last buffer being active
// then emulate the Android platform code that clears all 3 buffer slots
- const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888, display.getDisplayId());
+ const auto buffer1 = allocate(display.getDisplayWidth(), display.getDisplayHeight(),
+ ::android::PIXEL_FORMAT_RGBA_8888);
ASSERT_NE(nullptr, buffer1);
const auto handle1 = buffer1->handle;
writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, handle1,
/*acquireFence*/ -1);
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
- const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888, display.getDisplayId());
+ const auto buffer2 = allocate(display.getDisplayWidth(), display.getDisplayHeight(),
+ ::android::PIXEL_FORMAT_RGBA_8888);
ASSERT_NE(nullptr, buffer2);
const auto handle2 = buffer2->handle;
writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 1, handle2,
/*acquireFence*/ -1);
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
- const auto buffer3 = allocate(::android::PIXEL_FORMAT_RGBA_8888, display.getDisplayId());
+ const auto buffer3 = allocate(display.getDisplayWidth(), display.getDisplayHeight(),
+ ::android::PIXEL_FORMAT_RGBA_8888);
ASSERT_NE(nullptr, buffer3);
const auto handle3 = buffer3->handle;
writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 2, handle3,
/*acquireFence*/ -1);
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
// Ensure we can clear all 3 buffer slots, even the active buffer - it is assumed the
// current active buffer's slot will be cleared, but still remain the active buffer and no
// errors will occur.
writer.setLayerBufferSlotsToClear(display.getDisplayId(), layer, {0, 1, 2});
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
}
}
@@ -2976,8 +3009,9 @@
}
// Send the REFRESH_RATE_INDICATOR update
- ASSERT_NO_FATAL_FAILURE(sendBufferUpdate(
- createOnScreenLayer(display, Composition::REFRESH_RATE_INDICATOR), displayId));
+ ASSERT_NO_FATAL_FAILURE(
+ sendBufferUpdate(createOnScreenLayer(display, Composition::REFRESH_RATE_INDICATOR),
+ displayId, display.getDisplayWidth(), display.getDisplayHeight()));
std::this_thread::sleep_for(1s);
EXPECT_FALSE(checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter))
<< "A callback should not be received for REFRESH_RATE_INDICATOR";
@@ -3100,7 +3134,8 @@
const auto& [status, layer] =
mComposerClient->createLayer(displayId, kBufferSlotCount, &writer);
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, displayId);
+ const auto buffer = allocate(display->getDisplayWidth(), display->getDisplayHeight(),
+ ::android::PIXEL_FORMAT_RGBA_8888);
ASSERT_NE(nullptr, buffer);
ASSERT_EQ(::android::OK, buffer->initCheck());
ASSERT_NE(nullptr, buffer->handle);
@@ -3181,7 +3216,7 @@
mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
EXPECT_TRUE(status.isOk());
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
}
}
@@ -3190,14 +3225,16 @@
GTEST_SKIP() << "LAYER_LIFECYCLE_BATCH_COMMAND not supported by the implementation";
return;
}
- auto& writer = getWriter(getInvalidDisplayId());
+
+ int64_t invalidDisplayId = getInvalidDisplayId();
+ auto& writer = getWriter(invalidDisplayId);
int64_t layer = 5;
- writer.setLayerLifecycleBatchCommandType(getInvalidDisplayId(), layer,
+ writer.setLayerLifecycleBatchCommandType(invalidDisplayId, layer,
LayerLifecycleBatchCommandType::CREATE);
- writer.setNewBufferSlotCount(getInvalidDisplayId(), layer, 1);
+ writer.setNewBufferSlotCount(invalidDisplayId, layer, 1);
execute();
- const auto errors = mReader.takeErrors();
+ const auto errors = getReader(invalidDisplayId).takeErrors();
ASSERT_TRUE(errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_BAD_DISPLAY);
}
@@ -3213,10 +3250,10 @@
mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
EXPECT_TRUE(status.isOk());
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
EXPECT_TRUE(mComposerClient->destroyLayer(display.getDisplayId(), layer, &writer).isOk());
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
}
}
@@ -3233,13 +3270,13 @@
EXPECT_TRUE(status.isOk());
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
auto& invalid_writer = getWriter(getInvalidDisplayId());
invalid_writer.setLayerLifecycleBatchCommandType(getInvalidDisplayId(), layer,
LayerLifecycleBatchCommandType::DESTROY);
execute();
- const auto errors = mReader.takeErrors();
+ const auto errors = getReader(display.getDisplayId()).takeErrors();
ASSERT_TRUE(errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_BAD_DISPLAY);
}
}
@@ -3256,7 +3293,7 @@
writer.setLayerLifecycleBatchCommandType(display.getDisplayId(), layer,
LayerLifecycleBatchCommandType::DESTROY);
execute();
- const auto errors = mReader.takeErrors();
+ const auto errors = getReader(display.getDisplayId()).takeErrors();
ASSERT_TRUE(errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_BAD_LAYER);
}
}
@@ -3272,7 +3309,8 @@
auto minFrameIntervalNs = config.vrrConfig->minFrameIntervalNs;
const auto timeoutNs = config.vrrConfig->notifyExpectedPresentConfig->timeoutNs;
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, displayId);
+ const auto buffer = allocate(display.getDisplayWidth(), display.getDisplayHeight(),
+ ::android::PIXEL_FORMAT_RGBA_8888);
ASSERT_NE(nullptr, buffer);
const auto layer = createOnScreenLayer(display);
auto& writer = getWriter(displayId);
@@ -3309,7 +3347,8 @@
forEachNotifyExpectedPresentConfig([&](DisplayWrapper& display,
const DisplayConfiguration& config) {
const auto displayId = display.getDisplayId();
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, displayId);
+ const auto buffer = allocate(display.getDisplayWidth(), display.getDisplayHeight(),
+ ::android::PIXEL_FORMAT_RGBA_8888);
ASSERT_NE(nullptr, buffer);
const auto layer = createOnScreenLayer(display);
auto& writer = getWriter(displayId);
@@ -3356,7 +3395,8 @@
forEachNotifyExpectedPresentConfig([&](DisplayWrapper& display,
const DisplayConfiguration& config) {
const auto displayId = display.getDisplayId();
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, displayId);
+ const auto buffer = allocate(display.getDisplayWidth(), display.getDisplayHeight(),
+ ::android::PIXEL_FORMAT_RGBA_8888);
ASSERT_NE(nullptr, buffer);
const auto layer = createOnScreenLayer(display);
auto& writer = getWriter(displayId);
@@ -3442,14 +3482,15 @@
auto& writer = getWriter(displayId);
const auto layer = createOnScreenLayer(display);
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, displayId);
+ const auto buffer = allocate(display.getDisplayWidth(), display.getDisplayHeight(),
+ ::android::PIXEL_FORMAT_RGBA_8888);
ASSERT_NE(nullptr, buffer->handle);
// TODO(b/337330263): Lookup profile IDs from MediaQualityManager
writer.setDisplayPictureProfileId(displayId, PictureProfileId(1));
writer.setLayerBuffer(displayId, layer, /*slot*/ 0, buffer->handle,
/*acquireFence*/ -1);
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
}
}
@@ -3467,14 +3508,15 @@
auto& writer = getWriter(displayId);
const auto layer = createOnScreenLayer(display);
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, displayId);
+ const auto buffer = allocate(display.getDisplayWidth(), display.getDisplayHeight(),
+ ::android::PIXEL_FORMAT_RGBA_8888);
ASSERT_NE(nullptr, buffer->handle);
writer.setLayerBuffer(displayId, layer, /*slot*/ 0, buffer->handle,
/*acquireFence*/ -1);
// TODO(b/337330263): Lookup profile IDs from MediaQualityManager
writer.setLayerPictureProfileId(displayId, layer, PictureProfileId(1));
execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ ASSERT_TRUE(getReader(display.getDisplayId()).takeErrors().empty());
}
}
@@ -3493,7 +3535,8 @@
auto& writer = getWriter(displayId);
for (int profileId = 1; profileId <= maxProfiles + 1; ++profileId) {
const auto layer = createOnScreenLayer(display);
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, displayId);
+ const auto buffer = allocate(display.getDisplayWidth(), display.getDisplayHeight(),
+ ::android::PIXEL_FORMAT_RGBA_8888);
ASSERT_NE(nullptr, buffer->handle);
writer.setLayerBuffer(displayId, layer, /*slot*/ 0, buffer->handle,
/*acquireFence*/ -1);
@@ -3501,7 +3544,7 @@
writer.setLayerPictureProfileId(displayId, layer, PictureProfileId(profileId));
}
execute();
- const auto errors = mReader.takeErrors();
+ const auto errors = getReader(display.getDisplayId()).takeErrors();
ASSERT_TRUE(errors.size() == 1 &&
errors[0].errorCode == IComposerClient::EX_PICTURE_PROFILE_MAX_EXCEEDED);
}
@@ -3513,7 +3556,8 @@
int64_t displayId = display.getDisplayId();
auto& writer = getWriter(displayId);
const auto layer = createOnScreenLayer(display);
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, displayId);
+ const auto buffer = allocate(display.getDisplayWidth(), display.getDisplayHeight(),
+ ::android::PIXEL_FORMAT_RGBA_8888);
ASSERT_NE(nullptr, buffer->handle);
writer.setLayerBuffer(displayId, layer, /*slot*/ 0, buffer->handle,
/*acquireFence*/ -1);
@@ -3556,8 +3600,9 @@
{LutProperties::Dimension::ONE_D, size, {LutProperties::SamplingKey::RGB}}};
luts.pfd = ndk::ScopedFileDescriptor(fd);
- const auto layer = createOnScreenLayer(display.getDisplayId());
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, display.getDisplayId());
+ const auto layer = createOnScreenLayer(display);
+ const auto buffer = allocate(display.getDisplayWidth(), display.getDisplayHeight(),
+ ::android::PIXEL_FORMAT_RGBA_8888);
ASSERT_NE(nullptr, buffer->handle);
writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, buffer->handle,
/*acquireFence*/ -1);
@@ -3565,13 +3610,15 @@
writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp,
ComposerClientWrapper::kNoFrameIntervalNs);
execute();
- const auto errors = mReader.takeErrors();
+ const auto errors = getReader(display.getDisplayId()).takeErrors();
if (errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_UNSUPPORTED) {
GTEST_SUCCEED() << "setLayerLuts is not supported";
return;
}
// change to client composition
- ASSERT_FALSE(mReader.takeChangedCompositionTypes(display.getDisplayId()).empty());
+ ASSERT_FALSE(getReader(display.getDisplayId())
+ .takeChangedCompositionTypes(display.getDisplayId())
+ .empty());
}
}
}
diff --git a/security/keymint/aidl/default/Android.bp b/security/keymint/aidl/default/Android.bp
index 0197141..0d03651 100644
--- a/security/keymint/aidl/default/Android.bp
+++ b/security/keymint/aidl/default/Android.bp
@@ -192,7 +192,6 @@
],
prebuilts: [
"keymint_aidl_nonsecure_init_rc",
- "keymint_aidl_nonsecure_vintf",
"android.hardware.hardware_keystore.xml", // permissions
],
}
@@ -210,14 +209,3 @@
out: ["android.hardware.security.keymint-service.nonsecure.apex.rc"],
cmd: "sed -E 's%/vendor/bin/%/apex/com.android.hardware.keymint/bin/%' $(in) > $(out)",
}
-
-prebuilt_etc {
- name: "keymint_aidl_nonsecure_vintf",
- sub_dir: "vintf",
- vendor: true,
- srcs: [
- "android.hardware.security.keymint-service.xml",
- "android.hardware.security.sharedsecret-service.xml",
- "android.hardware.security.secureclock-service.xml",
- ],
-}
diff --git a/security/secretkeeper/aidl/vts/Android.bp b/security/secretkeeper/aidl/vts/Android.bp
index c84afae..4353ca5 100644
--- a/security/secretkeeper/aidl/vts/Android.bp
+++ b/security/secretkeeper/aidl/vts/Android.bp
@@ -27,6 +27,7 @@
"libciborium",
"libcoset",
"libdiced_open_dice",
+ "libexplicitkeydice",
"libhex",
"liblog_rust",
"libsecretkeeper_client",
@@ -54,6 +55,7 @@
"libciborium",
"libcoset",
"libdice_policy_builder",
+ "libexplicitkeydice",
"liblog_rust",
"libsecretkeeper_client",
"libsecretkeeper_comm_nostd",
@@ -77,6 +79,7 @@
"libclap",
"libcoset",
"libdice_policy_builder",
+ "libexplicitkeydice",
"libhex",
"liblog_rust",
"libsecretkeeper_client",
diff --git a/security/secretkeeper/aidl/vts/dice_sample.rs b/security/secretkeeper/aidl/vts/dice_sample.rs
index d6379e5..f504445 100644
--- a/security/secretkeeper/aidl/vts/dice_sample.rs
+++ b/security/secretkeeper/aidl/vts/dice_sample.rs
@@ -34,8 +34,8 @@
retry_bcc_main_flow, retry_dice_main_flow, Config, DiceArtifacts, DiceConfigValues, DiceError,
DiceMode, InputValues, OwnedDiceArtifacts, HASH_SIZE, HIDDEN_SIZE,
};
+use explicitkeydice::OwnedDiceArtifactsWithExplicitKey;
use log::error;
-use secretkeeper_client::dice::OwnedDiceArtifactsWithExplicitKey;
/// Sample UDS used to perform the root DICE flow by `make_sample_bcc_and_cdis`.
const UDS: &[u8; CDI_SIZE] = &[
diff --git a/security/secretkeeper/aidl/vts/secretkeeper_cli.rs b/security/secretkeeper/aidl/vts/secretkeeper_cli.rs
index 9fbfb45..6a743a8 100644
--- a/security/secretkeeper/aidl/vts/secretkeeper_cli.rs
+++ b/security/secretkeeper/aidl/vts/secretkeeper_cli.rs
@@ -29,7 +29,8 @@
WILDCARD_FULL_ARRAY,
};
-use secretkeeper_client::{dice::OwnedDiceArtifactsWithExplicitKey, SkSession};
+use explicitkeydice::OwnedDiceArtifactsWithExplicitKey;
+use secretkeeper_client::SkSession;
use secretkeeper_comm::data_types::{
error::SecretkeeperError,
packet::{ResponsePacket, ResponseType},
diff --git a/security/secretkeeper/aidl/vts/secretkeeper_test_client.rs b/security/secretkeeper/aidl/vts/secretkeeper_test_client.rs
index b944865..453ff8f 100644
--- a/security/secretkeeper/aidl/vts/secretkeeper_test_client.rs
+++ b/security/secretkeeper/aidl/vts/secretkeeper_test_client.rs
@@ -22,8 +22,8 @@
use authgraph_core::key;
use coset::{CborOrdering, CborSerializable, CoseEncrypt0, CoseKey};
use dice_policy_builder::{TargetEntry, ConstraintSpec, ConstraintType, MissingAction, WILDCARD_FULL_ARRAY, policy_for_dice_chain};
+use explicitkeydice::OwnedDiceArtifactsWithExplicitKey;
use rdroidtest::{ignore_if, rdroidtest};
-use secretkeeper_client::dice::OwnedDiceArtifactsWithExplicitKey;
use secretkeeper_client::{SkSession, Error as SkClientError};
use secretkeeper_core::cipher;
use secretkeeper_comm::data_types::error::SecretkeeperError;
diff --git a/tv/mediaquality/aidl/Android.bp b/tv/mediaquality/aidl/Android.bp
index 49cfd80..f817836 100644
--- a/tv/mediaquality/aidl/Android.bp
+++ b/tv/mediaquality/aidl/Android.bp
@@ -10,7 +10,6 @@
aidl_interface {
name: "android.hardware.tv.mediaquality",
vendor_available: true,
- owner: "haofanw",
srcs: [
"android/hardware/tv/mediaquality/*.aidl",
],
@@ -35,5 +34,12 @@
enabled: false,
},
},
- frozen: false,
+ frozen: true,
+ versions_with_info: [
+ {
+ version: "1",
+ imports: ["android.hardware.graphics.common-V5"],
+ },
+ ],
+
}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/.hash b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/.hash
new file mode 100644
index 0000000..a3e4a55
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/.hash
@@ -0,0 +1 @@
+ac19fd80413145bec55462874afb34c24a47a12b
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightColorFormat.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightColorFormat.aidl
new file mode 100644
index 0000000..9ee9dcc
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightColorFormat.aidl
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+union AmbientBacklightColorFormat {
+ int RGB888;
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightCompressAlgorithm.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightCompressAlgorithm.aidl
new file mode 100644
index 0000000..d441370
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightCompressAlgorithm.aidl
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+enum AmbientBacklightCompressAlgorithm {
+ NONE = 0,
+ RLE = 1,
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightEvent.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightEvent.aidl
new file mode 100644
index 0000000..2fc2cc6
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightEvent.aidl
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+union AmbientBacklightEvent {
+ boolean enabled;
+ android.hardware.tv.mediaquality.AmbientBacklightMetadata metadata;
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightMetadata.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightMetadata.aidl
new file mode 100644
index 0000000..2ea3198
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightMetadata.aidl
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+parcelable AmbientBacklightMetadata {
+ android.hardware.tv.mediaquality.AmbientBacklightSettings settings;
+ android.hardware.tv.mediaquality.AmbientBacklightCompressAlgorithm compressAlgorithm;
+ android.hardware.tv.mediaquality.AmbientBacklightColorFormat[] zonesColors;
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightSettings.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightSettings.aidl
new file mode 100644
index 0000000..7770e18
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightSettings.aidl
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+parcelable AmbientBacklightSettings {
+ int uid;
+ android.hardware.tv.mediaquality.AmbientBacklightSource source;
+ int maxFramerate;
+ android.hardware.graphics.common.PixelFormat colorFormat;
+ int hZonesNumber;
+ int vZonesNumber;
+ boolean hasLetterbox;
+ int colorThreshold;
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightSource.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightSource.aidl
new file mode 100644
index 0000000..22912f4
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightSource.aidl
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+enum AmbientBacklightSource {
+ NONE = 0,
+ AUDIO = 1,
+ VIDEO = 2,
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ColorRange.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ColorRange.aidl
new file mode 100644
index 0000000..c08c6cc
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ColorRange.aidl
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+enum ColorRange {
+ AUTO,
+ LIMITED,
+ FULL,
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ColorSpace.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ColorSpace.aidl
new file mode 100644
index 0000000..9bcddcb
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ColorSpace.aidl
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+enum ColorSpace {
+ AUTO,
+ S_RGB_BT_709,
+ DCI,
+ ADOBE_RGB,
+ BT2020,
+ ON,
+ OFF,
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ColorTemperature.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ColorTemperature.aidl
new file mode 100644
index 0000000..2d26aca
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ColorTemperature.aidl
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+enum ColorTemperature {
+ USER,
+ COOL,
+ STANDARD,
+ WARM,
+ USER_HDR10PLUS,
+ COOL_HDR10PLUS,
+ STANDARD_HDR10PLUS,
+ WARM_HDR10PLUS,
+ FMMSDR,
+ FMMHDR,
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/DigitalOutput.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/DigitalOutput.aidl
new file mode 100644
index 0000000..dad0e96
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/DigitalOutput.aidl
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+enum DigitalOutput {
+ AUTO,
+ BYPASS,
+ PCM,
+ DolbyDigitalPlus,
+ DolbyDigital,
+ DolbyMat,
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/DolbyAudioProcessing.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/DolbyAudioProcessing.aidl
new file mode 100644
index 0000000..f21243c
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/DolbyAudioProcessing.aidl
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+parcelable DolbyAudioProcessing {
+ android.hardware.tv.mediaquality.DolbyAudioProcessing.SoundMode soundMode;
+ boolean volumeLeveler;
+ boolean surroundVirtualizer;
+ boolean dolbyAtmos;
+ enum SoundMode {
+ GAME,
+ MOVIE,
+ MUSIC,
+ NEWS,
+ STADIUM,
+ STANDARD,
+ USER,
+ }
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/DownmixMode.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/DownmixMode.aidl
new file mode 100644
index 0000000..ecb7db2
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/DownmixMode.aidl
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+enum DownmixMode {
+ STEREO,
+ SURROUND,
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/DtsVirtualX.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/DtsVirtualX.aidl
new file mode 100644
index 0000000..d136dd9
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/DtsVirtualX.aidl
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+parcelable DtsVirtualX {
+ boolean tbHdx;
+ boolean limiter;
+ boolean truSurroundX;
+ boolean truVolumeHd;
+ boolean dialogClarity;
+ boolean definition;
+ boolean height;
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/EqualizerDetail.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/EqualizerDetail.aidl
new file mode 100644
index 0000000..99543e9
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/EqualizerDetail.aidl
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+parcelable EqualizerDetail {
+ int band120Hz;
+ int band500Hz;
+ int band1_5kHz;
+ int band5kHz;
+ int band10kHz;
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/Gamma.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/Gamma.aidl
new file mode 100644
index 0000000..89bb808
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/Gamma.aidl
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+enum Gamma {
+ DARK,
+ MIDDLE,
+ BRIGHT,
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/IMediaQuality.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/IMediaQuality.aidl
new file mode 100644
index 0000000..26df461
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/IMediaQuality.aidl
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+interface IMediaQuality {
+ void setAmbientBacklightCallback(in android.hardware.tv.mediaquality.IMediaQualityCallback callback);
+ void setAmbientBacklightDetector(in android.hardware.tv.mediaquality.AmbientBacklightSettings settings);
+ void setAmbientBacklightDetectionEnabled(in boolean enabled);
+ boolean getAmbientBacklightDetectionEnabled();
+ boolean isAutoPqSupported();
+ boolean getAutoPqEnabled();
+ void setAutoPqEnabled(boolean enable);
+ boolean isAutoSrSupported();
+ boolean getAutoSrEnabled();
+ void setAutoSrEnabled(boolean enable);
+ boolean isAutoAqSupported();
+ boolean getAutoAqEnabled();
+ void setAutoAqEnabled(boolean enable);
+ android.hardware.tv.mediaquality.IPictureProfileChangedListener getPictureProfileListener();
+ void setPictureProfileAdjustmentListener(android.hardware.tv.mediaquality.IPictureProfileAdjustmentListener listener);
+ void sendDefaultPictureParameters(in android.hardware.tv.mediaquality.PictureParameters pictureParameters);
+ android.hardware.tv.mediaquality.ISoundProfileChangedListener getSoundProfileListener();
+ void setSoundProfileAdjustmentListener(android.hardware.tv.mediaquality.ISoundProfileAdjustmentListener listener);
+ void sendDefaultSoundParameters(in android.hardware.tv.mediaquality.SoundParameters soundParameters);
+ void getParamCaps(in android.hardware.tv.mediaquality.ParameterName[] paramNames, out android.hardware.tv.mediaquality.ParamCapability[] caps);
+ void getVendorParamCaps(in android.hardware.tv.mediaquality.VendorParameterIdentifier[] names, out android.hardware.tv.mediaquality.VendorParamCapability[] caps);
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/IMediaQualityCallback.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/IMediaQualityCallback.aidl
new file mode 100644
index 0000000..014bf58
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/IMediaQualityCallback.aidl
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+interface IMediaQualityCallback {
+ oneway void notifyAmbientBacklightEvent(in android.hardware.tv.mediaquality.AmbientBacklightEvent event);
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/IPictureProfileAdjustmentListener.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/IPictureProfileAdjustmentListener.aidl
new file mode 100644
index 0000000..1923043
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/IPictureProfileAdjustmentListener.aidl
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+interface IPictureProfileAdjustmentListener {
+ oneway void onPictureProfileAdjusted(in android.hardware.tv.mediaquality.PictureProfile pictureProfile);
+ oneway void onParamCapabilityChanged(long pictureProfileId, in android.hardware.tv.mediaquality.ParamCapability[] caps);
+ oneway void onVendorParamCapabilityChanged(long pictureProfileId, in android.hardware.tv.mediaquality.VendorParamCapability[] caps);
+ oneway void requestPictureParameters(long pictureProfileId);
+ oneway void onStreamStatusChanged(long pictureProfileId, android.hardware.tv.mediaquality.StreamStatus status);
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/IPictureProfileChangedListener.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/IPictureProfileChangedListener.aidl
new file mode 100644
index 0000000..c1bfc36
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/IPictureProfileChangedListener.aidl
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+interface IPictureProfileChangedListener {
+ oneway void onPictureProfileChanged(in android.hardware.tv.mediaquality.PictureProfile pictureProfile);
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ISoundProfileAdjustmentListener.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ISoundProfileAdjustmentListener.aidl
new file mode 100644
index 0000000..d976cf7
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ISoundProfileAdjustmentListener.aidl
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+interface ISoundProfileAdjustmentListener {
+ oneway void onSoundProfileAdjusted(in android.hardware.tv.mediaquality.SoundProfile soundProfile);
+ oneway void onParamCapabilityChanged(long soundProfileId, in android.hardware.tv.mediaquality.ParamCapability[] caps);
+ oneway void onVendorParamCapabilityChanged(long soundProfileId, in android.hardware.tv.mediaquality.VendorParamCapability[] caps);
+ oneway void requestSoundParameters(long SoundProfileId);
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ISoundProfileChangedListener.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ISoundProfileChangedListener.aidl
new file mode 100644
index 0000000..d07abe7
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ISoundProfileChangedListener.aidl
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+interface ISoundProfileChangedListener {
+ oneway void onSoundProfileChanged(in android.hardware.tv.mediaquality.SoundProfile soundProfile);
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/NumberRange.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/NumberRange.aidl
new file mode 100644
index 0000000..9fc9d0d
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/NumberRange.aidl
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+union NumberRange {
+ @nullable int[2] intMinMax;
+ @nullable long[2] longMinMax;
+ @nullable double[2] doubleMinMax;
+ @nullable int[] intValuesSupported;
+ @nullable long[] longValuesSupported;
+ @nullable double[] doubleValuesSupported;
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ParamCapability.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ParamCapability.aidl
new file mode 100644
index 0000000..c60f1d1
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ParamCapability.aidl
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+parcelable ParamCapability {
+ android.hardware.tv.mediaquality.ParameterName name;
+ boolean isSupported;
+ @nullable android.hardware.tv.mediaquality.ParameterDefaultValue defaultValue;
+ @nullable android.hardware.tv.mediaquality.ParameterRange range;
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ParameterDefaultValue.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ParameterDefaultValue.aidl
new file mode 100644
index 0000000..14e5ff4
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ParameterDefaultValue.aidl
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+union ParameterDefaultValue {
+ int intDefault;
+ long longDefault;
+ double doubleDefault;
+ String stringDefault;
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ParameterName.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ParameterName.aidl
new file mode 100644
index 0000000..522b8e6
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ParameterName.aidl
@@ -0,0 +1,133 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+enum ParameterName {
+ BRIGHTNESS,
+ CONTRAST,
+ SHARPNESS,
+ SATURATION,
+ HUE,
+ COLOR_TUNER_BRIGHTNESS,
+ COLOR_TUNER_SATURATION,
+ COLOR_TUNER_HUE,
+ COLOR_TUNER_RED_OFFSET,
+ COLOR_TUNER_GREEN_OFFSET,
+ COLOR_TUNER_BLUE_OFFSET,
+ COLOR_TUNER_RED_GAIN,
+ COLOR_TUNER_GREEN_GAIN,
+ COLOR_TUNER_BLUE_GAIN,
+ NOISE_REDUCTION,
+ MPEG_NOISE_REDUCTION,
+ FLASH_TONE,
+ DE_CONTOUR,
+ DYNAMIC_LUMA_CONTROL,
+ FILM_MODE,
+ BLACK_STRETCH,
+ BLUE_STRETCH,
+ COLOR_TUNE,
+ COLOR_TEMPERATURE,
+ GLOBE_DIMMING,
+ AUTO_PICTUREQUALITY_ENABLED,
+ AUTO_SUPER_RESOLUTION_ENABLED,
+ LEVEL_RANGE,
+ GAMUT_MAPPING,
+ PC_MODE,
+ LOW_LATENCY,
+ VRR,
+ CVRR,
+ HDMI_RGB_RANGE,
+ COLOR_SPACE,
+ PANEL_INIT_MAX_LUMINCE_VALID,
+ GAMMA,
+ COLOR_TEMPERATURE_RED_GAIN,
+ COLOR_TEMPERATURE_GREEN_GAIN,
+ COLOR_TEMPERATURE_BLUE_GAIN,
+ COLOR_TEMPERATURE_RED_OFFSET,
+ COLOR_TEMPERATURE_GREEN_OFFSET,
+ COLOR_TEMPERATURE_BLUE_OFFSET,
+ ELEVEN_POINT_RED,
+ ELEVEN_POINT_GREEN,
+ ELEVEN_POINT_BLUE,
+ LOW_BLUE_LIGHT,
+ LD_MODE,
+ OSD_RED_GAIN,
+ OSD_GREEN_GAIN,
+ OSD_BLUE_GAIN,
+ OSD_RED_OFFSET,
+ OSD_GREEN_OFFSET,
+ OSD_BLUE_OFFSET,
+ OSD_HUE,
+ OSD_SATURATION,
+ OSD_CONTRAST,
+ COLOR_TUNER_SWITCH,
+ COLOR_TUNER_HUE_RED,
+ COLOR_TUNER_HUE_GREEN,
+ COLOR_TUNER_HUE_BLUE,
+ COLOR_TUNER_HUE_CYAN,
+ COLOR_TUNER_HUE_MAGENTA,
+ COLOR_TUNER_HUE_YELLOW,
+ COLOR_TUNER_HUE_FLESH,
+ COLOR_TUNER_SATURATION_RED,
+ COLOR_TUNER_SATURATION_GREEN,
+ COLOR_TUNER_SATURATION_BLUE,
+ COLOR_TUNER_SATURATION_CYAN,
+ COLOR_TUNER_SATURATION_MAGENTA,
+ COLOR_TUNER_SATURATION_YELLOW,
+ COLOR_TUNER_SATURATION_FLESH,
+ COLOR_TUNER_LUMINANCE_RED,
+ COLOR_TUNER_LUMINANCE_GREEN,
+ COLOR_TUNER_LUMINANCE_BLUE,
+ COLOR_TUNER_LUMINANCE_CYAN,
+ COLOR_TUNER_LUMINANCE_MAGENTA,
+ COLOR_TUNER_LUMINANCE_YELLOW,
+ COLOR_TUNER_LUMINANCE_FLESH,
+ BALANCE,
+ BASS,
+ TREBLE,
+ SURROUND_SOUND_ENABLED,
+ EQUALIZER_DETAIL,
+ SPEAKERS_ENABLED,
+ SPEAKERS_DELAY_MS,
+ ENHANCED_AUDIO_RETURN_CHANNEL_ENABLED,
+ AUTO_VOLUME_CONTROL,
+ DOWNMIX_MODE,
+ DTS_DRC,
+ DOLBY_AUDIO_PROCESSING,
+ DOLBY_DIALOGUE_ENHANCER,
+ DTS_VIRTUAL_X,
+ DIGITAL_OUTPUT,
+ DIGITAL_OUTPUT_DELAY_MS,
+ SOUND_STYLE,
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ParameterRange.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ParameterRange.aidl
new file mode 100644
index 0000000..66bc405
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ParameterRange.aidl
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+parcelable ParameterRange {
+ android.hardware.tv.mediaquality.NumberRange numRange;
+ ParcelableHolder vendorDefinedValues;
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/PictureParameter.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/PictureParameter.aidl
new file mode 100644
index 0000000..3a9e4e4
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/PictureParameter.aidl
@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+union PictureParameter {
+ float brightness;
+ int contrast;
+ int sharpness;
+ int saturation;
+ int hue;
+ int colorTunerBrightness;
+ int colorTunerSaturation;
+ int colorTunerHue;
+ int colorTunerRedOffset;
+ int colorTunerGreenOffset;
+ int colorTunerBlueOffset;
+ int colorTunerRedGain;
+ int colorTunerGreenGain;
+ int colorTunerBlueGain;
+ android.hardware.tv.mediaquality.QualityLevel noiseReduction;
+ android.hardware.tv.mediaquality.QualityLevel mpegNoiseReduction;
+ android.hardware.tv.mediaquality.QualityLevel fleshTone;
+ android.hardware.tv.mediaquality.QualityLevel deContour;
+ android.hardware.tv.mediaquality.QualityLevel dynamicLumaControl;
+ boolean filmMode;
+ boolean blueStretch;
+ boolean colorTune;
+ android.hardware.tv.mediaquality.ColorTemperature colorTemperature;
+ boolean globeDimming;
+ boolean autoPictureQualityEnabled;
+ boolean autoSuperResolutionEnabled;
+ android.hardware.tv.mediaquality.ColorRange levelRange;
+ boolean gamutMapping;
+ boolean pcMode;
+ boolean lowLatency;
+ boolean vrr;
+ boolean cvrr;
+ android.hardware.tv.mediaquality.ColorRange hdmiRgbRange;
+ android.hardware.tv.mediaquality.ColorSpace colorSpace;
+ int panelInitMaxLuminceNits;
+ boolean panelInitMaxLuminceValid;
+ android.hardware.tv.mediaquality.Gamma gamma;
+ int colorTemperatureRedGain;
+ int colorTemperatureGreenGain;
+ int colorTemperatureBlueGain;
+ int colorTemperatureRedOffset;
+ int colorTemperatureGreenOffset;
+ int colorTemperatureBlueOffset;
+ int[11] elevenPointRed;
+ int[11] elevenPointGreen;
+ int[11] elevenPointBlue;
+ android.hardware.tv.mediaquality.QualityLevel lowBlueLight;
+ android.hardware.tv.mediaquality.QualityLevel LdMode;
+ int osdRedGain;
+ int osdGreenGain;
+ int osdBlueGain;
+ int osdRedOffset;
+ int osdGreenOffset;
+ int osdBlueOffset;
+ int osdHue;
+ int osdSaturation;
+ int osdContrast;
+ boolean colorTunerSwitch;
+ int colorTunerHueRed;
+ int colorTunerHueGreen;
+ int colorTunerHueBlue;
+ int colorTunerHueCyan;
+ int colorTunerHueMagenta;
+ int colorTunerHueYellow;
+ int colorTunerHueFlesh;
+ int colorTunerSaturationRed;
+ int colorTunerSaturationGreen;
+ int colorTunerSaturationBlue;
+ int colorTunerSaturationCyan;
+ int colorTunerSaturationMagenta;
+ int colorTunerSaturationYellow;
+ int colorTunerSaturationFlesh;
+ int colorTunerLuminanceRed;
+ int colorTunerLuminanceGreen;
+ int colorTunerLuminanceBlue;
+ int colorTunerLuminanceCyan;
+ int colorTunerLuminanceMagenta;
+ int colorTunerLuminanceYellow;
+ int colorTunerLuminanceFlesh;
+ boolean activeProfile;
+ android.hardware.tv.mediaquality.PictureQualityEventType pictureQualityEventType;
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/PictureParameters.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/PictureParameters.aidl
new file mode 100644
index 0000000..627369d
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/PictureParameters.aidl
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+parcelable PictureParameters {
+ android.hardware.tv.mediaquality.PictureParameter[] pictureParameters;
+ ParcelableHolder vendorPictureParameters;
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/PictureProfile.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/PictureProfile.aidl
new file mode 100644
index 0000000..ec2f9ff
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/PictureProfile.aidl
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+parcelable PictureProfile {
+ long pictureProfileId;
+ android.hardware.tv.mediaquality.PictureParameters parameters;
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/PictureQualityEventType.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/PictureQualityEventType.aidl
new file mode 100644
index 0000000..11001f6
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/PictureQualityEventType.aidl
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+enum PictureQualityEventType {
+ NONE,
+ BBD_RESULT,
+ VIDEO_DELAY_CHANGE,
+ CAPTUREPOINT_INFO_CHANGE,
+ VIDEOPATH_CHANGE,
+ EXTRA_FRAME_CHANGE,
+ DOLBY_IQ_CHANGE,
+ DOLBY_APO_CHANGE,
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/QualityLevel.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/QualityLevel.aidl
new file mode 100644
index 0000000..a7f130f
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/QualityLevel.aidl
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+enum QualityLevel {
+ OFF,
+ LOW,
+ MEDIUM,
+ HIGH,
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/SoundParameter.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/SoundParameter.aidl
new file mode 100644
index 0000000..8c0eaaf
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/SoundParameter.aidl
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+union SoundParameter {
+ int balance;
+ int bass;
+ int treble;
+ boolean surroundSoundEnabled;
+ android.hardware.tv.mediaquality.EqualizerDetail equalizerDetail;
+ boolean speakersEnabled;
+ int speakersDelayMs;
+ boolean enhancedAudioReturnChannelEnabled;
+ boolean autoVolumeControl;
+ android.hardware.tv.mediaquality.DownmixMode downmixMode;
+ boolean dtsDrc;
+ @nullable android.hardware.tv.mediaquality.DolbyAudioProcessing dolbyAudioProcessing;
+ android.hardware.tv.mediaquality.QualityLevel dolbyDialogueEnhancer;
+ @nullable android.hardware.tv.mediaquality.DtsVirtualX dtsVirtualX;
+ android.hardware.tv.mediaquality.DigitalOutput digitalOutput;
+ int digitalOutputDelayMs;
+ boolean activeProfile;
+ android.hardware.tv.mediaquality.SoundStyle soundStyle;
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/SoundParameters.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/SoundParameters.aidl
new file mode 100644
index 0000000..6492163
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/SoundParameters.aidl
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+parcelable SoundParameters {
+ android.hardware.tv.mediaquality.SoundParameter[] soundParameters;
+ ParcelableHolder vendorSoundParameters;
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/SoundProfile.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/SoundProfile.aidl
new file mode 100644
index 0000000..05f936f
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/SoundProfile.aidl
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+parcelable SoundProfile {
+ long soundProfileId;
+ android.hardware.tv.mediaquality.SoundParameters parameters;
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/SoundStyle.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/SoundStyle.aidl
new file mode 100644
index 0000000..1dbaf2c
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/SoundStyle.aidl
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+enum SoundStyle {
+ USER,
+ STANDARD,
+ VIVID,
+ SPORTS,
+ MOVIE,
+ MUSIC,
+ NEWS,
+ AUTO,
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/StreamStatus.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/StreamStatus.aidl
new file mode 100644
index 0000000..23e584b
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/StreamStatus.aidl
@@ -0,0 +1,54 @@
+/*
+ * Copyright 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+enum StreamStatus {
+ SDR,
+ DOLBYVISION,
+ HDR10,
+ TCH,
+ HLG,
+ HDR10PLUS,
+ HDRVIVID,
+ IMAXSDR,
+ IMAXHDR10,
+ IMAXHDR10PLUS,
+ FMMSDR,
+ FMMHDR10,
+ FMMHDR10PLUS,
+ FMMHLG,
+ FMMDOLBY,
+ FMMTCH,
+ FMMHDRVIVID,
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/VendorParamCapability.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/VendorParamCapability.aidl
new file mode 100644
index 0000000..5f16de9
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/VendorParamCapability.aidl
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+parcelable VendorParamCapability {
+ android.hardware.tv.mediaquality.VendorParameterIdentifier identifier;
+ boolean isSupported;
+ @nullable android.hardware.tv.mediaquality.ParameterDefaultValue defaultValue;
+ @nullable android.hardware.tv.mediaquality.ParameterRange range;
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/VendorParameterIdentifier.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/VendorParameterIdentifier.aidl
new file mode 100644
index 0000000..016c22d
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/VendorParameterIdentifier.aidl
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+// the interface (from the latest frozen version), the build system will
+// prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+parcelable VendorParameterIdentifier {
+ ParcelableHolder identifier;
+}
diff --git a/tv/mediaquality/aidl/default/hal/media_quality_hal_impl.rs b/tv/mediaquality/aidl/default/hal/media_quality_hal_impl.rs
index 087730f..37f333a 100644
--- a/tv/mediaquality/aidl/default/hal/media_quality_hal_impl.rs
+++ b/tv/mediaquality/aidl/default/hal/media_quality_hal_impl.rs
@@ -62,15 +62,15 @@
pub fn new() -> Self {
Self {
callback: Arc::new(Mutex::new(None)),
- ambient_backlight_supported: Arc::new(Mutex::new(false)),
- ambient_backlight_enabled: Arc::new(Mutex::new(true)),
+ ambient_backlight_supported: Arc::new(Mutex::new(true)),
+ ambient_backlight_enabled: Arc::new(Mutex::new(false)),
ambient_backlight_detector_settings:
Arc::new(Mutex::new(AmbientBacklightSettings::default())),
- auto_pq_supported: Arc::new(Mutex::new(false)),
+ auto_pq_supported: Arc::new(Mutex::new(true)),
auto_pq_enabled: Arc::new(Mutex::new(false)),
- auto_sr_supported: Arc::new(Mutex::new(false)),
+ auto_sr_supported: Arc::new(Mutex::new(true)),
auto_sr_enabled: Arc::new(Mutex::new(false)),
- auto_aq_supported: Arc::new(Mutex::new(false)),
+ auto_aq_supported: Arc::new(Mutex::new(true)),
auto_aq_enabled: Arc::new(Mutex::new(false)),
picture_profile_adjustment_listener: Arc::new(Mutex::new(None)),
sound_profile_adjustment_listener: Arc::new(Mutex::new(None)),
@@ -236,7 +236,7 @@
fn getPictureProfileListener(&self) -> binder::Result<binder::Strong<dyn IPictureProfileChangedListener>> {
println!("getPictureProfileListener");
let listener = self.picture_profile_changed_listener.lock().unwrap();
- listener.clone().ok_or(binder::StatusCode::UNKNOWN_ERROR.into())
+ Ok(listener.clone().expect("NONE"))
}
fn setPictureProfileAdjustmentListener(
diff --git a/tv/mediaquality/aidl/vts/functional/VtsHalMediaQualityTest.cpp b/tv/mediaquality/aidl/vts/functional/VtsHalMediaQualityTest.cpp
index a01d4b0..5d320d3 100644
--- a/tv/mediaquality/aidl/vts/functional/VtsHalMediaQualityTest.cpp
+++ b/tv/mediaquality/aidl/vts/functional/VtsHalMediaQualityTest.cpp
@@ -578,6 +578,18 @@
ASSERT_OK(mediaquality->setAmbientBacklightCallback(callback));
}
+TEST_P(MediaQualityAidl, TestGetPictureProfileChangedListener) {
+ std::shared_ptr<::aidl::android::hardware::tv::mediaquality::IPictureProfileChangedListener>
+ aidlListener;
+ mediaquality->getPictureProfileListener(&aidlListener);
+}
+
+TEST_P(MediaQualityAidl, TestGetSoundProfileChangedListener) {
+ std::shared_ptr<::aidl::android::hardware::tv::mediaquality::ISoundProfileChangedListener>
+ aidlListener;
+ mediaquality->getSoundProfileListener(&aidlListener);
+}
+
TEST_P(MediaQualityAidl, TestSetPictureProfileAdjustmentListener) {
std::shared_ptr<PictureProfileAdjustmentListener> listener =
ndk::SharedRefBase::make<PictureProfileAdjustmentListener>(
diff --git a/wifi/apex/Android.bp b/wifi/apex/Android.bp
index f8c8e6f..5052ebb 100644
--- a/wifi/apex/Android.bp
+++ b/wifi/apex/Android.bp
@@ -15,13 +15,6 @@
installable: false,
}
-prebuilt_etc {
- name: "com.android.hardware.wifi.xml",
- src: ":default-android.hardware.wifi-service.xml",
- installable: false,
- sub_dir: "vintf",
-}
-
apex {
name: "com.android.hardware.wifi",
manifest: "apex_manifest.json",
@@ -36,7 +29,6 @@
],
prebuilts: [
"com.android.hardware.wifi.rc",
- "com.android.hardware.wifi.xml",
],
overrides: [
"android.hardware.wifi-service",