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/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..9a3a429 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,
@@ -2552,28 +2552,28 @@
     ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
                                  {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE,
                                   RadioError::MODEM_ERR, RadioError::REQUEST_NOT_SUPPORTED}));
+    if (radioRsp_network->rspInfo.error != RadioError::NONE) return;
 
+    // Assert the value has changed
+    serial = GetRandomSerialNumber();
+    ndk::ScopedAStatus res = radio_network->isCellularIdentifierTransparencyEnabled(serial);
+
+    ASSERT_OK(res);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
+    ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
+                                 {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE,
+                                  RadioError::MODEM_ERR, RadioError::REQUEST_NOT_SUPPORTED}));
     if (radioRsp_network->rspInfo.error == RadioError::NONE) {
-        // Assert the value has changed
-        serial = GetRandomSerialNumber();
-        ndk::ScopedAStatus res = radio_network->isCellularIdentifierTransparencyEnabled(serial);
-
-        ASSERT_OK(res);
-        EXPECT_EQ(std::cv_status::no_timeout, wait());
-        EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
-        EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
-        ASSERT_TRUE(CheckAnyOfErrors(radioRsp_network->rspInfo.error,
-                                     {RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE,
-                                      RadioError::MODEM_ERR, RadioError::REQUEST_NOT_SUPPORTED}));
         EXPECT_EQ(valueToSet, radioRsp_network->isCellularIdentifierTransparencyEnabled);
-
-        // Reset original state
-        radio_network->setCellularIdentifierTransparencyEnabled(serial,
-                                                                originalTransparencySetting);
-        EXPECT_EQ(std::cv_status::no_timeout, wait());
-        EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
-        EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
     }
