Merge changes Ie107b57d,I315fe1b4 into main
* changes:
Freeze android.hardware.tv.media
Remove owner field from android.hardware.tv.mediaquality
diff --git a/audio/aidl/default/alsa/StreamAlsa.cpp b/audio/aidl/default/alsa/StreamAlsa.cpp
index 114c4c0..210c26b 100644
--- a/audio/aidl/default/alsa/StreamAlsa.cpp
+++ b/audio/aidl/default/alsa/StreamAlsa.cpp
@@ -280,13 +280,22 @@
const size_t bufferSize = mBufferSizeFrames * mFrameSizeBytes;
std::vector<char> buffer(bufferSize);
while (mIoThreadIsRunning) {
- ssize_t framesRead = mSources[idx]->read(&buffer[0], mBufferSizeFrames);
- if (framesRead > 0) {
+ ssize_t framesReadOrError = mSources[idx]->read(&buffer[0], mBufferSizeFrames);
+ if (framesReadOrError > 0) {
int ret = proxy_write_with_retries(mAlsaDeviceProxies[idx].get(), &buffer[0],
- framesRead * mFrameSizeBytes, mReadWriteRetries);
+ framesReadOrError * mFrameSizeBytes,
+ mReadWriteRetries);
// Errors when the stream is being stopped are expected.
LOG_IF(WARNING, ret != 0 && mIoThreadIsRunning)
<< __func__ << "[" << idx << "]: Error writing into ALSA: " << ret;
+ } else if (framesReadOrError == 0) {
+ // MonoPipeReader does not have a blocking read, while use of std::condition_variable
+ // requires use of a mutex. For now, just do a 1ms sleep. Consider using a different
+ // pipe / ring buffer mechanism.
+ if (mIoThreadIsRunning) usleep(1000);
+ } else {
+ LOG(WARNING) << __func__ << "[" << idx
+ << "]: Error while reading from the pipe: " << framesReadOrError;
}
}
}
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/aidl/emu_metadata/android.hardware.automotive.vehicle-types-meta.json b/automotive/vehicle/aidl/emu_metadata/android.hardware.automotive.vehicle-types-meta.json
index 2867aa2..53e5e99 100644
--- a/automotive/vehicle/aidl/emu_metadata/android.hardware.automotive.vehicle-types-meta.json
+++ b/automotive/vehicle/aidl/emu_metadata/android.hardware.automotive.vehicle-types-meta.json
@@ -388,13 +388,13 @@
"description": "Fan speed setting\nThe maxInt32Value and minInt32Value in VehicleAreaConfig must be defined. All integers between minInt32Value and maxInt32Value must be supported.\nThe minInt32Value indicates the lowest fan speed.\nThe maxInt32Value indicates the highest fan speed.\nIf {@code HasSupportedValueInfo} for a specific area ID is not {@code null}: {@code HasSupportedValueInfo#hasMinSupportedValue} and {@code HasSupportedValueInfo#hasMaxSupportedValue} must be {@code true} for the specific area ID. {@code MinMaxSupportedValueResult#minSupportedValue} has the same meaning as minInt32Value. {@code MinMaxSupportedValueResult#maxSupportedValue} has the same meaning as maxInt32Value. All integers between minSupportedValue and maxSupportedValue must be supported. At boot, minInt32Value is equal to minSupportedValue, maxInt32Value is equal to maxSupportedValue.\nThis property is not in any particular unit but in a specified range of relative speeds.\nThis property is defined as VehiclePropertyAccess.READ_WRITE, but OEMs have the option to implement it as VehiclePropertyAccess.READ only."
},
{
- "name": "Fan direction setting",
+ "name": "HVAC_FAN_DIRECTION",
"value": 356517121,
"data_enums": [
"VehicleHvacFanDirection"
],
"data_enum": "VehicleHvacFanDirection",
- "description": "Fan direction setting\nThis property is defined as VehiclePropertyAccess.READ_WRITE, but OEMs have the option to implement it as VehiclePropertyAccess.READ only.\nThe supported hvac fan direction is exposed through {@code HVAC_FAN_DIRECTION_AVAILABLE} property. Caller should not call {@code getSupportedValuesList}, or use {@code VehicleAreaConfig#supportedEnumValues}."
+ "description": "The current HVAC fan direction setting\nThis property is defined as VehiclePropertyAccess.READ_WRITE, but OEMs have the option to implement it as VehiclePropertyAccess.READ only.\nThe supported hvac fan direction is exposed through {@code HVAC_FAN_DIRECTION_AVAILABLE} property. Caller should not call {@code getSupportedValuesList}, or use {@code VehicleAreaConfig#supportedEnumValues}.\nThis property must be supported if {@code HVAC_FAN_DIRECTION_AVAILABLE} is implemented on the vehicle, and vice versa."
},
{
"name": "HVAC current temperature.",
@@ -476,13 +476,13 @@
"description": "Represents global power state for HVAC. Setting this property to false MAY mark some properties that control individual HVAC features\/subsystems to UNAVAILABLE state. Setting this property to true MAY mark some properties that control individual HVAC features\/subsystems to AVAILABLE state (unless any\/all of them are UNAVAILABLE on their own individual merits).\n[Definition] HvacPower_DependentProperties: Properties that need HVAC to be powered on in order to enable their functionality. For example, in some cars, in order to turn on the AC, HVAC must be powered on first.\nHvacPower_DependentProperties list must be set in the VehiclePropConfig.configArray. HvacPower_DependentProperties must only contain properties that are associated with VehicleArea:SEAT. Properties that are not associated with VehicleArea:SEAT, for example, HVAC_DEFROSTER, must never depend on HVAC_POWER_ON property and must never be part of HvacPower_DependentProperties list.\nAreaID mapping for HVAC_POWER_ON property must contain all AreaIDs that HvacPower_DependentProperties are mapped to.\nExample 1: A car has two front seats (ROW_1_LEFT, ROW_1_RIGHT) and three back seats (ROW_2_LEFT, ROW_2_CENTER, ROW_2_RIGHT). If the HVAC features (AC, Temperature etc.) throughout the car are dependent on a single HVAC power controller then HVAC_POWER_ON must be mapped to [ROW_1_LEFT | ROW_1_RIGHT | ROW_2_LEFT | ROW_2_CENTER | ROW_2_RIGHT].\nExample 2: A car has two seats in the front row (ROW_1_LEFT, ROW_1_RIGHT) and three seats in the second (ROW_2_LEFT, ROW_2_CENTER, ROW_2_RIGHT) and third rows (ROW_3_LEFT, ROW_3_CENTER, ROW_3_RIGHT). If the car has temperature controllers in the front row which can operate entirely independently of temperature controllers in the back of the vehicle, then HVAC_POWER_ON must be mapped to a two element array: - ROW_1_LEFT | ROW_1_RIGHT - ROW_2_LEFT | ROW_2_CENTER | ROW_2_RIGHT | ROW_3_LEFT | ROW_3_CENTER | ROW_3_RIGHT\nThis property is defined as VehiclePropertyAccess.READ_WRITE, but OEMs have the option to implement it as VehiclePropertyAccess.READ only."
},
{
- "name": "Fan Positions Available",
+ "name": "HVAC_FAN_DIRECTION_AVAILABLE",
"value": 356582673,
"data_enums": [
"VehicleHvacFanDirection"
],
"data_enum": "VehicleHvacFanDirection",
- "description": "Fan Positions Available\nThis is a bit mask of fan positions available for the zone. Each available fan direction is denoted by a separate entry in the vector. A fan direction may have multiple bits from vehicle_hvac_fan_direction set. For instance, a typical car may have the following fan positions: - FAN_DIRECTION_FACE (0x1) - FAN_DIRECTION_FLOOR (0x2) - FAN_DIRECTION_FACE | FAN_DIRECTION_FLOOR (0x3) - FAN_DIRECTION_DEFROST (0x4) - FAN_DIRECTION_FLOOR | FAN_DIRECTION_DEFROST (0x6)"
+ "description": "List of supported fan directions in the vehicle.\nThis is a bit mask of the supported fan positions available each area ID. Each supported fan direction is denoted by a separate entry in the vector. A fan direction may have multiple bits from vehicle_hvac_fan_direction set. For instance, a typical car may have the following fan positions: - FAN_DIRECTION_FACE (0x1) - FAN_DIRECTION_FLOOR (0x2) - FAN_DIRECTION_FACE | FAN_DIRECTION_FLOOR (0x3) - FAN_DIRECTION_DEFROST (0x4) - FAN_DIRECTION_FLOOR | FAN_DIRECTION_DEFROST (0x6)\nThis property must be supported if {@code #HVAC_FAN_DIRECTION} is implemented on the vehicle, and vice versa."
},
{
"name": "Automatic recirculation on\/off",
diff --git a/automotive/vehicle/aidl_property/android/hardware/automotive/vehicle/VehicleProperty.aidl b/automotive/vehicle/aidl_property/android/hardware/automotive/vehicle/VehicleProperty.aidl
index 200ba4c..a7ecb36 100644
--- a/automotive/vehicle/aidl_property/android/hardware/automotive/vehicle/VehicleProperty.aidl
+++ b/automotive/vehicle/aidl_property/android/hardware/automotive/vehicle/VehicleProperty.aidl
@@ -1317,7 +1317,7 @@
HVAC_FAN_SPEED = 0x0500 + 0x10000000 + 0x05000000
+ 0x00400000, // VehiclePropertyGroup:SYSTEM,VehicleArea:SEAT,VehiclePropertyType:INT32
/**
- * Fan direction setting
+ * The current HVAC fan direction setting
*
* This property is defined as VehiclePropertyAccess.READ_WRITE, but OEMs have the option to
* implement it as VehiclePropertyAccess.READ only.
@@ -1326,6 +1326,9 @@
* property. Caller should not call {@code getSupportedValuesList}, or use
* {@code VehicleAreaConfig#supportedEnumValues}.
*
+ * This property must be supported if {@code HVAC_FAN_DIRECTION_AVAILABLE} is implemented
+ * on the vehicle, and vice versa.
+ *
* @change_mode VehiclePropertyChangeMode.ON_CHANGE
* @access VehiclePropertyAccess.READ_WRITE
* @access VehiclePropertyAccess.READ
@@ -1770,10 +1773,10 @@
HVAC_POWER_ON = 0x0510 + 0x10000000 + 0x05000000
+ 0x00200000, // VehiclePropertyGroup:SYSTEM,VehicleArea:SEAT,VehiclePropertyType:BOOLEAN
/**
- * Fan Positions Available
+ * List of supported fan directions in the vehicle.
*
- * This is a bit mask of fan positions available for the zone. Each
- * available fan direction is denoted by a separate entry in the vector. A
+ * This is a bit mask of the supported fan positions available each area ID. Each
+ * supported fan direction is denoted by a separate entry in the vector. A
* fan direction may have multiple bits from vehicle_hvac_fan_direction set.
* For instance, a typical car may have the following fan positions:
* - FAN_DIRECTION_FACE (0x1)
@@ -1782,6 +1785,9 @@
* - FAN_DIRECTION_DEFROST (0x4)
* - FAN_DIRECTION_FLOOR | FAN_DIRECTION_DEFROST (0x6)
*
+ * This property must be supported if {@code #HVAC_FAN_DIRECTION} is implemented on the vehicle,
+ * and vice versa.
+ *
* @change_mode VehiclePropertyChangeMode.STATIC
* @access VehiclePropertyAccess.READ
* @data_enum VehicleHvacFanDirection
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/biometrics/fingerprint/aidl/vts/VtsHalBiometricsFingerprintTargetTest.cpp b/biometrics/fingerprint/aidl/vts/VtsHalBiometricsFingerprintTargetTest.cpp
index 2cc5e56..951418f 100644
--- a/biometrics/fingerprint/aidl/vts/VtsHalBiometricsFingerprintTargetTest.cpp
+++ b/biometrics/fingerprint/aidl/vts/VtsHalBiometricsFingerprintTargetTest.cpp
@@ -138,6 +138,11 @@
};
class Fingerprint : 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.
@@ -157,8 +162,24 @@
ASSERT_NE(binder, nullptr);
mHal = IFingerprint::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);
@@ -178,6 +199,7 @@
std::shared_ptr<IFingerprint> mHal;
std::shared_ptr<SessionCallback> mCb;
std::shared_ptr<ISession> mSession;
+ ::ndk::ScopedAIBinder_DeathRecipient mHalDeathRecipient;
};
TEST_P(Fingerprint, GetSensorPropsWorksTest) {
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/radio/aidl/vts/radio_aidl_hal_utils.h b/radio/aidl/vts/radio_aidl_hal_utils.h
index aea5cee..d9c7311 100644
--- a/radio/aidl/vts/radio_aidl_hal_utils.h
+++ b/radio/aidl/vts/radio_aidl_hal_utils.h
@@ -65,8 +65,6 @@
static constexpr const char* FEATURE_TELEPHONY = "android.hardware.telephony";
-static constexpr const char* FEATURE_TELEPHONY_GSM = "android.hardware.telephony.gsm";
-
static constexpr const char* FEATURE_TELEPHONY_CDMA = "android.hardware.telephony.cdma";
static constexpr const char* FEATURE_TELEPHONY_IMS = "android.hardware.telephony.ims";
diff --git a/radio/aidl/vts/radio_modem_test.cpp b/radio/aidl/vts/radio_modem_test.cpp
index 6a9996b..c6b2579 100644
--- a/radio/aidl/vts/radio_modem_test.cpp
+++ b/radio/aidl/vts/radio_modem_test.cpp
@@ -220,13 +220,6 @@
* Test IRadioModem.getImei() for the response returned.
*/
TEST_P(RadioModemTest, getImei) {
- if (telephony_flags::enforce_telephony_feature_mapping()) {
- if (!deviceSupportsFeature(FEATURE_TELEPHONY_GSM)) {
- GTEST_SKIP() << "Skipping getImei "
- "due to undefined FEATURE_TELEPHONY_GSM";
- }
- }
-
int32_t aidl_version;
ndk::ScopedAStatus aidl_status = radio_modem->getInterfaceVersion(&aidl_version);
ASSERT_OK(aidl_status);
diff --git a/radio/aidl/vts/radio_network_test.cpp b/radio/aidl/vts/radio_network_test.cpp
index 2b4dc42..5529b7e 100644
--- a/radio/aidl/vts/radio_network_test.cpp
+++ b/radio/aidl/vts/radio_network_test.cpp
@@ -1065,7 +1065,7 @@
if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error, {RadioError::SIM_ABSENT}));
} else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
- if (deviceSupportsFeature(FEATURE_TELEPHONY_GSM) && isLteConnected()) {
+ if (isLteConnected()) {
// Modems support 3GPP RAT family need to
// support scanning requests combined with some parameters.
ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
diff --git a/radio/aidl/vts/radio_voice_test.cpp b/radio/aidl/vts/radio_voice_test.cpp
index 6c68fd5..3b07378 100644
--- a/radio/aidl/vts/radio_voice_test.cpp
+++ b/radio/aidl/vts/radio_voice_test.cpp
@@ -102,10 +102,6 @@
if (!deviceSupportsFeature(FEATURE_VOICE_CALL)) {
ALOGI("Skipping emergencyDial because voice call is not supported in device");
return;
- } else if (!deviceSupportsFeature(FEATURE_TELEPHONY_GSM) &&
- !deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {
- ALOGI("Skipping emergencyDial because gsm/cdma radio is not supported in device");
- return;
} else {
ALOGI("Running emergencyDial because voice call is supported in device");
}
@@ -163,10 +159,6 @@
if (!deviceSupportsFeature(FEATURE_VOICE_CALL)) {
ALOGI("Skipping emergencyDial because voice call is not supported in device");
return;
- } else if (!deviceSupportsFeature(FEATURE_TELEPHONY_GSM) &&
- !deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {
- ALOGI("Skipping emergencyDial because gsm/cdma radio is not supported in device");
- return;
} else {
ALOGI("Running emergencyDial because voice call is supported in device");
}
@@ -224,10 +216,6 @@
if (!deviceSupportsFeature(FEATURE_VOICE_CALL)) {
ALOGI("Skipping emergencyDial because voice call is not supported in device");
return;
- } else if (!deviceSupportsFeature(FEATURE_TELEPHONY_GSM) &&
- !deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {
- ALOGI("Skipping emergencyDial because gsm/cdma radio is not supported in device");
- return;
} else {
ALOGI("Running emergencyDial because voice call is supported in device");
}
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/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",