+
+    // Reset original state
+    radio_network->setCellularIdentifierTransparencyEnabled(serial, originalTransparencySetting);
+    EXPECT_EQ(std::cv_status::no_timeout, wait());
+    EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_network->rspInfo.type);
+    EXPECT_EQ(serial, radioRsp_network->rspInfo.serial);
 }
 
 /*
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/Android.bp b/tv/mediaquality/aidl/Android.bp
index 49cfd80..f817836 100644
--- a/tv/mediaquality/aidl/Android.bp
+++ b/tv/mediaquality/aidl/Android.bp
@@ -10,7 +10,6 @@
 aidl_interface {
     name: "android.hardware.tv.mediaquality",
     vendor_available: true,
-    owner: "haofanw",
     srcs: [
         "android/hardware/tv/mediaquality/*.aidl",
     ],
@@ -35,5 +34,12 @@
             enabled: false,
         },
     },
-    frozen: false,
+    frozen: true,
+    versions_with_info: [
+        {
+            version: "1",
+            imports: ["android.hardware.graphics.common-V5"],
+        },
+    ],
+
 }
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/.hash b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/.hash
new file mode 100644
index 0000000..a3e4a55
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/.hash
@@ -0,0 +1 @@
+ac19fd80413145bec55462874afb34c24a47a12b
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightColorFormat.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightColorFormat.aidl
new file mode 100644
index 0000000..9ee9dcc
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightColorFormat.aidl
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+union AmbientBacklightColorFormat {
+  int RGB888;
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightCompressAlgorithm.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightCompressAlgorithm.aidl
new file mode 100644
index 0000000..d441370
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightCompressAlgorithm.aidl
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+enum AmbientBacklightCompressAlgorithm {
+  NONE = 0,
+  RLE = 1,
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightEvent.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightEvent.aidl
new file mode 100644
index 0000000..2fc2cc6
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightEvent.aidl
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+union AmbientBacklightEvent {
+  boolean enabled;
+  android.hardware.tv.mediaquality.AmbientBacklightMetadata metadata;
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightMetadata.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightMetadata.aidl
new file mode 100644
index 0000000..2ea3198
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightMetadata.aidl
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+parcelable AmbientBacklightMetadata {
+  android.hardware.tv.mediaquality.AmbientBacklightSettings settings;
+  android.hardware.tv.mediaquality.AmbientBacklightCompressAlgorithm compressAlgorithm;
+  android.hardware.tv.mediaquality.AmbientBacklightColorFormat[] zonesColors;
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightSettings.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightSettings.aidl
new file mode 100644
index 0000000..7770e18
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightSettings.aidl
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+parcelable AmbientBacklightSettings {
+  int uid;
+  android.hardware.tv.mediaquality.AmbientBacklightSource source;
+  int maxFramerate;
+  android.hardware.graphics.common.PixelFormat colorFormat;
+  int hZonesNumber;
+  int vZonesNumber;
+  boolean hasLetterbox;
+  int colorThreshold;
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightSource.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightSource.aidl
new file mode 100644
index 0000000..22912f4
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/AmbientBacklightSource.aidl
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+enum AmbientBacklightSource {
+  NONE = 0,
+  AUDIO = 1,
+  VIDEO = 2,
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ColorRange.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ColorRange.aidl
new file mode 100644
index 0000000..c08c6cc
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ColorRange.aidl
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+enum ColorRange {
+  AUTO,
+  LIMITED,
+  FULL,
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ColorSpace.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ColorSpace.aidl
new file mode 100644
index 0000000..9bcddcb
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ColorSpace.aidl
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+enum ColorSpace {
+  AUTO,
+  S_RGB_BT_709,
+  DCI,
+  ADOBE_RGB,
+  BT2020,
+  ON,
+  OFF,
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ColorTemperature.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ColorTemperature.aidl
new file mode 100644
index 0000000..2d26aca
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ColorTemperature.aidl
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+enum ColorTemperature {
+  USER,
+  COOL,
+  STANDARD,
+  WARM,
+  USER_HDR10PLUS,
+  COOL_HDR10PLUS,
+  STANDARD_HDR10PLUS,
+  WARM_HDR10PLUS,
+  FMMSDR,
+  FMMHDR,
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/DigitalOutput.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/DigitalOutput.aidl
new file mode 100644
index 0000000..dad0e96
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/DigitalOutput.aidl
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+enum DigitalOutput {
+  AUTO,
+  BYPASS,
+  PCM,
+  DolbyDigitalPlus,
+  DolbyDigital,
+  DolbyMat,
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/DolbyAudioProcessing.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/DolbyAudioProcessing.aidl
new file mode 100644
index 0000000..f21243c
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/DolbyAudioProcessing.aidl
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+parcelable DolbyAudioProcessing {
+  android.hardware.tv.mediaquality.DolbyAudioProcessing.SoundMode soundMode;
+  boolean volumeLeveler;
+  boolean surroundVirtualizer;
+  boolean dolbyAtmos;
+  enum SoundMode {
+    GAME,
+    MOVIE,
+    MUSIC,
+    NEWS,
+    STADIUM,
+    STANDARD,
+    USER,
+  }
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/DownmixMode.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/DownmixMode.aidl
new file mode 100644
index 0000000..ecb7db2
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/DownmixMode.aidl
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+enum DownmixMode {
+  STEREO,
+  SURROUND,
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/DtsVirtualX.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/DtsVirtualX.aidl
new file mode 100644
index 0000000..d136dd9
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/DtsVirtualX.aidl
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+parcelable DtsVirtualX {
+  boolean tbHdx;
+  boolean limiter;
+  boolean truSurroundX;
+  boolean truVolumeHd;
+  boolean dialogClarity;
+  boolean definition;
+  boolean height;
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/EqualizerDetail.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/EqualizerDetail.aidl
new file mode 100644
index 0000000..99543e9
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/EqualizerDetail.aidl
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+parcelable EqualizerDetail {
+  int band120Hz;
+  int band500Hz;
+  int band1_5kHz;
+  int band5kHz;
+  int band10kHz;
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/Gamma.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/Gamma.aidl
new file mode 100644
index 0000000..89bb808
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/Gamma.aidl
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+enum Gamma {
+  DARK,
+  MIDDLE,
+  BRIGHT,
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/IMediaQuality.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/IMediaQuality.aidl
new file mode 100644
index 0000000..26df461
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/IMediaQuality.aidl
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+interface IMediaQuality {
+  void setAmbientBacklightCallback(in android.hardware.tv.mediaquality.IMediaQualityCallback callback);
+  void setAmbientBacklightDetector(in android.hardware.tv.mediaquality.AmbientBacklightSettings settings);
+  void setAmbientBacklightDetectionEnabled(in boolean enabled);
+  boolean getAmbientBacklightDetectionEnabled();
+  boolean isAutoPqSupported();
+  boolean getAutoPqEnabled();
+  void setAutoPqEnabled(boolean enable);
+  boolean isAutoSrSupported();
+  boolean getAutoSrEnabled();
+  void setAutoSrEnabled(boolean enable);
+  boolean isAutoAqSupported();
+  boolean getAutoAqEnabled();
+  void setAutoAqEnabled(boolean enable);
+  android.hardware.tv.mediaquality.IPictureProfileChangedListener getPictureProfileListener();
+  void setPictureProfileAdjustmentListener(android.hardware.tv.mediaquality.IPictureProfileAdjustmentListener listener);
+  void sendDefaultPictureParameters(in android.hardware.tv.mediaquality.PictureParameters pictureParameters);
+  android.hardware.tv.mediaquality.ISoundProfileChangedListener getSoundProfileListener();
+  void setSoundProfileAdjustmentListener(android.hardware.tv.mediaquality.ISoundProfileAdjustmentListener listener);
+  void sendDefaultSoundParameters(in android.hardware.tv.mediaquality.SoundParameters soundParameters);
+  void getParamCaps(in android.hardware.tv.mediaquality.ParameterName[] paramNames, out android.hardware.tv.mediaquality.ParamCapability[] caps);
+  void getVendorParamCaps(in android.hardware.tv.mediaquality.VendorParameterIdentifier[] names, out android.hardware.tv.mediaquality.VendorParamCapability[] caps);
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/IMediaQualityCallback.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/IMediaQualityCallback.aidl
new file mode 100644
index 0000000..014bf58
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/IMediaQualityCallback.aidl
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+interface IMediaQualityCallback {
+  oneway void notifyAmbientBacklightEvent(in android.hardware.tv.mediaquality.AmbientBacklightEvent event);
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/IPictureProfileAdjustmentListener.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/IPictureProfileAdjustmentListener.aidl
new file mode 100644
index 0000000..1923043
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/IPictureProfileAdjustmentListener.aidl
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+interface IPictureProfileAdjustmentListener {
+  oneway void onPictureProfileAdjusted(in android.hardware.tv.mediaquality.PictureProfile pictureProfile);
+  oneway void onParamCapabilityChanged(long pictureProfileId, in android.hardware.tv.mediaquality.ParamCapability[] caps);
+  oneway void onVendorParamCapabilityChanged(long pictureProfileId, in android.hardware.tv.mediaquality.VendorParamCapability[] caps);
+  oneway void requestPictureParameters(long pictureProfileId);
+  oneway void onStreamStatusChanged(long pictureProfileId, android.hardware.tv.mediaquality.StreamStatus status);
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/IPictureProfileChangedListener.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/IPictureProfileChangedListener.aidl
new file mode 100644
index 0000000..c1bfc36
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/IPictureProfileChangedListener.aidl
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+interface IPictureProfileChangedListener {
+  oneway void onPictureProfileChanged(in android.hardware.tv.mediaquality.PictureProfile pictureProfile);
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ISoundProfileAdjustmentListener.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ISoundProfileAdjustmentListener.aidl
new file mode 100644
index 0000000..d976cf7
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ISoundProfileAdjustmentListener.aidl
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+interface ISoundProfileAdjustmentListener {
+  oneway void onSoundProfileAdjusted(in android.hardware.tv.mediaquality.SoundProfile soundProfile);
+  oneway void onParamCapabilityChanged(long soundProfileId, in android.hardware.tv.mediaquality.ParamCapability[] caps);
+  oneway void onVendorParamCapabilityChanged(long soundProfileId, in android.hardware.tv.mediaquality.VendorParamCapability[] caps);
+  oneway void requestSoundParameters(long SoundProfileId);
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ISoundProfileChangedListener.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ISoundProfileChangedListener.aidl
new file mode 100644
index 0000000..d07abe7
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ISoundProfileChangedListener.aidl
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+interface ISoundProfileChangedListener {
+  oneway void onSoundProfileChanged(in android.hardware.tv.mediaquality.SoundProfile soundProfile);
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/NumberRange.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/NumberRange.aidl
new file mode 100644
index 0000000..9fc9d0d
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/NumberRange.aidl
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+union NumberRange {
+  @nullable int[2] intMinMax;
+  @nullable long[2] longMinMax;
+  @nullable double[2] doubleMinMax;
+  @nullable int[] intValuesSupported;
+  @nullable long[] longValuesSupported;
+  @nullable double[] doubleValuesSupported;
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ParamCapability.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ParamCapability.aidl
new file mode 100644
index 0000000..c60f1d1
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ParamCapability.aidl
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+parcelable ParamCapability {
+  android.hardware.tv.mediaquality.ParameterName name;
+  boolean isSupported;
+  @nullable android.hardware.tv.mediaquality.ParameterDefaultValue defaultValue;
+  @nullable android.hardware.tv.mediaquality.ParameterRange range;
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ParameterDefaultValue.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ParameterDefaultValue.aidl
new file mode 100644
index 0000000..14e5ff4
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ParameterDefaultValue.aidl
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+union ParameterDefaultValue {
+  int intDefault;
+  long longDefault;
+  double doubleDefault;
+  String stringDefault;
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ParameterName.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ParameterName.aidl
new file mode 100644
index 0000000..522b8e6
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ParameterName.aidl
@@ -0,0 +1,133 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+enum ParameterName {
+  BRIGHTNESS,
+  CONTRAST,
+  SHARPNESS,
+  SATURATION,
+  HUE,
+  COLOR_TUNER_BRIGHTNESS,
+  COLOR_TUNER_SATURATION,
+  COLOR_TUNER_HUE,
+  COLOR_TUNER_RED_OFFSET,
+  COLOR_TUNER_GREEN_OFFSET,
+  COLOR_TUNER_BLUE_OFFSET,
+  COLOR_TUNER_RED_GAIN,
+  COLOR_TUNER_GREEN_GAIN,
+  COLOR_TUNER_BLUE_GAIN,
+  NOISE_REDUCTION,
+  MPEG_NOISE_REDUCTION,
+  FLASH_TONE,
+  DE_CONTOUR,
+  DYNAMIC_LUMA_CONTROL,
+  FILM_MODE,
+  BLACK_STRETCH,
+  BLUE_STRETCH,
+  COLOR_TUNE,
+  COLOR_TEMPERATURE,
+  GLOBE_DIMMING,
+  AUTO_PICTUREQUALITY_ENABLED,
+  AUTO_SUPER_RESOLUTION_ENABLED,
+  LEVEL_RANGE,
+  GAMUT_MAPPING,
+  PC_MODE,
+  LOW_LATENCY,
+  VRR,
+  CVRR,
+  HDMI_RGB_RANGE,
+  COLOR_SPACE,
+  PANEL_INIT_MAX_LUMINCE_VALID,
+  GAMMA,
+  COLOR_TEMPERATURE_RED_GAIN,
+  COLOR_TEMPERATURE_GREEN_GAIN,
+  COLOR_TEMPERATURE_BLUE_GAIN,
+  COLOR_TEMPERATURE_RED_OFFSET,
+  COLOR_TEMPERATURE_GREEN_OFFSET,
+  COLOR_TEMPERATURE_BLUE_OFFSET,
+  ELEVEN_POINT_RED,
+  ELEVEN_POINT_GREEN,
+  ELEVEN_POINT_BLUE,
+  LOW_BLUE_LIGHT,
+  LD_MODE,
+  OSD_RED_GAIN,
+  OSD_GREEN_GAIN,
+  OSD_BLUE_GAIN,
+  OSD_RED_OFFSET,
+  OSD_GREEN_OFFSET,
+  OSD_BLUE_OFFSET,
+  OSD_HUE,
+  OSD_SATURATION,
+  OSD_CONTRAST,
+  COLOR_TUNER_SWITCH,
+  COLOR_TUNER_HUE_RED,
+  COLOR_TUNER_HUE_GREEN,
+  COLOR_TUNER_HUE_BLUE,
+  COLOR_TUNER_HUE_CYAN,
+  COLOR_TUNER_HUE_MAGENTA,
+  COLOR_TUNER_HUE_YELLOW,
+  COLOR_TUNER_HUE_FLESH,
+  COLOR_TUNER_SATURATION_RED,
+  COLOR_TUNER_SATURATION_GREEN,
+  COLOR_TUNER_SATURATION_BLUE,
+  COLOR_TUNER_SATURATION_CYAN,
+  COLOR_TUNER_SATURATION_MAGENTA,
+  COLOR_TUNER_SATURATION_YELLOW,
+  COLOR_TUNER_SATURATION_FLESH,
+  COLOR_TUNER_LUMINANCE_RED,
+  COLOR_TUNER_LUMINANCE_GREEN,
+  COLOR_TUNER_LUMINANCE_BLUE,
+  COLOR_TUNER_LUMINANCE_CYAN,
+  COLOR_TUNER_LUMINANCE_MAGENTA,
+  COLOR_TUNER_LUMINANCE_YELLOW,
+  COLOR_TUNER_LUMINANCE_FLESH,
+  BALANCE,
+  BASS,
+  TREBLE,
+  SURROUND_SOUND_ENABLED,
+  EQUALIZER_DETAIL,
+  SPEAKERS_ENABLED,
+  SPEAKERS_DELAY_MS,
+  ENHANCED_AUDIO_RETURN_CHANNEL_ENABLED,
+  AUTO_VOLUME_CONTROL,
+  DOWNMIX_MODE,
+  DTS_DRC,
+  DOLBY_AUDIO_PROCESSING,
+  DOLBY_DIALOGUE_ENHANCER,
+  DTS_VIRTUAL_X,
+  DIGITAL_OUTPUT,
+  DIGITAL_OUTPUT_DELAY_MS,
+  SOUND_STYLE,
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ParameterRange.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ParameterRange.aidl
new file mode 100644
index 0000000..66bc405
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/ParameterRange.aidl
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+parcelable ParameterRange {
+  android.hardware.tv.mediaquality.NumberRange numRange;
+  ParcelableHolder vendorDefinedValues;
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/PictureParameter.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/PictureParameter.aidl
new file mode 100644
index 0000000..3a9e4e4
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/PictureParameter.aidl
@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+union PictureParameter {
+  float brightness;
+  int contrast;
+  int sharpness;
+  int saturation;
+  int hue;
+  int colorTunerBrightness;
+  int colorTunerSaturation;
+  int colorTunerHue;
+  int colorTunerRedOffset;
+  int colorTunerGreenOffset;
+  int colorTunerBlueOffset;
+  int colorTunerRedGain;
+  int colorTunerGreenGain;
+  int colorTunerBlueGain;
+  android.hardware.tv.mediaquality.QualityLevel noiseReduction;
+  android.hardware.tv.mediaquality.QualityLevel mpegNoiseReduction;
+  android.hardware.tv.mediaquality.QualityLevel fleshTone;
+  android.hardware.tv.mediaquality.QualityLevel deContour;
+  android.hardware.tv.mediaquality.QualityLevel dynamicLumaControl;
+  boolean filmMode;
+  boolean blueStretch;
+  boolean colorTune;
+  android.hardware.tv.mediaquality.ColorTemperature colorTemperature;
+  boolean globeDimming;
+  boolean autoPictureQualityEnabled;
+  boolean autoSuperResolutionEnabled;
+  android.hardware.tv.mediaquality.ColorRange levelRange;
+  boolean gamutMapping;
+  boolean pcMode;
+  boolean lowLatency;
+  boolean vrr;
+  boolean cvrr;
+  android.hardware.tv.mediaquality.ColorRange hdmiRgbRange;
+  android.hardware.tv.mediaquality.ColorSpace colorSpace;
+  int panelInitMaxLuminceNits;
+  boolean panelInitMaxLuminceValid;
+  android.hardware.tv.mediaquality.Gamma gamma;
+  int colorTemperatureRedGain;
+  int colorTemperatureGreenGain;
+  int colorTemperatureBlueGain;
+  int colorTemperatureRedOffset;
+  int colorTemperatureGreenOffset;
+  int colorTemperatureBlueOffset;
+  int[11] elevenPointRed;
+  int[11] elevenPointGreen;
+  int[11] elevenPointBlue;
+  android.hardware.tv.mediaquality.QualityLevel lowBlueLight;
+  android.hardware.tv.mediaquality.QualityLevel LdMode;
+  int osdRedGain;
+  int osdGreenGain;
+  int osdBlueGain;
+  int osdRedOffset;
+  int osdGreenOffset;
+  int osdBlueOffset;
+  int osdHue;
+  int osdSaturation;
+  int osdContrast;
+  boolean colorTunerSwitch;
+  int colorTunerHueRed;
+  int colorTunerHueGreen;
+  int colorTunerHueBlue;
+  int colorTunerHueCyan;
+  int colorTunerHueMagenta;
+  int colorTunerHueYellow;
+  int colorTunerHueFlesh;
+  int colorTunerSaturationRed;
+  int colorTunerSaturationGreen;
+  int colorTunerSaturationBlue;
+  int colorTunerSaturationCyan;
+  int colorTunerSaturationMagenta;
+  int colorTunerSaturationYellow;
+  int colorTunerSaturationFlesh;
+  int colorTunerLuminanceRed;
+  int colorTunerLuminanceGreen;
+  int colorTunerLuminanceBlue;
+  int colorTunerLuminanceCyan;
+  int colorTunerLuminanceMagenta;
+  int colorTunerLuminanceYellow;
+  int colorTunerLuminanceFlesh;
+  boolean activeProfile;
+  android.hardware.tv.mediaquality.PictureQualityEventType pictureQualityEventType;
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/PictureParameters.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/PictureParameters.aidl
new file mode 100644
index 0000000..627369d
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/PictureParameters.aidl
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+parcelable PictureParameters {
+  android.hardware.tv.mediaquality.PictureParameter[] pictureParameters;
+  ParcelableHolder vendorPictureParameters;
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/PictureProfile.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/PictureProfile.aidl
new file mode 100644
index 0000000..ec2f9ff
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/PictureProfile.aidl
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+parcelable PictureProfile {
+  long pictureProfileId;
+  android.hardware.tv.mediaquality.PictureParameters parameters;
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/PictureQualityEventType.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/PictureQualityEventType.aidl
new file mode 100644
index 0000000..11001f6
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/PictureQualityEventType.aidl
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+enum PictureQualityEventType {
+  NONE,
+  BBD_RESULT,
+  VIDEO_DELAY_CHANGE,
+  CAPTUREPOINT_INFO_CHANGE,
+  VIDEOPATH_CHANGE,
+  EXTRA_FRAME_CHANGE,
+  DOLBY_IQ_CHANGE,
+  DOLBY_APO_CHANGE,
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/QualityLevel.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/QualityLevel.aidl
new file mode 100644
index 0000000..a7f130f
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/QualityLevel.aidl
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+enum QualityLevel {
+  OFF,
+  LOW,
+  MEDIUM,
+  HIGH,
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/SoundParameter.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/SoundParameter.aidl
new file mode 100644
index 0000000..8c0eaaf
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/SoundParameter.aidl
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+union SoundParameter {
+  int balance;
+  int bass;
+  int treble;
+  boolean surroundSoundEnabled;
+  android.hardware.tv.mediaquality.EqualizerDetail equalizerDetail;
+  boolean speakersEnabled;
+  int speakersDelayMs;
+  boolean enhancedAudioReturnChannelEnabled;
+  boolean autoVolumeControl;
+  android.hardware.tv.mediaquality.DownmixMode downmixMode;
+  boolean dtsDrc;
+  @nullable android.hardware.tv.mediaquality.DolbyAudioProcessing dolbyAudioProcessing;
+  android.hardware.tv.mediaquality.QualityLevel dolbyDialogueEnhancer;
+  @nullable android.hardware.tv.mediaquality.DtsVirtualX dtsVirtualX;
+  android.hardware.tv.mediaquality.DigitalOutput digitalOutput;
+  int digitalOutputDelayMs;
+  boolean activeProfile;
+  android.hardware.tv.mediaquality.SoundStyle soundStyle;
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/SoundParameters.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/SoundParameters.aidl
new file mode 100644
index 0000000..6492163
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/SoundParameters.aidl
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+parcelable SoundParameters {
+  android.hardware.tv.mediaquality.SoundParameter[] soundParameters;
+  ParcelableHolder vendorSoundParameters;
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/SoundProfile.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/SoundProfile.aidl
new file mode 100644
index 0000000..05f936f
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/SoundProfile.aidl
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+parcelable SoundProfile {
+  long soundProfileId;
+  android.hardware.tv.mediaquality.SoundParameters parameters;
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/SoundStyle.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/SoundStyle.aidl
new file mode 100644
index 0000000..1dbaf2c
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/SoundStyle.aidl
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+enum SoundStyle {
+  USER,
+  STANDARD,
+  VIVID,
+  SPORTS,
+  MOVIE,
+  MUSIC,
+  NEWS,
+  AUTO,
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/StreamStatus.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/StreamStatus.aidl
new file mode 100644
index 0000000..23e584b
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/StreamStatus.aidl
@@ -0,0 +1,54 @@
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+enum StreamStatus {
+  SDR,
+  DOLBYVISION,
+  HDR10,
+  TCH,
+  HLG,
+  HDR10PLUS,
+  HDRVIVID,
+  IMAXSDR,
+  IMAXHDR10,
+  IMAXHDR10PLUS,
+  FMMSDR,
+  FMMHDR10,
+  FMMHDR10PLUS,
+  FMMHLG,
+  FMMDOLBY,
+  FMMTCH,
+  FMMHDRVIVID,
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/VendorParamCapability.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/VendorParamCapability.aidl
new file mode 100644
index 0000000..5f16de9
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/VendorParamCapability.aidl
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+parcelable VendorParamCapability {
+  android.hardware.tv.mediaquality.VendorParameterIdentifier identifier;
+  boolean isSupported;
+  @nullable android.hardware.tv.mediaquality.ParameterDefaultValue defaultValue;
+  @nullable android.hardware.tv.mediaquality.ParameterRange range;
+}
diff --git a/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/VendorParameterIdentifier.aidl b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/VendorParameterIdentifier.aidl
new file mode 100644
index 0000000..016c22d
--- /dev/null
+++ b/tv/mediaquality/aidl/aidl_api/android.hardware.tv.mediaquality/1/android/hardware/tv/mediaquality/VendorParameterIdentifier.aidl
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+///////////////////////////////////////////////////////////////////////////////
+// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE.                          //
+///////////////////////////////////////////////////////////////////////////////
+
+// This file is a snapshot of an AIDL file. Do not edit it manually. There are
+// two cases:
+// 1). this is a frozen version file - do not edit this in any case.
+// 2). this is a 'current' file. If you make a backwards compatible change to
+//     the interface (from the latest frozen version), the build system will
+//     prompt you to update this file with `m <name>-update-api`.
+//
+// You must not make a backward incompatible change to any AIDL file built
+// with the aidl_interface module type with versions property set. The module
+// type is used to build AIDL files in a way that they can be used across
+// independently updatable components of the system. If a device is shipped
+// with such a backward incompatible change, it has a high risk of breaking
+// later when a module using the interface is updated, e.g., Mainline modules.
+
+package android.hardware.tv.mediaquality;
+@VintfStability
+parcelable VendorParameterIdentifier {
+  ParcelableHolder identifier;
+}
diff --git a/tv/mediaquality/aidl/default/hal/media_quality_hal_impl.rs b/tv/mediaquality/aidl/default/hal/media_quality_hal_impl.rs
index 087730f..37f333a 100644
--- a/tv/mediaquality/aidl/default/hal/media_quality_hal_impl.rs
+++ b/tv/mediaquality/aidl/default/hal/media_quality_hal_impl.rs
@@ -62,15 +62,15 @@
     pub fn new() -> Self {
         Self {
             callback: Arc::new(Mutex::new(None)),
-            ambient_backlight_supported: Arc::new(Mutex::new(false)),
-            ambient_backlight_enabled: Arc::new(Mutex::new(true)),
+            ambient_backlight_supported: Arc::new(Mutex::new(true)),
+            ambient_backlight_enabled: Arc::new(Mutex::new(false)),
             ambient_backlight_detector_settings:
                     Arc::new(Mutex::new(AmbientBacklightSettings::default())),
-            auto_pq_supported: Arc::new(Mutex::new(false)),
+            auto_pq_supported: Arc::new(Mutex::new(true)),
             auto_pq_enabled: Arc::new(Mutex::new(false)),
-            auto_sr_supported: Arc::new(Mutex::new(false)),
+            auto_sr_supported: Arc::new(Mutex::new(true)),
             auto_sr_enabled: Arc::new(Mutex::new(false)),
-            auto_aq_supported: Arc::new(Mutex::new(false)),
+            auto_aq_supported: Arc::new(Mutex::new(true)),
             auto_aq_enabled: Arc::new(Mutex::new(false)),
             picture_profile_adjustment_listener: Arc::new(Mutex::new(None)),
             sound_profile_adjustment_listener: Arc::new(Mutex::new(None)),
@@ -236,7 +236,7 @@
     fn getPictureProfileListener(&self) -> binder::Result<binder::Strong<dyn IPictureProfileChangedListener>> {
         println!("getPictureProfileListener");
         let listener = self.picture_profile_changed_listener.lock().unwrap();
-        listener.clone().ok_or(binder::StatusCode::UNKNOWN_ERROR.into())
+        Ok(listener.clone().expect("NONE"))
     }
 
     fn setPictureProfileAdjustmentListener(
diff --git a/tv/mediaquality/aidl/vts/functional/VtsHalMediaQualityTest.cpp b/tv/mediaquality/aidl/vts/functional/VtsHalMediaQualityTest.cpp
index a01d4b0..5d320d3 100644
--- a/tv/mediaquality/aidl/vts/functional/VtsHalMediaQualityTest.cpp
+++ b/tv/mediaquality/aidl/vts/functional/VtsHalMediaQualityTest.cpp
@@ -578,6 +578,18 @@
     ASSERT_OK(mediaquality->setAmbientBacklightCallback(callback));
 }
 
+TEST_P(MediaQualityAidl, TestGetPictureProfileChangedListener) {
+    std::shared_ptr<::aidl::android::hardware::tv::mediaquality::IPictureProfileChangedListener>
+            aidlListener;
+    mediaquality->getPictureProfileListener(&aidlListener);
+}
+
+TEST_P(MediaQualityAidl, TestGetSoundProfileChangedListener) {
+    std::shared_ptr<::aidl::android::hardware::tv::mediaquality::ISoundProfileChangedListener>
+            aidlListener;
+    mediaquality->getSoundProfileListener(&aidlListener);
+}
+
 TEST_P(MediaQualityAidl, TestSetPictureProfileAdjustmentListener) {
     std::shared_ptr<PictureProfileAdjustmentListener> listener =
             ndk::SharedRefBase::make<PictureProfileAdjustmentListener>(
diff --git a/wifi/apex/Android.bp b/wifi/apex/Android.bp
index f8c8e6f..5052ebb 100644
--- a/wifi/apex/Android.bp
+++ b/wifi/apex/Android.bp
@@ -15,13 +15,6 @@
     installable: false,
 }
 
-prebuilt_etc {
-    name: "com.android.hardware.wifi.xml",
-    src: ":default-android.hardware.wifi-service.xml",
-    installable: false,
-    sub_dir: "vintf",
-}
-
 apex {
     name: "com.android.hardware.wifi",
     manifest: "apex_manifest.json",
@@ -36,7 +29,6 @@
     ],
     prebuilts: [
         "com.android.hardware.wifi.rc",
-        "com.android.hardware.wifi.xml",
     ],
     overrides: [
         "android.hardware.wifi-service",