Merge "Add IfaceConcurrencyType and related methods for AP_BRIDGED concurrency"
diff --git a/audio/common/all-versions/default/Android.bp b/audio/common/all-versions/default/Android.bp
index 8f55744..a25565d 100644
--- a/audio/common/all-versions/default/Android.bp
+++ b/audio/common/all-versions/default/Android.bp
@@ -157,6 +157,28 @@
],
}
+cc_library {
+ name: "android.hardware.audio.common@7.1-util",
+ defaults: ["android.hardware.audio.common-util_default"],
+ srcs: [
+ "7.0/HidlUtils.cpp",
+ "HidlUtilsCommon.cpp",
+ "UuidUtils.cpp",
+ ],
+ shared_libs: [
+ "android.hardware.audio.common@7.0",
+ "android.hardware.audio.common@7.1-enums",
+ "libbase",
+ ],
+ cflags: [
+ "-DMAJOR_VERSION=7",
+ "-DMINOR_VERSION=1",
+ "-DCOMMON_TYPES_MINOR_VERSION=0",
+ "-DCORE_TYPES_MINOR_VERSION=0",
+ "-include common/all-versions/VersionMacro.h",
+ ],
+}
+
// Note: this isn't a VTS test, but rather a unit test
// to verify correctness of conversion utilities.
cc_test {
@@ -214,3 +236,35 @@
test_suites: ["device-tests"],
}
+
+cc_test {
+ name: "android.hardware.audio.common@7.1-util_tests",
+ defaults: ["android.hardware.audio.common-util_default"],
+
+ srcs: ["tests/hidlutils_tests.cpp"],
+
+ // Use static linking to allow running in presubmit on
+ // targets that don't have HAL V7.1.
+ static_libs: [
+ "android.hardware.audio.common@7.1-enums",
+ "android.hardware.audio.common@7.1-util",
+ "android.hardware.audio.common@7.0",
+ ],
+
+ shared_libs: [
+ "libbase",
+ "libxml2",
+ ],
+
+ cflags: [
+ "-Werror",
+ "-Wall",
+ "-DMAJOR_VERSION=7",
+ "-DMINOR_VERSION=1",
+ "-DCOMMON_TYPES_MINOR_VERSION=0",
+ "-DCORE_TYPES_MINOR_VERSION=0",
+ "-include common/all-versions/VersionMacro.h",
+ ],
+
+ test_suites: ["device-tests"],
+}
diff --git a/audio/common/all-versions/default/HidlUtilsCommon.cpp b/audio/common/all-versions/default/HidlUtilsCommon.cpp
index d2da193..bc3d870 100644
--- a/audio/common/all-versions/default/HidlUtilsCommon.cpp
+++ b/audio/common/all-versions/default/HidlUtilsCommon.cpp
@@ -20,7 +20,7 @@
namespace hardware {
namespace audio {
namespace common {
-namespace CPP_VERSION {
+namespace COMMON_TYPES_CPP_VERSION {
namespace implementation {
status_t HidlUtils::audioPortConfigsFromHal(unsigned int numHalConfigs,
@@ -51,7 +51,7 @@
}
} // namespace implementation
-} // namespace CPP_VERSION
+} // namespace COMMON_TYPES_CPP_VERSION
} // namespace common
} // namespace audio
} // namespace hardware
diff --git a/audio/common/all-versions/default/TEST_MAPPING b/audio/common/all-versions/default/TEST_MAPPING
index c965113..780beea 100644
--- a/audio/common/all-versions/default/TEST_MAPPING
+++ b/audio/common/all-versions/default/TEST_MAPPING
@@ -5,6 +5,9 @@
},
{
"name": "android.hardware.audio.common@7.0-util_tests"
+ },
+ {
+ "name": "android.hardware.audio.common@7.1-util_tests"
}
]
}
diff --git a/audio/common/all-versions/default/tests/hidlutils_tests.cpp b/audio/common/all-versions/default/tests/hidlutils_tests.cpp
index 2749cce..ec16b02 100644
--- a/audio/common/all-versions/default/tests/hidlutils_tests.cpp
+++ b/audio/common/all-versions/default/tests/hidlutils_tests.cpp
@@ -23,7 +23,7 @@
#include <log/log.h>
#include <HidlUtils.h>
-#include <android_audio_policy_configuration_V7_0-enums.h>
+#include PATH(APM_XSD_ENUMS_H_FILENAME)
#include <system/audio.h>
#include <xsdc/XsdcSupport.h>
@@ -32,7 +32,7 @@
using namespace ::android::hardware::audio::common::COMMON_TYPES_CPP_VERSION;
using ::android::hardware::audio::common::COMMON_TYPES_CPP_VERSION::implementation::HidlUtils;
namespace xsd {
-using namespace ::android::audio::policy::configuration::V7_0;
+using namespace ::android::audio::policy::configuration::CPP_VERSION;
}
static constexpr audio_channel_mask_t kInvalidHalChannelMask = AUDIO_CHANNEL_INVALID;
diff --git a/audio/core/all-versions/default/Android.bp b/audio/core/all-versions/default/Android.bp
index df688fd..3536561 100644
--- a/audio/core/all-versions/default/Android.bp
+++ b/audio/core/all-versions/default/Android.bp
@@ -168,10 +168,10 @@
shared_libs: [
"android.hardware.audio@7.0",
"android.hardware.audio@7.1",
- "android.hardware.audio@7.0-util",
+ "android.hardware.audio@7.1-util",
"android.hardware.audio.common@7.0",
"android.hardware.audio.common@7.1-enums",
- "android.hardware.audio.common@7.0-util",
+ "android.hardware.audio.common@7.1-util",
"libbase",
],
cflags: [
diff --git a/audio/core/all-versions/default/TEST_MAPPING b/audio/core/all-versions/default/TEST_MAPPING
index 1e29440..07e98f3 100644
--- a/audio/core/all-versions/default/TEST_MAPPING
+++ b/audio/core/all-versions/default/TEST_MAPPING
@@ -4,6 +4,9 @@
"name": "android.hardware.audio@7.0-util_tests"
},
{
+ "name": "android.hardware.audio@7.1-util_tests"
+ },
+ {
"name": "HalAudioV6_0GeneratorTest"
},
{
diff --git a/audio/core/all-versions/default/util/Android.bp b/audio/core/all-versions/default/util/Android.bp
index 7caf18d..b96f2d2 100644
--- a/audio/core/all-versions/default/util/Android.bp
+++ b/audio/core/all-versions/default/util/Android.bp
@@ -112,6 +112,25 @@
],
}
+cc_library {
+ name: "android.hardware.audio@7.1-util",
+ defaults: ["android.hardware.audio-util_default"],
+ shared_libs: [
+ "android.hardware.audio.common@7.0",
+ "android.hardware.audio.common@7.1-enums",
+ "android.hardware.audio.common@7.1-util",
+ "android.hardware.audio@7.1",
+ "libbase",
+ ],
+ cflags: [
+ "-DMAJOR_VERSION=7",
+ "-DMINOR_VERSION=1",
+ "-DCOMMON_TYPES_MINOR_VERSION=0",
+ "-DCORE_TYPES_MINOR_VERSION=0",
+ "-include common/all-versions/VersionMacro.h",
+ ],
+}
+
// Note: this isn't a VTS test, but rather a unit test
// to verify correctness of conversion utilities.
cc_test {
@@ -145,3 +164,37 @@
test_suites: ["device-tests"],
}
+
+cc_test {
+ name: "android.hardware.audio@7.1-util_tests",
+ defaults: ["android.hardware.audio-util_default"],
+
+ srcs: ["tests/coreutils_tests.cpp"],
+
+ // Use static linking to allow running in presubmit on
+ // targets that don't have HAL V7.1.
+ static_libs: [
+ "android.hardware.audio.common@7.0",
+ "android.hardware.audio.common@7.1-enums",
+ "android.hardware.audio.common@7.1-util",
+ "android.hardware.audio@7.1",
+ "android.hardware.audio@7.1-util",
+ ],
+
+ shared_libs: [
+ "libbase",
+ "libxml2",
+ ],
+
+ cflags: [
+ "-Werror",
+ "-Wall",
+ "-DMAJOR_VERSION=7",
+ "-DMINOR_VERSION=1",
+ "-DCOMMON_TYPES_MINOR_VERSION=0",
+ "-DCORE_TYPES_MINOR_VERSION=0",
+ "-include common/all-versions/VersionMacro.h",
+ ],
+
+ test_suites: ["device-tests"],
+}
diff --git a/audio/core/all-versions/default/util/tests/coreutils_tests.cpp b/audio/core/all-versions/default/util/tests/coreutils_tests.cpp
index 3976b08..0e15960 100644
--- a/audio/core/all-versions/default/util/tests/coreutils_tests.cpp
+++ b/audio/core/all-versions/default/util/tests/coreutils_tests.cpp
@@ -22,18 +22,18 @@
#define LOG_TAG "CoreUtils_Test"
#include <log/log.h>
-#include <android_audio_policy_configuration_V7_0-enums.h>
+#include PATH(APM_XSD_ENUMS_H_FILENAME)
#include <system/audio.h>
#include <util/CoreUtils.h>
#include <xsdc/XsdcSupport.h>
using namespace android;
using namespace ::android::hardware::audio::common::COMMON_TYPES_CPP_VERSION;
-using namespace ::android::hardware::audio::CPP_VERSION;
+using namespace ::android::hardware::audio::CORE_TYPES_CPP_VERSION;
using ::android::hardware::hidl_vec;
-using ::android::hardware::audio::CPP_VERSION::implementation::CoreUtils;
+using ::android::hardware::audio::CORE_TYPES_CPP_VERSION::implementation::CoreUtils;
namespace xsd {
-using namespace ::android::audio::policy::configuration::V7_0;
+using namespace ::android::audio::policy::configuration::CPP_VERSION;
}
static constexpr audio_channel_mask_t kInvalidHalChannelMask = AUDIO_CHANNEL_INVALID;
diff --git a/audio/core/all-versions/vts/functional/7.1/AudioPrimaryHidlHalTest.cpp b/audio/core/all-versions/vts/functional/7.1/AudioPrimaryHidlHalTest.cpp
index 6b9b32d..09b25d9 100644
--- a/audio/core/all-versions/vts/functional/7.1/AudioPrimaryHidlHalTest.cpp
+++ b/audio/core/all-versions/vts/functional/7.1/AudioPrimaryHidlHalTest.cpp
@@ -47,6 +47,7 @@
// initial state. To workaround this, destroy the HAL at the end of this test.
ASSERT_TRUE(resetDevice());
}
+
class LatencyModeOutputStreamTest : public OutputStreamTest {
protected:
void SetUp() override {
@@ -95,3 +96,8 @@
EXPECT_OK(stream->setLatencyModeCallback(new MockOutLatencyModeCallback));
EXPECT_OK(stream->setLatencyModeCallback(nullptr));
}
+
+INSTANTIATE_TEST_CASE_P(LatencyModeOutputStream, LatencyModeOutputStreamTest,
+ ::testing::ValuesIn(getOutputDeviceSingleConfigParameters()),
+ &DeviceConfigParameterToString);
+GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(LatencyModeOutputStreamTest);
diff --git a/audio/core/all-versions/vts/functional/Android.bp b/audio/core/all-versions/vts/functional/Android.bp
index 61ab1bb..87063a7 100644
--- a/audio/core/all-versions/vts/functional/Android.bp
+++ b/audio/core/all-versions/vts/functional/Android.bp
@@ -200,7 +200,7 @@
"android.hardware.audio.common@7.0",
"android.hardware.audio.common@7.0-enums",
"android.hardware.audio.common@7.1-enums",
- "android.hardware.audio.common@7.0-util",
+ "android.hardware.audio.common@7.1-util",
],
cflags: [
"-DMAJOR_VERSION=7",
diff --git a/automotive/vehicle/aidl/aidl_api/android.hardware.automotive.vehicle/current/android/hardware/automotive/vehicle/VehicleProperty.aidl b/automotive/vehicle/aidl/aidl_api/android.hardware.automotive.vehicle/current/android/hardware/automotive/vehicle/VehicleProperty.aidl
index 5cd814c..04f8fa3 100644
--- a/automotive/vehicle/aidl/aidl_api/android.hardware.automotive.vehicle/current/android/hardware/automotive/vehicle/VehicleProperty.aidl
+++ b/automotive/vehicle/aidl/aidl_api/android.hardware.automotive.vehicle/current/android/hardware/automotive/vehicle/VehicleProperty.aidl
@@ -205,4 +205,5 @@
EV_CHARGE_TIME_REMAINING = 289410883,
EV_REGENERATIVE_BRAKING_STATE = 289410884,
TRAILER_PRESENT = 289410885,
+ VEHICLE_CURB_WEIGHT = 289410886,
}
diff --git a/automotive/vehicle/aidl/android/hardware/automotive/vehicle/VehicleProperty.aidl b/automotive/vehicle/aidl/android/hardware/automotive/vehicle/VehicleProperty.aidl
index 9dbeae2..727b949 100644
--- a/automotive/vehicle/aidl/android/hardware/automotive/vehicle/VehicleProperty.aidl
+++ b/automotive/vehicle/aidl/android/hardware/automotive/vehicle/VehicleProperty.aidl
@@ -2815,4 +2815,29 @@
*/
TRAILER_PRESENT = 0x0F45 + 0x10000000 + 0x01000000
+ 0x00400000, // VehiclePropertyGroup:SYSTEM,VehicleArea:GLOBAL,VehiclePropertyType:INT32
+
+ /**
+ * Vehicle’s curb weight
+ *
+ * Returns the vehicle's curb weight in kilograms. Curb weight is
+ * the total weight of the vehicle with standard equipment and all
+ * necessary operating consumables such as motor oil,transmission oil,
+ * brake fluid, coolant, air conditioning refrigerant, and weight of
+ * fuel at nominal tank capacity, while not loaded with either passengers
+ * or cargo.
+ *
+ * configArray[0] is used to specify the vehicle’s gross weight in kilograms.
+ * The vehicle’s gross weight is the maximum operating weight of the vehicle
+ * as specified by the manufacturer including the vehicle's chassis, body, engine,
+ * engine fluids, fuel, accessories, driver, passengers and cargo but excluding
+ * that of any trailers.
+ *
+ * @change_mode VehiclePropertyChangeMode:STATIC
+ * @access VehiclePropertyAccess:READ
+ * @unit VehicleUnit:KILOGRAM
+ */
+
+ VEHICLE_CURB_WEIGHT = 0x0F46 + 0x10000000 + 0x01000000
+ + 0x00400000, // VehiclePropertyGroup:SYSTEM,VehicleArea:GLOBAL,VehiclePropertyType:INT32
+
}
diff --git a/wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/Bandwidth.aidl b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/AptxAdaptiveCapabilities.aidl
similarity index 73%
copy from wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/Bandwidth.aidl
copy to bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/AptxAdaptiveCapabilities.aidl
index 4d78640..4e5dfe6 100644
--- a/wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/Bandwidth.aidl
+++ b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/AptxAdaptiveCapabilities.aidl
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2021 The Android Open Source Project
+ * Copyright 2022 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.
@@ -31,19 +31,16 @@
// 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.wifi.hostapd;
-@Backing(type="int") @VintfStability
-enum Bandwidth {
- BANDWIDTH_INVALID = 0,
- BANDWIDTH_20_NOHT = 1,
- BANDWIDTH_20 = 2,
- BANDWIDTH_40 = 3,
- BANDWIDTH_80 = 4,
- BANDWIDTH_80P80 = 5,
- BANDWIDTH_160 = 6,
- BANDWIDTH_320 = 7,
- BANDWIDTH_2160 = 8,
- BANDWIDTH_4320 = 9,
- BANDWIDTH_6480 = 10,
- BANDWIDTH_8640 = 11,
+package android.hardware.bluetooth.audio;
+@VintfStability
+parcelable AptxAdaptiveCapabilities {
+ int[] sampleRateHz;
+ android.hardware.bluetooth.audio.AptxAdaptiveChannelMode[] channelMode;
+ byte[] bitsPerSample;
+ android.hardware.bluetooth.audio.AptxMode[] aptxMode;
+ android.hardware.bluetooth.audio.AptxSinkBuffering sinkBufferingMs;
+ android.hardware.bluetooth.audio.AptxAdaptiveTimeToPlay ttp;
+ android.hardware.bluetooth.audio.AptxAdaptiveInputMode inputMode;
+ int inputFadeDurationMs;
+ byte[] aptxAdaptiveConfigStream;
}
diff --git a/wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/Bandwidth.aidl b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/AptxAdaptiveChannelMode.aidl
similarity index 81%
copy from wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/Bandwidth.aidl
copy to bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/AptxAdaptiveChannelMode.aidl
index 4d78640..0499b70 100644
--- a/wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/Bandwidth.aidl
+++ b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/AptxAdaptiveChannelMode.aidl
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2021 The Android Open Source Project
+ * Copyright 2022 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.
@@ -31,19 +31,12 @@
// 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.wifi.hostapd;
+package android.hardware.bluetooth.audio;
@Backing(type="int") @VintfStability
-enum Bandwidth {
- BANDWIDTH_INVALID = 0,
- BANDWIDTH_20_NOHT = 1,
- BANDWIDTH_20 = 2,
- BANDWIDTH_40 = 3,
- BANDWIDTH_80 = 4,
- BANDWIDTH_80P80 = 5,
- BANDWIDTH_160 = 6,
- BANDWIDTH_320 = 7,
- BANDWIDTH_2160 = 8,
- BANDWIDTH_4320 = 9,
- BANDWIDTH_6480 = 10,
- BANDWIDTH_8640 = 11,
+enum AptxAdaptiveChannelMode {
+ JOINT_STEREO = 0,
+ MONO = 1,
+ DUAL_MONO = 2,
+ TWS_STEREO = 4,
+ UNKNOWN = 255,
}
diff --git a/wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/Bandwidth.aidl b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/AptxAdaptiveConfiguration.aidl
similarity index 73%
copy from wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/Bandwidth.aidl
copy to bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/AptxAdaptiveConfiguration.aidl
index 4d78640..aab0521 100644
--- a/wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/Bandwidth.aidl
+++ b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/AptxAdaptiveConfiguration.aidl
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2021 The Android Open Source Project
+ * Copyright 2022 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.
@@ -31,19 +31,16 @@
// 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.wifi.hostapd;
-@Backing(type="int") @VintfStability
-enum Bandwidth {
- BANDWIDTH_INVALID = 0,
- BANDWIDTH_20_NOHT = 1,
- BANDWIDTH_20 = 2,
- BANDWIDTH_40 = 3,
- BANDWIDTH_80 = 4,
- BANDWIDTH_80P80 = 5,
- BANDWIDTH_160 = 6,
- BANDWIDTH_320 = 7,
- BANDWIDTH_2160 = 8,
- BANDWIDTH_4320 = 9,
- BANDWIDTH_6480 = 10,
- BANDWIDTH_8640 = 11,
+package android.hardware.bluetooth.audio;
+@VintfStability
+parcelable AptxAdaptiveConfiguration {
+ int sampleRateHz;
+ android.hardware.bluetooth.audio.AptxAdaptiveChannelMode channelMode;
+ byte bitsPerSample;
+ android.hardware.bluetooth.audio.AptxMode aptxMode;
+ android.hardware.bluetooth.audio.AptxSinkBuffering sinkBufferingMs;
+ android.hardware.bluetooth.audio.AptxAdaptiveTimeToPlay ttp;
+ android.hardware.bluetooth.audio.AptxAdaptiveInputMode inputMode;
+ int inputFadeDurationMs;
+ byte[] aptxAdaptiveConfigStream;
}
diff --git a/wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/Bandwidth.aidl b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/AptxAdaptiveInputMode.aidl
similarity index 81%
copy from wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/Bandwidth.aidl
copy to bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/AptxAdaptiveInputMode.aidl
index 4d78640..f702939 100644
--- a/wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/Bandwidth.aidl
+++ b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/AptxAdaptiveInputMode.aidl
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2021 The Android Open Source Project
+ * Copyright 2022 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.
@@ -31,19 +31,9 @@
// 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.wifi.hostapd;
+package android.hardware.bluetooth.audio;
@Backing(type="int") @VintfStability
-enum Bandwidth {
- BANDWIDTH_INVALID = 0,
- BANDWIDTH_20_NOHT = 1,
- BANDWIDTH_20 = 2,
- BANDWIDTH_40 = 3,
- BANDWIDTH_80 = 4,
- BANDWIDTH_80P80 = 5,
- BANDWIDTH_160 = 6,
- BANDWIDTH_320 = 7,
- BANDWIDTH_2160 = 8,
- BANDWIDTH_4320 = 9,
- BANDWIDTH_6480 = 10,
- BANDWIDTH_8640 = 11,
+enum AptxAdaptiveInputMode {
+ STEREO = 0,
+ DUAL_MONO = 1,
}
diff --git a/wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/Bandwidth.aidl b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/AptxAdaptiveTimeToPlay.aidl
similarity index 79%
copy from wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/Bandwidth.aidl
copy to bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/AptxAdaptiveTimeToPlay.aidl
index 4d78640..3560666 100644
--- a/wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/Bandwidth.aidl
+++ b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/AptxAdaptiveTimeToPlay.aidl
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2021 The Android Open Source Project
+ * Copyright 2022 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.
@@ -31,19 +31,13 @@
// 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.wifi.hostapd;
-@Backing(type="int") @VintfStability
-enum Bandwidth {
- BANDWIDTH_INVALID = 0,
- BANDWIDTH_20_NOHT = 1,
- BANDWIDTH_20 = 2,
- BANDWIDTH_40 = 3,
- BANDWIDTH_80 = 4,
- BANDWIDTH_80P80 = 5,
- BANDWIDTH_160 = 6,
- BANDWIDTH_320 = 7,
- BANDWIDTH_2160 = 8,
- BANDWIDTH_4320 = 9,
- BANDWIDTH_6480 = 10,
- BANDWIDTH_8640 = 11,
+package android.hardware.bluetooth.audio;
+@VintfStability
+parcelable AptxAdaptiveTimeToPlay {
+ byte lowLowLatency;
+ byte highLowLatency;
+ byte lowHighQuality;
+ byte highHighQuality;
+ byte lowTws;
+ byte highTws;
}
diff --git a/wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/Bandwidth.aidl b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/AptxMode.aidl
similarity index 81%
copy from wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/Bandwidth.aidl
copy to bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/AptxMode.aidl
index 4d78640..d5dd9d9 100644
--- a/wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/Bandwidth.aidl
+++ b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/AptxMode.aidl
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2021 The Android Open Source Project
+ * Copyright 2022 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.
@@ -31,19 +31,11 @@
// 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.wifi.hostapd;
+package android.hardware.bluetooth.audio;
@Backing(type="int") @VintfStability
-enum Bandwidth {
- BANDWIDTH_INVALID = 0,
- BANDWIDTH_20_NOHT = 1,
- BANDWIDTH_20 = 2,
- BANDWIDTH_40 = 3,
- BANDWIDTH_80 = 4,
- BANDWIDTH_80P80 = 5,
- BANDWIDTH_160 = 6,
- BANDWIDTH_320 = 7,
- BANDWIDTH_2160 = 8,
- BANDWIDTH_4320 = 9,
- BANDWIDTH_6480 = 10,
- BANDWIDTH_8640 = 11,
+enum AptxMode {
+ UNKNOWN = 0,
+ HIGH_QUALITY = 4096,
+ LOW_LATENCY = 8192,
+ ULTRA_LOW_LATENCY = 16384,
}
diff --git a/wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/Bandwidth.aidl b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/AptxSinkBuffering.aidl
similarity index 79%
copy from wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/Bandwidth.aidl
copy to bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/AptxSinkBuffering.aidl
index 4d78640..527418e 100644
--- a/wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/Bandwidth.aidl
+++ b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/AptxSinkBuffering.aidl
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2021 The Android Open Source Project
+ * Copyright 2022 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.
@@ -31,19 +31,13 @@
// 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.wifi.hostapd;
-@Backing(type="int") @VintfStability
-enum Bandwidth {
- BANDWIDTH_INVALID = 0,
- BANDWIDTH_20_NOHT = 1,
- BANDWIDTH_20 = 2,
- BANDWIDTH_40 = 3,
- BANDWIDTH_80 = 4,
- BANDWIDTH_80P80 = 5,
- BANDWIDTH_160 = 6,
- BANDWIDTH_320 = 7,
- BANDWIDTH_2160 = 8,
- BANDWIDTH_4320 = 9,
- BANDWIDTH_6480 = 10,
- BANDWIDTH_8640 = 11,
+package android.hardware.bluetooth.audio;
+@VintfStability
+parcelable AptxSinkBuffering {
+ byte minLowLatency;
+ byte maxLowLatency;
+ byte minHighQuality;
+ byte maxHighQuality;
+ byte minTws;
+ byte maxTws;
}
diff --git a/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/CodecCapabilities.aidl b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/CodecCapabilities.aidl
index 948c04a..6efdcb7 100644
--- a/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/CodecCapabilities.aidl
+++ b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/CodecCapabilities.aidl
@@ -46,6 +46,7 @@
android.hardware.bluetooth.audio.AacCapabilities aacCapabilities;
android.hardware.bluetooth.audio.LdacCapabilities ldacCapabilities;
android.hardware.bluetooth.audio.AptxCapabilities aptxCapabilities;
+ android.hardware.bluetooth.audio.AptxAdaptiveCapabilities aptxAdaptiveCapabilities;
android.hardware.bluetooth.audio.Lc3Capabilities lc3Capabilities;
android.hardware.bluetooth.audio.CodecCapabilities.VendorCapabilities vendorCapabilities;
}
diff --git a/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/CodecConfiguration.aidl b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/CodecConfiguration.aidl
index 32bccd8..77a6b1b 100644
--- a/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/CodecConfiguration.aidl
+++ b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/CodecConfiguration.aidl
@@ -51,6 +51,7 @@
android.hardware.bluetooth.audio.AacConfiguration aacConfig;
android.hardware.bluetooth.audio.LdacConfiguration ldacConfig;
android.hardware.bluetooth.audio.AptxConfiguration aptxConfig;
+ android.hardware.bluetooth.audio.AptxAdaptiveConfiguration aptxAdaptiveConfig;
android.hardware.bluetooth.audio.Lc3Configuration lc3Config;
android.hardware.bluetooth.audio.CodecConfiguration.VendorConfiguration vendorConfig;
}
diff --git a/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/CodecType.aidl b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/CodecType.aidl
index 3a5f951..1522cb4 100644
--- a/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/CodecType.aidl
+++ b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/CodecType.aidl
@@ -42,4 +42,5 @@
LDAC = 5,
LC3 = 6,
VENDOR = 7,
+ APTX_ADAPTIVE = 8,
}
diff --git a/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/IBluetoothAudioPort.aidl b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/IBluetoothAudioPort.aidl
index 9a1557a..cc3c641 100644
--- a/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/IBluetoothAudioPort.aidl
+++ b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/IBluetoothAudioPort.aidl
@@ -40,4 +40,6 @@
void suspendStream();
void updateSourceMetadata(in android.hardware.audio.common.SourceMetadata sourceMetadata);
void updateSinkMetadata(in android.hardware.audio.common.SinkMetadata sinkMetadata);
+ void setLatencyMode(in android.hardware.bluetooth.audio.LatencyMode latencyMode);
+ void setCodecType(in android.hardware.bluetooth.audio.CodecType codecType);
}
diff --git a/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/IBluetoothAudioProvider.aidl b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/IBluetoothAudioProvider.aidl
index 0dcba2e..6e0bd98 100644
--- a/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/IBluetoothAudioProvider.aidl
+++ b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/IBluetoothAudioProvider.aidl
@@ -39,4 +39,5 @@
void streamStarted(in android.hardware.bluetooth.audio.BluetoothAudioStatus status);
void streamSuspended(in android.hardware.bluetooth.audio.BluetoothAudioStatus status);
void updateAudioConfiguration(in android.hardware.bluetooth.audio.AudioConfiguration audioConfig);
+ void setLowLatencyModeAllowed(in boolean allowed);
}
diff --git a/wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/Bandwidth.aidl b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/LatencyMode.aidl
similarity index 81%
copy from wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/Bandwidth.aidl
copy to bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/LatencyMode.aidl
index 4d78640..5583679 100644
--- a/wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/Bandwidth.aidl
+++ b/bluetooth/audio/aidl/aidl_api/android.hardware.bluetooth.audio/current/android/hardware/bluetooth/audio/LatencyMode.aidl
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2021 The Android Open Source Project
+ * Copyright 2022 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.
@@ -31,19 +31,10 @@
// 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.wifi.hostapd;
+package android.hardware.bluetooth.audio;
@Backing(type="int") @VintfStability
-enum Bandwidth {
- BANDWIDTH_INVALID = 0,
- BANDWIDTH_20_NOHT = 1,
- BANDWIDTH_20 = 2,
- BANDWIDTH_40 = 3,
- BANDWIDTH_80 = 4,
- BANDWIDTH_80P80 = 5,
- BANDWIDTH_160 = 6,
- BANDWIDTH_320 = 7,
- BANDWIDTH_2160 = 8,
- BANDWIDTH_4320 = 9,
- BANDWIDTH_6480 = 10,
- BANDWIDTH_8640 = 11,
+enum LatencyMode {
+ UNKNOWN = 0,
+ LOW_LATENCY = 1,
+ FREE = 2,
}
diff --git a/bluetooth/audio/aidl/android/hardware/bluetooth/audio/AptxAdaptiveCapabilities.aidl b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/AptxAdaptiveCapabilities.aidl
new file mode 100644
index 0000000..6a56704
--- /dev/null
+++ b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/AptxAdaptiveCapabilities.aidl
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.hardware.bluetooth.audio;
+
+import android.hardware.bluetooth.audio.AptxAdaptiveChannelMode;
+import android.hardware.bluetooth.audio.AptxMode;
+import android.hardware.bluetooth.audio.AptxSinkBuffering;
+import android.hardware.bluetooth.audio.AptxAdaptiveTimeToPlay;
+import android.hardware.bluetooth.audio.AptxAdaptiveInputMode;
+
+
+@VintfStability
+parcelable AptxAdaptiveCapabilities {
+ int[] sampleRateHz;
+ AptxAdaptiveChannelMode[] channelMode;
+ byte[] bitsPerSample;
+ AptxMode[] aptxMode;
+ AptxSinkBuffering sinkBufferingMs;
+ AptxAdaptiveTimeToPlay ttp;
+ AptxAdaptiveInputMode inputMode;
+ int inputFadeDurationMs;
+ byte[] aptxAdaptiveConfigStream;
+}
diff --git a/bluetooth/audio/aidl/android/hardware/bluetooth/audio/AptxAdaptiveChannelMode.aidl b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/AptxAdaptiveChannelMode.aidl
new file mode 100644
index 0000000..c5e89b1
--- /dev/null
+++ b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/AptxAdaptiveChannelMode.aidl
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.hardware.bluetooth.audio;
+
+@VintfStability
+@Backing(type="int")
+enum AptxAdaptiveChannelMode {
+ /* Joint Stereo - default mode */
+ JOINT_STEREO = 0,
+ /* Legacy Mono */
+ MONO = 1,
+ /* Two streams L & R in a single channel (TWS) */
+ DUAL_MONO = 2,
+ /* Stereo - For TWS+ where L and R are different links */
+ TWS_STEREO = 4,
+ UNKNOWN = 0xFF,
+}
diff --git a/bluetooth/audio/aidl/android/hardware/bluetooth/audio/AptxAdaptiveConfiguration.aidl b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/AptxAdaptiveConfiguration.aidl
new file mode 100644
index 0000000..84c3119
--- /dev/null
+++ b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/AptxAdaptiveConfiguration.aidl
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.hardware.bluetooth.audio;
+
+import android.hardware.bluetooth.audio.AptxAdaptiveChannelMode;
+import android.hardware.bluetooth.audio.AptxMode;
+import android.hardware.bluetooth.audio.AptxSinkBuffering;
+import android.hardware.bluetooth.audio.AptxAdaptiveTimeToPlay;
+import android.hardware.bluetooth.audio.AptxAdaptiveInputMode;
+
+@VintfStability
+parcelable AptxAdaptiveConfiguration {
+ int sampleRateHz;
+ AptxAdaptiveChannelMode channelMode;
+ byte bitsPerSample;
+ AptxMode aptxMode;
+ AptxSinkBuffering sinkBufferingMs;
+ AptxAdaptiveTimeToPlay ttp;
+ AptxAdaptiveInputMode inputMode;
+ int inputFadeDurationMs;
+ byte[] aptxAdaptiveConfigStream;
+}
diff --git a/bluetooth/audio/aidl/android/hardware/bluetooth/audio/AptxAdaptiveInputMode.aidl b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/AptxAdaptiveInputMode.aidl
new file mode 100644
index 0000000..c2f0fc9
--- /dev/null
+++ b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/AptxAdaptiveInputMode.aidl
@@ -0,0 +1,24 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.hardware.bluetooth.audio;
+
+@VintfStability
+@Backing(type="int")
+enum AptxAdaptiveInputMode {
+ STEREO = 0x00,
+ DUAL_MONO = 0x01,
+}
diff --git a/bluetooth/audio/aidl/android/hardware/bluetooth/audio/AptxAdaptiveTimeToPlay.aidl b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/AptxAdaptiveTimeToPlay.aidl
new file mode 100644
index 0000000..9bcf1a4
--- /dev/null
+++ b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/AptxAdaptiveTimeToPlay.aidl
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.hardware.bluetooth.audio;
+
+@VintfStability
+parcelable AptxAdaptiveTimeToPlay {
+ byte lowLowLatency;
+ byte highLowLatency;
+ byte lowHighQuality;
+ byte highHighQuality;
+ byte lowTws;
+ byte highTws;
+}
diff --git a/bluetooth/audio/aidl/android/hardware/bluetooth/audio/AptxMode.aidl b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/AptxMode.aidl
new file mode 100644
index 0000000..2422d69
--- /dev/null
+++ b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/AptxMode.aidl
@@ -0,0 +1,24 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package android.hardware.bluetooth.audio;
+@VintfStability
+@Backing(type="int")
+enum AptxMode {
+ UNKNOWN = 0x00,
+ HIGH_QUALITY = 0x1000,
+ LOW_LATENCY = 0x2000,
+ ULTRA_LOW_LATENCY = 0x4000,
+}
diff --git a/bluetooth/audio/aidl/android/hardware/bluetooth/audio/AptxSinkBuffering.aidl b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/AptxSinkBuffering.aidl
new file mode 100644
index 0000000..3593b5d
--- /dev/null
+++ b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/AptxSinkBuffering.aidl
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.hardware.bluetooth.audio;
+
+@VintfStability
+parcelable AptxSinkBuffering {
+ byte minLowLatency;
+ byte maxLowLatency;
+ byte minHighQuality;
+ byte maxHighQuality;
+ byte minTws;
+ byte maxTws;
+}
+
diff --git a/bluetooth/audio/aidl/android/hardware/bluetooth/audio/CodecCapabilities.aidl b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/CodecCapabilities.aidl
index 41e2431..9fcdf1c 100644
--- a/bluetooth/audio/aidl/android/hardware/bluetooth/audio/CodecCapabilities.aidl
+++ b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/CodecCapabilities.aidl
@@ -18,6 +18,7 @@
import android.hardware.bluetooth.audio.AacCapabilities;
import android.hardware.bluetooth.audio.AptxCapabilities;
+import android.hardware.bluetooth.audio.AptxAdaptiveCapabilities;
import android.hardware.bluetooth.audio.CodecType;
import android.hardware.bluetooth.audio.Lc3Capabilities;
import android.hardware.bluetooth.audio.LdacCapabilities;
@@ -39,6 +40,7 @@
AacCapabilities aacCapabilities;
LdacCapabilities ldacCapabilities;
AptxCapabilities aptxCapabilities;
+ AptxAdaptiveCapabilities aptxAdaptiveCapabilities;
Lc3Capabilities lc3Capabilities;
VendorCapabilities vendorCapabilities;
}
diff --git a/bluetooth/audio/aidl/android/hardware/bluetooth/audio/CodecConfiguration.aidl b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/CodecConfiguration.aidl
index 3679537..5ed12e3 100644
--- a/bluetooth/audio/aidl/android/hardware/bluetooth/audio/CodecConfiguration.aidl
+++ b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/CodecConfiguration.aidl
@@ -18,6 +18,7 @@
import android.hardware.bluetooth.audio.AacConfiguration;
import android.hardware.bluetooth.audio.AptxConfiguration;
+import android.hardware.bluetooth.audio.AptxAdaptiveConfiguration;
import android.hardware.bluetooth.audio.CodecType;
import android.hardware.bluetooth.audio.Lc3Configuration;
import android.hardware.bluetooth.audio.LdacConfiguration;
@@ -41,6 +42,7 @@
AacConfiguration aacConfig;
LdacConfiguration ldacConfig;
AptxConfiguration aptxConfig;
+ AptxAdaptiveConfiguration aptxAdaptiveConfig;
Lc3Configuration lc3Config;
VendorConfiguration vendorConfig;
}
diff --git a/bluetooth/audio/aidl/android/hardware/bluetooth/audio/CodecType.aidl b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/CodecType.aidl
index 9c33081..386876e 100644
--- a/bluetooth/audio/aidl/android/hardware/bluetooth/audio/CodecType.aidl
+++ b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/CodecType.aidl
@@ -27,4 +27,5 @@
LDAC,
LC3,
VENDOR,
+ APTX_ADAPTIVE,
}
diff --git a/bluetooth/audio/aidl/android/hardware/bluetooth/audio/IBluetoothAudioPort.aidl b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/IBluetoothAudioPort.aidl
index 827f57d..81c2ce2 100644
--- a/bluetooth/audio/aidl/android/hardware/bluetooth/audio/IBluetoothAudioPort.aidl
+++ b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/IBluetoothAudioPort.aidl
@@ -18,6 +18,8 @@
import android.hardware.audio.common.SinkMetadata;
import android.hardware.audio.common.SourceMetadata;
+import android.hardware.bluetooth.audio.CodecType;
+import android.hardware.bluetooth.audio.LatencyMode;
import android.hardware.bluetooth.audio.PresentationPosition;
/**
@@ -78,4 +80,18 @@
* @param sinkMetadata as passed from Audio Framework
*/
void updateSinkMetadata(in SinkMetadata sinkMetadata);
+
+ /**
+ * Called when latency mode is changed.
+ *
+ * @param latencyMode latency mode from audio
+ */
+ void setLatencyMode(in LatencyMode latencyMode);
+
+ /**
+ * Called when codec type is changed.
+ *
+ * @param codecType codec type from audio
+ */
+ void setCodecType(in CodecType codecType);
}
diff --git a/bluetooth/audio/aidl/android/hardware/bluetooth/audio/IBluetoothAudioProvider.aidl b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/IBluetoothAudioProvider.aidl
index 6f88f30..ca6f691 100644
--- a/bluetooth/audio/aidl/android/hardware/bluetooth/audio/IBluetoothAudioProvider.aidl
+++ b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/IBluetoothAudioProvider.aidl
@@ -82,4 +82,12 @@
* encoding.
*/
void updateAudioConfiguration(in AudioConfiguration audioConfig);
+
+ /**
+ * Called when the supported latency mode is updated.
+ *
+ * @param allowed If the peripheral devices can't keep up with low latency
+ * mode, the API will be called with supported is false.
+ */
+ void setLowLatencyModeAllowed(in boolean allowed);
}
diff --git a/bluetooth/audio/aidl/android/hardware/bluetooth/audio/LatencyMode.aidl b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/LatencyMode.aidl
new file mode 100644
index 0000000..0c354f7
--- /dev/null
+++ b/bluetooth/audio/aidl/android/hardware/bluetooth/audio/LatencyMode.aidl
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.hardware.bluetooth.audio;
+
+@VintfStability
+@Backing(type="int")
+enum LatencyMode {
+ UNKNOWN,
+ LOW_LATENCY,
+ FREE,
+}
diff --git a/bluetooth/audio/aidl/default/BluetoothAudioProvider.cpp b/bluetooth/audio/aidl/default/BluetoothAudioProvider.cpp
index c2ffa2e..54e82d1 100644
--- a/bluetooth/audio/aidl/default/BluetoothAudioProvider.cpp
+++ b/bluetooth/audio/aidl/default/BluetoothAudioProvider.cpp
@@ -121,6 +121,19 @@
return ndk::ScopedAStatus::ok();
}
+ndk::ScopedAStatus BluetoothAudioProvider::setLowLatencyModeAllowed(
+ bool allowed) {
+ LOG(INFO) << __func__ << " - SessionType=" << toString(session_type_);
+
+ if (stack_iface_ == nullptr) {
+ LOG(INFO) << __func__ << " - SessionType=" << toString(session_type_)
+ << " has NO session";
+ return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
+ }
+ LOG(INFO) << __func__ << " - allowed " << allowed;
+ return ndk::ScopedAStatus::ok();
+}
+
void BluetoothAudioProvider::binderDiedCallbackAidl(void* ptr) {
LOG(ERROR) << __func__ << " - BluetoothAudio Service died";
auto provider = static_cast<BluetoothAudioProvider*>(ptr);
diff --git a/bluetooth/audio/aidl/default/BluetoothAudioProvider.h b/bluetooth/audio/aidl/default/BluetoothAudioProvider.h
index f7acbdf..393aaba 100644
--- a/bluetooth/audio/aidl/default/BluetoothAudioProvider.h
+++ b/bluetooth/audio/aidl/default/BluetoothAudioProvider.h
@@ -46,6 +46,7 @@
ndk::ScopedAStatus streamSuspended(BluetoothAudioStatus status);
ndk::ScopedAStatus updateAudioConfiguration(
const AudioConfiguration& audio_config);
+ ndk::ScopedAStatus setLowLatencyModeAllowed(bool allowed);
virtual bool isValid(const SessionType& sessionType) = 0;
diff --git a/bluetooth/audio/utils/aidl_session/BluetoothAudioCodecs.cpp b/bluetooth/audio/utils/aidl_session/BluetoothAudioCodecs.cpp
index 516ebe8..a8d8817 100644
--- a/bluetooth/audio/utils/aidl_session/BluetoothAudioCodecs.cpp
+++ b/bluetooth/audio/utils/aidl_session/BluetoothAudioCodecs.cpp
@@ -356,6 +356,7 @@
break;
case CodecType::UNKNOWN:
case CodecType::VENDOR:
+ case CodecType::APTX_ADAPTIVE:
break;
}
}
@@ -419,6 +420,7 @@
return true;
}
break;
+ case CodecType::APTX_ADAPTIVE:
case CodecType::UNKNOWN:
case CodecType::VENDOR:
break;
@@ -487,4 +489,4 @@
} // namespace bluetooth
} // namespace hardware
} // namespace android
-} // namespace aidl
\ No newline at end of file
+} // namespace aidl
diff --git a/bluetooth/audio/utils/aidl_session/BluetoothAudioSession.cpp b/bluetooth/audio/utils/aidl_session/BluetoothAudioSession.cpp
index f626db8..96cd9ef 100644
--- a/bluetooth/audio/utils/aidl_session/BluetoothAudioSession.cpp
+++ b/bluetooth/audio/utils/aidl_session/BluetoothAudioSession.cpp
@@ -508,6 +508,36 @@
}
}
+void BluetoothAudioSession::SetLatencyMode(LatencyMode latency_mode) {
+ std::lock_guard<std::recursive_mutex> guard(mutex_);
+ if (!IsSessionReady()) {
+ LOG(DEBUG) << __func__ << " - SessionType=" << toString(session_type_)
+ << " has NO session";
+ return;
+ }
+
+ auto hal_retval = stack_iface_->setLatencyMode(latency_mode);
+ if (!hal_retval.isOk()) {
+ LOG(WARNING) << __func__ << " - IBluetoothAudioPort SessionType="
+ << toString(session_type_) << " failed";
+ }
+}
+
+void BluetoothAudioSession::SetCodecType(CodecType codec_type) {
+ std::lock_guard<std::recursive_mutex> guard(mutex_);
+ if (!IsSessionReady()) {
+ LOG(DEBUG) << __func__ << " - SessionType=" << toString(session_type_)
+ << " has NO session";
+ return;
+ }
+
+ auto hal_retval = stack_iface_->setCodecType(codec_type);
+ if (!hal_retval.isOk()) {
+ LOG(WARNING) << __func__ << " - IBluetoothAudioPort SessionType="
+ << toString(session_type_) << " failed";
+ }
+}
+
bool BluetoothAudioSession::IsAidlAvailable() {
if (is_aidl_checked) return is_aidl_available;
is_aidl_available =
diff --git a/bluetooth/audio/utils/aidl_session/BluetoothAudioSession.h b/bluetooth/audio/utils/aidl_session/BluetoothAudioSession.h
index 73bc0f8..5adc0e2 100644
--- a/bluetooth/audio/utils/aidl_session/BluetoothAudioSession.h
+++ b/bluetooth/audio/utils/aidl_session/BluetoothAudioSession.h
@@ -20,6 +20,7 @@
#include <aidl/android/hardware/audio/common/SourceMetadata.h>
#include <aidl/android/hardware/bluetooth/audio/IBluetoothAudioProvider.h>
#include <aidl/android/hardware/bluetooth/audio/IBluetoothAudioProviderFactory.h>
+#include <aidl/android/hardware/bluetooth/audio/LatencyMode.h>
#include <aidl/android/hardware/bluetooth/audio/SessionType.h>
#include <fmq/AidlMessageQueue.h>
#include <hardware/audio.h>
@@ -164,6 +165,8 @@
bool GetPresentationPosition(PresentationPosition& presentation_position);
void UpdateSourceMetadata(const struct source_metadata& source_metadata);
void UpdateSinkMetadata(const struct sink_metadata& sink_metadata);
+ void SetLatencyMode(LatencyMode latency_mode);
+ void SetCodecType(CodecType codec_type);
// The control function writes stream to FMQ
size_t OutWritePcmData(const void* buffer, size_t bytes);
diff --git a/bluetooth/audio/utils/session/BluetoothAudioSupportedCodecsDB_2_2.cpp b/bluetooth/audio/utils/session/BluetoothAudioSupportedCodecsDB_2_2.cpp
index 4c99b0f..decff70 100644
--- a/bluetooth/audio/utils/session/BluetoothAudioSupportedCodecsDB_2_2.cpp
+++ b/bluetooth/audio/utils/session/BluetoothAudioSupportedCodecsDB_2_2.cpp
@@ -77,9 +77,13 @@
// Stores the supported setting of audio location, connected device, and the
// channel count for each device
std::vector<std::tuple<AudioLocation, uint8_t, uint8_t>>
- supportedDeviceSetting = {std::make_tuple(stereoAudio, 2, 1),
- std::make_tuple(monoAudio, 1, 2),
- std::make_tuple(monoAudio, 1, 1)};
+ supportedDeviceSetting = {
+ // Stereo, two connected device, one for L one for R
+ std::make_tuple(stereoAudio, 2, 1),
+ // Stereo, one connected device for both L and R
+ std::make_tuple(stereoAudio, 1, 2),
+ // Mono
+ std::make_tuple(monoAudio, 1, 1)};
bool IsOffloadLeAudioConfigurationValid(
const ::android::hardware::bluetooth::audio::V2_1::SessionType&
diff --git a/gnss/aidl/default/Gnss.cpp b/gnss/aidl/default/Gnss.cpp
index af1dd5c..a861957 100644
--- a/gnss/aidl/default/Gnss.cpp
+++ b/gnss/aidl/default/Gnss.cpp
@@ -58,7 +58,8 @@
int capabilities = (int)(IGnssCallback::CAPABILITY_SATELLITE_BLOCKLIST |
IGnssCallback::CAPABILITY_SATELLITE_PVT |
- IGnssCallback::CAPABILITY_CORRELATION_VECTOR);
+ IGnssCallback::CAPABILITY_CORRELATION_VECTOR |
+ IGnssCallback::CAPABILITY_ANTENNA_INFO);
auto status = sGnssCallback->gnssSetCapabilitiesCb(capabilities);
if (!status.isOk()) {
diff --git a/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/Android.bp b/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/Android.bp
index bd2c3b1..139b5e8 100644
--- a/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/Android.bp
+++ b/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/Android.bp
@@ -35,6 +35,9 @@
"VtsHalGraphicsComposer3_TargetTest.cpp",
"VtsHalGraphicsComposer3_ReadbackTest.cpp",
"composer-vts/GraphicsComposerCallback.cpp",
+ "composer-vts/ReadbackVts.cpp",
+ "composer-vts/RenderEngineVts.cpp",
+ "composer-vts/VtsComposerClient.cpp",
],
shared_libs: [
@@ -72,15 +75,19 @@
"android.hardware.graphics.allocator@2.0",
"android.hardware.graphics.allocator@3.0",
"android.hardware.graphics.allocator@4.0",
- "android.hardware.graphics.composer@3-vts",
"android.hardware.graphics.mapper@2.0-vts",
"android.hardware.graphics.mapper@2.1-vts",
"android.hardware.graphics.mapper@3.0-vts",
"android.hardware.graphics.mapper@4.0-vts",
"libaidlcommonsupport",
+ "libarect",
+ "libbase",
+ "libfmq",
"libgtest",
+ "libmath",
"librenderengine",
"libshaders",
+ "libsync",
"libtonemap",
],
cflags: [
diff --git a/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/VtsHalGraphicsComposer3_ReadbackTest.cpp b/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/VtsHalGraphicsComposer3_ReadbackTest.cpp
index 3f1e703..45a8f6f 100644
--- a/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/VtsHalGraphicsComposer3_ReadbackTest.cpp
+++ b/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/VtsHalGraphicsComposer3_ReadbackTest.cpp
@@ -20,14 +20,12 @@
#include <aidl/Vintf.h>
#include <aidl/android/hardware/graphics/common/BufferUsage.h>
#include <aidl/android/hardware/graphics/composer3/IComposer.h>
-#include <android/binder_manager.h>
#include <composer-vts/include/ReadbackVts.h>
#include <composer-vts/include/RenderEngineVts.h>
#include <gtest/gtest.h>
#include <ui/DisplayId.h>
#include <ui/DisplayIdentification.h>
#include <ui/GraphicBuffer.h>
-#include <ui/GraphicBufferAllocator.h>
#include <ui/PixelFormat.h>
#include <ui/Rect.h>
@@ -37,6 +35,7 @@
#include <tinyxml2.h>
#pragma clang diagnostic pop
#include "composer-vts/include/GraphicsComposerCallback.h"
+#include "composer-vts/include/VtsComposerClient.h"
namespace aidl::android::hardware::graphics::composer3::vts {
namespace {
@@ -48,40 +47,25 @@
class GraphicsCompositionTestBase : public ::testing::Test {
protected:
void SetUpBase(const std::string& name) {
- ndk::SpAIBinder binder(AServiceManager_waitForService(name.c_str()));
- ASSERT_NE(binder, nullptr);
- ASSERT_NO_FATAL_FAILURE(mComposer = IComposer::fromBinder(binder));
- ASSERT_NE(mComposer, nullptr);
- ASSERT_NO_FATAL_FAILURE(mComposer->createClient(&mComposerClient));
- mComposerCallback = ::ndk::SharedRefBase::make<GraphicsComposerCallback>();
- mComposerClient->registerCallback(mComposerCallback);
+ mComposerClient = std::make_shared<VtsComposerClient>(name);
+ ASSERT_TRUE(mComposerClient->createClient().isOk());
- // assume the first display is primary and is never removed
- mPrimaryDisplay = waitForFirstDisplay();
-
- ASSERT_NO_FATAL_FAILURE(mInvalidDisplayId = GetInvalidDisplayId());
-
- int32_t activeConfig;
- EXPECT_TRUE(mComposerClient->getActiveConfig(mPrimaryDisplay, &activeConfig).isOk());
- EXPECT_TRUE(mComposerClient
- ->getDisplayAttribute(mPrimaryDisplay, activeConfig,
- DisplayAttribute::WIDTH, &mDisplayWidth)
- .isOk());
- EXPECT_TRUE(mComposerClient
- ->getDisplayAttribute(mPrimaryDisplay, activeConfig,
- DisplayAttribute::HEIGHT, &mDisplayHeight)
- .isOk());
+ const auto& [status, displays] = mComposerClient->getDisplays();
+ ASSERT_TRUE(status.isOk());
+ mDisplays = displays;
setTestColorModes();
// explicitly disable vsync
- EXPECT_TRUE(mComposerClient->setVsyncEnabled(mPrimaryDisplay, false).isOk());
- mComposerCallback->setVsyncAllowed(false);
+ for (const auto& display : mDisplays) {
+ EXPECT_TRUE(mComposerClient->setVsync(display.getDisplayId(), /*enable*/ false).isOk());
+ }
+ mComposerClient->setVsyncAllowed(/*isAllowed*/ false);
// set up gralloc
mGraphicBuffer = allocate();
- ASSERT_NO_FATAL_FAILURE(mComposerClient->setPowerMode(mPrimaryDisplay, PowerMode::ON));
+ EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
ASSERT_NO_FATAL_FAILURE(
mTestRenderEngine = std::unique_ptr<TestRenderEngine>(new TestRenderEngine(
@@ -96,11 +80,12 @@
.build())));
::android::renderengine::DisplaySettings clientCompositionDisplay;
- clientCompositionDisplay.physicalDisplay = Rect(mDisplayWidth, mDisplayHeight);
+ clientCompositionDisplay.physicalDisplay = Rect(getDisplayWidth(), getDisplayHeight());
clientCompositionDisplay.clip = clientCompositionDisplay.physicalDisplay;
mTestRenderEngine->initGraphicBuffer(
- static_cast<uint32_t>(mDisplayWidth), static_cast<uint32_t>(mDisplayHeight), 1,
+ 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) |
@@ -109,21 +94,27 @@
}
void TearDown() override {
- ASSERT_NO_FATAL_FAILURE(mComposerClient->setPowerMode(mPrimaryDisplay, PowerMode::OFF));
+ ASSERT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
+ ASSERT_TRUE(mComposerClient->tearDown());
+ mComposerClient.reset();
const auto errors = mReader.takeErrors();
ASSERT_TRUE(mReader.takeErrors().empty());
- ASSERT_TRUE(mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty());
-
- if (mComposerCallback != nullptr) {
- EXPECT_EQ(0, mComposerCallback->getInvalidHotplugCount());
- EXPECT_EQ(0, mComposerCallback->getInvalidRefreshCount());
- EXPECT_EQ(0, mComposerCallback->getInvalidVsyncCount());
- }
+ ASSERT_TRUE(mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty());
}
+ const VtsDisplay& getPrimaryDisplay() const { return mDisplays[0]; }
+
+ int64_t getPrimaryDisplayId() const { return getPrimaryDisplay().getDisplayId(); }
+
+ int64_t getInvalidDisplayId() const { return mComposerClient->getInvalidDisplayId(); }
+
+ int32_t getDisplayWidth() const { return getPrimaryDisplay().getDisplayWidth(); }
+
+ int32_t getDisplayHeight() const { return getPrimaryDisplay().getDisplayHeight(); }
+
::android::sp<::android::GraphicBuffer> allocate() {
- const auto width = static_cast<uint32_t>(mDisplayWidth);
- const auto height = static_cast<uint32_t>(mDisplayHeight);
+ const auto width = static_cast<uint32_t>(getDisplayWidth());
+ const auto height = static_cast<uint32_t>(getDisplayHeight());
const auto usage = static_cast<uint32_t>(common::BufferUsage::CPU_WRITE_OFTEN) |
static_cast<uint32_t>(common::BufferUsage::CPU_READ_OFTEN);
@@ -133,9 +124,9 @@
}
uint64_t getStableDisplayId(int64_t display) {
- DisplayIdentification identification;
- const auto error = mComposerClient->getDisplayIdentificationData(display, &identification);
- EXPECT_TRUE(error.isOk());
+ const auto& [status, identification] =
+ mComposerClient->getDisplayIdentificationData(display);
+ EXPECT_TRUE(status.isOk());
if (const auto info = ::android::parseDisplayIdentificationData(
static_cast<uint8_t>(identification.port), identification.data)) {
@@ -203,7 +194,7 @@
}
void writeLayers(const std::vector<std::shared_ptr<TestLayer>>& layers) {
- for (auto layer : layers) {
+ for (const auto& layer : layers) {
layer->write(mWriter);
}
execute();
@@ -216,59 +207,42 @@
return;
}
- std::vector<CommandResultPayload> results;
- auto status = mComposerClient->executeCommands(commands, &results);
+ auto [status, results] = mComposerClient->executeCommands(commands);
ASSERT_TRUE(status.isOk()) << "executeCommands failed " << status.getDescription();
mReader.parse(std::move(results));
mWriter.reset();
}
- bool getHasReadbackBuffer() {
- ReadbackBufferAttributes readBackBufferAttributes;
- const auto error = mComposerClient->getReadbackBufferAttributes(mPrimaryDisplay,
- &readBackBufferAttributes);
- mPixelFormat = readBackBufferAttributes.format;
- mDataspace = readBackBufferAttributes.dataspace;
- return error.isOk() && ReadbackHelper::readbackSupported(mPixelFormat, mDataspace);
+ std::pair<ScopedAStatus, bool> getHasReadbackBuffer() {
+ auto [status, readBackBufferAttributes] =
+ mComposerClient->getReadbackBufferAttributes(getPrimaryDisplayId());
+ if (status.isOk()) {
+ mPixelFormat = readBackBufferAttributes.format;
+ mDataspace = readBackBufferAttributes.dataspace;
+ return {std::move(status), ReadbackHelper::readbackSupported(mPixelFormat, mDataspace)};
+ }
+ return {std::move(status), false};
}
- std::shared_ptr<IComposer> mComposer;
- std::shared_ptr<IComposerClient> mComposerClient;
-
- std::shared_ptr<GraphicsComposerCallback> mComposerCallback;
- // the first display and is assumed never to be removed
- int64_t mPrimaryDisplay;
- int64_t mInvalidDisplayId;
- int32_t mDisplayWidth;
- int32_t mDisplayHeight;
+ std::shared_ptr<VtsComposerClient> mComposerClient;
+ std::vector<VtsDisplay> mDisplays;
+ // use the slot count usually set by SF
std::vector<ColorMode> mTestColorModes;
ComposerClientWriter mWriter;
ComposerClientReader mReader;
::android::sp<::android::GraphicBuffer> mGraphicBuffer;
std::unique_ptr<TestRenderEngine> mTestRenderEngine;
-
common::PixelFormat mPixelFormat;
common::Dataspace mDataspace;
static constexpr uint32_t kClientTargetSlotCount = 64;
private:
- int64_t waitForFirstDisplay() {
- while (true) {
- std::vector<int64_t> displays = mComposerCallback->getDisplays();
- if (displays.empty()) {
- usleep(5 * 1000);
- continue;
- }
- return displays[0];
- }
- }
-
void setTestColorModes() {
mTestColorModes.clear();
- std::vector<ColorMode> modes;
- EXPECT_TRUE(mComposerClient->getColorModes(mPrimaryDisplay, &modes).isOk());
+ const auto& [status, modes] = mComposerClient->getColorModes(getPrimaryDisplayId());
+ ASSERT_TRUE(status.isOk());
for (ColorMode mode : modes) {
if (std::find(ReadbackHelper::colorModes.begin(), ReadbackHelper::colorModes.end(),
@@ -277,27 +251,6 @@
}
}
}
-
- // returns an invalid display id (one that has not been registered to a
- // display. Currently assuming that a device will never have close to
- // std::numeric_limit<uint64_t>::max() displays registered while running tests
- int64_t GetInvalidDisplayId() {
- int64_t id = std::numeric_limits<int64_t>::max();
- std::vector<int64_t> displays = mComposerCallback->getDisplays();
- while (id > 0) {
- if (std::none_of(displays.begin(), displays.end(),
- [&](const auto& display) { return id == display; })) {
- return id;
- }
- id--;
- }
-
- // Although 0 could be an invalid display, a return value of 0
- // from GetInvalidDisplayId means all other ids are in use, a condition which
- // we are assuming a device will never have
- EXPECT_NE(0, id);
- return id;
- }
};
class GraphicsCompositionTest : public GraphicsCompositionTestBase,
@@ -308,16 +261,19 @@
TEST_P(GraphicsCompositionTest, SingleSolidColorLayer) {
for (ColorMode mode : mTestColorModes) {
- ASSERT_NO_FATAL_FAILURE(
- mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));
+ EXPECT_TRUE(mComposerClient
+ ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
+ .isOk());
- if (!getHasReadbackBuffer()) {
+ const auto& [readbackStatus, isSupported] = getHasReadbackBuffer();
+ EXPECT_TRUE(readbackStatus.isOk());
+ if (!isSupported) {
GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
return;
}
- auto layer = std::make_shared<TestColorLayer>(mComposerClient, mPrimaryDisplay);
- common::Rect coloredSquare({0, 0, mDisplayWidth, mDisplayHeight});
+ auto layer = std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId());
+ common::Rect coloredSquare({0, 0, getDisplayWidth(), getDisplayHeight()});
layer->setColor(BLUE);
layer->setDisplayFrame(coloredSquare);
layer->setZOrder(10);
@@ -325,25 +281,26 @@
std::vector<std::shared_ptr<TestLayer>> layers = {layer};
// expected color for each pixel
- std::vector<Color> expectedColors(static_cast<size_t>(mDisplayWidth * mDisplayHeight));
- ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth, coloredSquare, BLUE);
+ std::vector<Color> expectedColors(
+ static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
+ ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), coloredSquare, BLUE);
- ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mDisplayWidth,
- mDisplayHeight, mPixelFormat, mDataspace);
+ ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
+ getDisplayHeight(), mPixelFormat, mDataspace);
ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
writeLayers(layers);
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);
+ mWriter.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
execute();
// if hwc cannot handle and asks for composition change,
// just succeed the test
- if (!mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty()) {
+ if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED();
return;
}
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.presentDisplay(mPrimaryDisplay);
+ mWriter.presentDisplay(getPrimaryDisplayId());
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
@@ -356,31 +313,35 @@
TEST_P(GraphicsCompositionTest, SetLayerBuffer) {
for (ColorMode mode : mTestColorModes) {
- ASSERT_NO_FATAL_FAILURE(
- mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));
+ EXPECT_TRUE(mComposerClient
+ ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
+ .isOk());
- if (!getHasReadbackBuffer()) {
+ const auto& [readbackStatus, isSupported] = getHasReadbackBuffer();
+ EXPECT_TRUE(readbackStatus.isOk());
+ if (!isSupported) {
GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
return;
}
- ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mDisplayWidth,
- mDisplayHeight, mPixelFormat, mDataspace);
+ ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
+ getDisplayHeight(), mPixelFormat, mDataspace);
ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
- std::vector<Color> expectedColors(static_cast<size_t>(mDisplayWidth * mDisplayHeight));
- ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
- {0, 0, mDisplayWidth, mDisplayHeight / 4}, RED);
- ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
- {0, mDisplayHeight / 4, mDisplayWidth, mDisplayHeight / 2},
- GREEN);
- ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
- {0, mDisplayHeight / 2, mDisplayWidth, mDisplayHeight},
- BLUE);
+ 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, mGraphicBuffer, *mTestRenderEngine, mPrimaryDisplay, mDisplayWidth,
- mDisplayHeight, common::PixelFormat::RGBA_8888);
- layer->setDisplayFrame({0, 0, mDisplayWidth, mDisplayHeight});
+ mComposerClient, mGraphicBuffer, *mTestRenderEngine, getPrimaryDisplayId(),
+ getDisplayWidth(), getDisplayHeight(), common::PixelFormat::RGBA_8888);
+ layer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
layer->setZOrder(10);
layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);
ASSERT_NO_FATAL_FAILURE(layer->setBuffer(expectedColors));
@@ -389,16 +350,16 @@
writeLayers(layers);
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);
+ mWriter.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
execute();
- if (!mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty()) {
+ if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED();
return;
}
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.presentDisplay(mPrimaryDisplay);
+ mWriter.presentDisplay(getPrimaryDisplayId());
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
@@ -412,16 +373,19 @@
TEST_P(GraphicsCompositionTest, SetLayerBufferNoEffect) {
for (ColorMode mode : mTestColorModes) {
- ASSERT_NO_FATAL_FAILURE(
- mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));
+ EXPECT_TRUE(mComposerClient
+ ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
+ .isOk());
- if (!getHasReadbackBuffer()) {
+ const auto& [readbackStatus, isSupported] = getHasReadbackBuffer();
+ EXPECT_TRUE(readbackStatus.isOk());
+ if (!isSupported) {
GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
return;
}
- auto layer = std::make_shared<TestColorLayer>(mComposerClient, mPrimaryDisplay);
- common::Rect coloredSquare({0, 0, mDisplayWidth, mDisplayHeight});
+ auto layer = std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId());
+ common::Rect coloredSquare({0, 0, getDisplayWidth(), getDisplayHeight()});
layer->setColor(BLUE);
layer->setDisplayFrame(coloredSquare);
layer->setZOrder(10);
@@ -432,28 +396,31 @@
static_cast<uint64_t>(static_cast<uint64_t>(common::BufferUsage::CPU_READ_OFTEN) |
static_cast<uint64_t>(common::BufferUsage::CPU_WRITE_OFTEN));
- mGraphicBuffer->reallocate(static_cast<uint32_t>(mDisplayWidth),
- static_cast<uint32_t>(mDisplayHeight), 1,
+ mGraphicBuffer->reallocate(static_cast<uint32_t>(getDisplayWidth()),
+ static_cast<uint32_t>(getDisplayHeight()), 1,
static_cast<uint32_t>(common::PixelFormat::RGBA_8888), usage);
- mWriter.setLayerBuffer(mPrimaryDisplay, layer->getLayer(), 0, mGraphicBuffer->handle, -1);
+ mWriter.setLayerBuffer(getPrimaryDisplayId(), layer->getLayer(), /*slot*/ 0,
+ mGraphicBuffer->handle,
+ /*acquireFence*/ -1);
// expected color for each pixel
- std::vector<Color> expectedColors(static_cast<size_t>(mDisplayWidth * mDisplayHeight));
- ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth, coloredSquare, BLUE);
+ std::vector<Color> expectedColors(
+ static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
+ ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), coloredSquare, BLUE);
- ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mDisplayWidth,
- mDisplayHeight, mPixelFormat, mDataspace);
+ ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
+ getDisplayHeight(), mPixelFormat, mDataspace);
ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
- mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);
+ mWriter.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
execute();
- if (!mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty()) {
+ if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED();
return;
}
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.presentDisplay(mPrimaryDisplay);
+ mWriter.presentDisplay(getPrimaryDisplayId());
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
@@ -462,111 +429,118 @@
}
TEST_P(GraphicsCompositionTest, SetReadbackBuffer) {
- if (!getHasReadbackBuffer()) {
+ const auto& [readbackStatus, isSupported] = getHasReadbackBuffer();
+ EXPECT_TRUE(readbackStatus.isOk());
+ if (!isSupported) {
GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
return;
}
- ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mDisplayWidth, mDisplayHeight,
- mPixelFormat, mDataspace);
+ ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
+ getDisplayHeight(), mPixelFormat, mDataspace);
ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
}
-TEST_P(GraphicsCompositionTest, SetReadbackBufferBadDisplay) {
- if (!getHasReadbackBuffer()) {
+TEST_P(GraphicsCompositionTest, SetReadbackBuffer_BadDisplay) {
+ const auto& [readbackStatus, isSupported] = getHasReadbackBuffer();
+ EXPECT_TRUE(readbackStatus.isOk());
+ if (!isSupported) {
GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
return;
}
ASSERT_NE(nullptr, mGraphicBuffer);
ASSERT_EQ(::android::OK, mGraphicBuffer->initCheck());
- aidl::android::hardware::common::NativeHandle bufferHandle =
- ::android::dupToAidl(mGraphicBuffer->handle);
+ const auto& bufferHandle = mGraphicBuffer->handle;
::ndk::ScopedFileDescriptor fence = ::ndk::ScopedFileDescriptor(-1);
- const auto error = mComposerClient->setReadbackBuffer(mInvalidDisplayId, bufferHandle, fence);
+ const auto status =
+ mComposerClient->setReadbackBuffer(getInvalidDisplayId(), bufferHandle, fence);
- EXPECT_FALSE(error.isOk());
- ASSERT_EQ(IComposerClient::EX_BAD_DISPLAY, error.getServiceSpecificError());
+ EXPECT_FALSE(status.isOk());
+ ASSERT_EQ(IComposerClient::EX_BAD_DISPLAY, status.getServiceSpecificError());
}
-TEST_P(GraphicsCompositionTest, SetReadbackBufferBadParameter) {
- if (!getHasReadbackBuffer()) {
+TEST_P(GraphicsCompositionTest, SetReadbackBuffer_BadParameter) {
+ const auto& [readbackStatus, isSupported] = getHasReadbackBuffer();
+ EXPECT_TRUE(readbackStatus.isOk());
+ if (!isSupported) {
GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
return;
}
- aidl::android::hardware::common::NativeHandle bufferHandle;
- {
- ::android::sp<::android::GraphicBuffer> buffer = allocate();
- ASSERT_EQ(::android::OK, mGraphicBuffer->initCheck());
- ::android::makeToAidl(mGraphicBuffer->handle);
- }
-
+ const native_handle_t bufferHandle{};
ndk::ScopedFileDescriptor releaseFence = ndk::ScopedFileDescriptor(-1);
- const auto error =
- mComposerClient->setReadbackBuffer(mPrimaryDisplay, bufferHandle, releaseFence);
+ const auto status =
+ mComposerClient->setReadbackBuffer(getPrimaryDisplayId(), &bufferHandle, releaseFence);
- EXPECT_FALSE(error.isOk());
- ASSERT_EQ(IComposerClient::EX_BAD_PARAMETER, error.getServiceSpecificError());
+ EXPECT_FALSE(status.isOk());
+ ASSERT_EQ(IComposerClient::EX_BAD_PARAMETER, status.getServiceSpecificError());
}
TEST_P(GraphicsCompositionTest, GetReadbackBufferFenceInactive) {
- if (!getHasReadbackBuffer()) {
+ const auto& [readbackStatus, isSupported] = getHasReadbackBuffer();
+ EXPECT_TRUE(readbackStatus.isOk());
+ if (!isSupported) {
GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
return;
}
- ndk::ScopedFileDescriptor releaseFence;
- const auto error = mComposerClient->getReadbackBufferFence(mPrimaryDisplay, &releaseFence);
+ const auto& [status, releaseFence] =
+ mComposerClient->getReadbackBufferFence(getPrimaryDisplayId());
- ASSERT_FALSE(error.isOk());
- EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, error.getServiceSpecificError());
+ EXPECT_FALSE(status.isOk());
+ EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, status.getServiceSpecificError());
EXPECT_EQ(-1, releaseFence.get());
}
TEST_P(GraphicsCompositionTest, ClientComposition) {
- EXPECT_TRUE(mComposerClient->setClientTargetSlotCount(mPrimaryDisplay, kClientTargetSlotCount)
- .isOk());
+ EXPECT_TRUE(
+ mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kClientTargetSlotCount)
+ .isOk());
for (ColorMode mode : mTestColorModes) {
- EXPECT_TRUE(mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC)
+ EXPECT_TRUE(mComposerClient
+ ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
.isOk());
- if (!getHasReadbackBuffer()) {
+ const auto& [readbackStatus, isSupported] = getHasReadbackBuffer();
+ EXPECT_TRUE(readbackStatus.isOk());
+ if (!isSupported) {
GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
return;
}
- std::vector<Color> expectedColors(static_cast<size_t>(mDisplayWidth * mDisplayHeight));
- ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
- {0, 0, mDisplayWidth, mDisplayHeight / 4}, RED);
- ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
- {0, mDisplayHeight / 4, mDisplayWidth, mDisplayHeight / 2},
- GREEN);
- ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
- {0, mDisplayHeight / 2, mDisplayWidth, mDisplayHeight},
- BLUE);
+ 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, mGraphicBuffer, *mTestRenderEngine, mPrimaryDisplay, mDisplayWidth,
- mDisplayHeight, PixelFormat::RGBA_FP16);
- layer->setDisplayFrame({0, 0, mDisplayWidth, mDisplayHeight});
+ mComposerClient, mGraphicBuffer, *mTestRenderEngine, getPrimaryDisplayId(),
+ getDisplayWidth(), getDisplayHeight(), PixelFormat::RGBA_FP16);
+ layer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
layer->setZOrder(10);
layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);
std::vector<std::shared_ptr<TestLayer>> layers = {layer};
- ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mDisplayWidth,
- mDisplayHeight, mPixelFormat, mDataspace);
+ ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
+ getDisplayHeight(), mPixelFormat, mDataspace);
ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
writeLayers(layers);
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);
+ mWriter.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
execute();
- auto changedCompositionTypes = mReader.takeChangedCompositionTypes(mPrimaryDisplay);
+ auto changedCompositionTypes = mReader.takeChangedCompositionTypes(getPrimaryDisplayId());
if (!changedCompositionTypes.empty()) {
ASSERT_EQ(1, changedCompositionTypes.size());
ASSERT_EQ(Composition::CLIENT, changedCompositionTypes[0].composition);
@@ -577,7 +551,7 @@
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, mDisplayWidth, mDisplayHeight};
+ common::Rect damage{0, 0, getDisplayWidth(), getDisplayHeight()};
// create client target buffer
mGraphicBuffer->reallocate(layer->getWidth(), layer->getHeight(),
@@ -595,21 +569,22 @@
clientBufData, clientFormat, expectedColors));
EXPECT_EQ(::android::OK, mGraphicBuffer->unlock());
- ndk::ScopedFileDescriptor fenceHandle;
- EXPECT_TRUE(
- mComposerClient->getReadbackBufferFence(mPrimaryDisplay, &fenceHandle).isOk());
+ const auto& [status, bufferFence] =
+ mComposerClient->getReadbackBufferFence(getPrimaryDisplayId());
+ EXPECT_TRUE(status.isOk());
layer->setToClientComposition(mWriter);
- mWriter.acceptDisplayChanges(mPrimaryDisplay);
- mWriter.setClientTarget(mPrimaryDisplay, 0, mGraphicBuffer->handle, fenceHandle.get(),
- clientDataspace, std::vector<common::Rect>(1, damage));
+ mWriter.acceptDisplayChanges(getPrimaryDisplayId());
+ mWriter.setClientTarget(getPrimaryDisplayId(), /*slot*/ 0, mGraphicBuffer->handle,
+ bufferFence.get(), clientDataspace,
+ std::vector<common::Rect>(1, damage));
execute();
- changedCompositionTypes = mReader.takeChangedCompositionTypes(mPrimaryDisplay);
+ changedCompositionTypes = mReader.takeChangedCompositionTypes(getPrimaryDisplayId());
ASSERT_TRUE(changedCompositionTypes.empty());
}
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.presentDisplay(mPrimaryDisplay);
+ mWriter.presentDisplay(getPrimaryDisplayId());
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
@@ -619,31 +594,37 @@
}
TEST_P(GraphicsCompositionTest, DeviceAndClientComposition) {
- ASSERT_NO_FATAL_FAILURE(
- mComposerClient->setClientTargetSlotCount(mPrimaryDisplay, kClientTargetSlotCount));
+ ASSERT_TRUE(
+ mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kClientTargetSlotCount)
+ .isOk());
for (ColorMode mode : mTestColorModes) {
- ASSERT_NO_FATAL_FAILURE(
- mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));
+ EXPECT_TRUE(mComposerClient
+ ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
+ .isOk());
- if (!getHasReadbackBuffer()) {
+ const auto& [readbackStatus, isSupported] = getHasReadbackBuffer();
+ EXPECT_TRUE(readbackStatus.isOk());
+ if (!isSupported) {
GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
return;
}
- std::vector<Color> expectedColors(static_cast<size_t>(mDisplayWidth * mDisplayHeight));
- ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
- {0, 0, mDisplayWidth, mDisplayHeight / 2}, GREEN);
- ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
- {0, mDisplayHeight / 2, mDisplayWidth, mDisplayHeight}, RED);
+ 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(mPrimaryDisplay, mComposerClient, mDisplayWidth,
- mDisplayHeight, mPixelFormat, mDataspace);
+ ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
+ getDisplayHeight(), mPixelFormat, mDataspace);
ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
auto deviceLayer = std::make_shared<TestBufferLayer>(
- mComposerClient, mGraphicBuffer, *mTestRenderEngine, mPrimaryDisplay, mDisplayWidth,
- mDisplayHeight / 2, PixelFormat::RGBA_8888);
+ mComposerClient, mGraphicBuffer, *mTestRenderEngine, getPrimaryDisplayId(),
+ getDisplayWidth(), getDisplayHeight() / 2, PixelFormat::RGBA_8888);
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()),
@@ -662,54 +643,59 @@
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 = mDisplayWidth;
- int32_t clientHeight = mDisplayHeight / 2;
+ int32_t clientWidth = getDisplayWidth();
+ int32_t clientHeight = getDisplayHeight() / 2;
auto clientLayer = std::make_shared<TestBufferLayer>(
- mComposerClient, mGraphicBuffer, *mTestRenderEngine, mPrimaryDisplay, clientWidth,
- clientHeight, PixelFormat::RGBA_FP16, Composition::DEVICE);
- common::Rect clientFrame = {0, mDisplayHeight / 2, mDisplayWidth, mDisplayHeight};
+ mComposerClient, mGraphicBuffer, *mTestRenderEngine, getPrimaryDisplayId(),
+ clientWidth, clientHeight, PixelFormat::RGBA_FP16, Composition::DEVICE);
+ common::Rect clientFrame = {0, getDisplayHeight() / 2, getDisplayWidth(),
+ getDisplayHeight()};
clientLayer->setDisplayFrame(clientFrame);
clientLayer->setZOrder(0);
clientLayer->write(mWriter);
- mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);
+ mWriter.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
execute();
- auto changedCompositionTypes = mReader.takeChangedCompositionTypes(mPrimaryDisplay);
+ auto changedCompositionTypes = mReader.takeChangedCompositionTypes(getPrimaryDisplayId());
if (changedCompositionTypes.size() != 1) {
continue;
}
// create client target buffer
ASSERT_EQ(Composition::CLIENT, changedCompositionTypes[0].composition);
- mGraphicBuffer->reallocate(static_cast<uint32_t>(mDisplayWidth),
- static_cast<uint32_t>(mDisplayHeight),
+ mGraphicBuffer->reallocate(static_cast<uint32_t>(getDisplayWidth()),
+ static_cast<uint32_t>(getDisplayHeight()),
static_cast<int32_t>(common::PixelFormat::RGBA_8888),
clientLayer->getLayerCount(), clientUsage);
ASSERT_NE(nullptr, mGraphicBuffer->handle);
void* clientBufData;
- mGraphicBuffer->lock(clientUsage, {0, 0, mDisplayWidth, mDisplayHeight}, &clientBufData);
+ mGraphicBuffer->lock(clientUsage, {0, 0, getDisplayWidth(), getDisplayHeight()},
+ &clientBufData);
- std::vector<Color> clientColors(static_cast<size_t>(mDisplayWidth * mDisplayHeight));
- ReadbackHelper::fillColorsArea(clientColors, mDisplayWidth, clientFrame, RED);
+ 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>(mDisplayWidth), static_cast<uint32_t>(mDisplayHeight),
+ static_cast<uint32_t>(getDisplayWidth()), static_cast<uint32_t>(getDisplayHeight()),
mGraphicBuffer->getStride(), clientBufData, clientFormat, clientColors));
EXPECT_EQ(::android::OK, mGraphicBuffer->unlock());
- ndk::ScopedFileDescriptor fenceHandle;
- EXPECT_TRUE(mComposerClient->getReadbackBufferFence(mPrimaryDisplay, &fenceHandle).isOk());
+ const auto& [status, bufferFence] =
+ mComposerClient->getReadbackBufferFence(getPrimaryDisplayId());
+ EXPECT_TRUE(status.isOk());
clientLayer->setToClientComposition(mWriter);
- mWriter.acceptDisplayChanges(mPrimaryDisplay);
- mWriter.setClientTarget(mPrimaryDisplay, 0, mGraphicBuffer->handle, fenceHandle.get(),
- clientDataspace, std::vector<common::Rect>(1, clientFrame));
+ mWriter.acceptDisplayChanges(getPrimaryDisplayId());
+ mWriter.setClientTarget(getPrimaryDisplayId(), /*slot*/ 0, mGraphicBuffer->handle,
+ bufferFence.get(), clientDataspace,
+ std::vector<common::Rect>(1, clientFrame));
execute();
- changedCompositionTypes = mReader.takeChangedCompositionTypes(mPrimaryDisplay);
+ changedCompositionTypes = mReader.takeChangedCompositionTypes(getPrimaryDisplayId());
ASSERT_TRUE(changedCompositionTypes.empty());
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.presentDisplay(mPrimaryDisplay);
+ mWriter.presentDisplay(getPrimaryDisplayId());
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
@@ -718,66 +704,72 @@
TEST_P(GraphicsCompositionTest, SetLayerDamage) {
for (ColorMode mode : mTestColorModes) {
- ASSERT_NO_FATAL_FAILURE(
- mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));
+ EXPECT_TRUE(mComposerClient
+ ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
+ .isOk());
- if (!getHasReadbackBuffer()) {
+ const auto& [readbackStatus, isSupported] = getHasReadbackBuffer();
+ EXPECT_TRUE(readbackStatus.isOk());
+ if (!isSupported) {
GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
return;
}
- common::Rect redRect = {0, 0, mDisplayWidth / 4, mDisplayHeight / 4};
+ common::Rect redRect = {0, 0, getDisplayWidth() / 4, getDisplayHeight() / 4};
- std::vector<Color> expectedColors(static_cast<size_t>(mDisplayWidth * mDisplayHeight));
- ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth, redRect, RED);
+ std::vector<Color> expectedColors(
+ static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
+ ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), redRect, RED);
auto layer = std::make_shared<TestBufferLayer>(
- mComposerClient, mGraphicBuffer, *mTestRenderEngine, mPrimaryDisplay, mDisplayWidth,
- mDisplayHeight, PixelFormat::RGBA_8888);
- layer->setDisplayFrame({0, 0, mDisplayWidth, mDisplayHeight});
+ mComposerClient, mGraphicBuffer, *mTestRenderEngine, getPrimaryDisplayId(),
+ getDisplayWidth(), getDisplayHeight(), PixelFormat::RGBA_8888);
+ layer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
layer->setZOrder(10);
layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);
ASSERT_NO_FATAL_FAILURE(layer->setBuffer(expectedColors));
std::vector<std::shared_ptr<TestLayer>> layers = {layer};
- ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mDisplayWidth,
- mDisplayHeight, mPixelFormat, mDataspace);
+ ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
+ getDisplayHeight(), mPixelFormat, mDataspace);
ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
writeLayers(layers);
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);
+ mWriter.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
execute();
- if (!mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty()) {
+ if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED();
return;
}
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.presentDisplay(mPrimaryDisplay);
+ mWriter.presentDisplay(getPrimaryDisplayId());
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
// update surface damage and recheck
- redRect = {mDisplayWidth / 4, mDisplayHeight / 4, mDisplayWidth / 2, mDisplayHeight / 2};
- ReadbackHelper::clearColors(expectedColors, mDisplayWidth, mDisplayHeight, mDisplayWidth);
- ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth, redRect, RED);
+ 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, mDisplayWidth / 2, mDisplayWidth / 2}));
+ 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(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);
+ mWriter.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
- ASSERT_TRUE(mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty());
- mWriter.presentDisplay(mPrimaryDisplay);
+ ASSERT_TRUE(mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty());
+ mWriter.presentDisplay(getPrimaryDisplayId());
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
@@ -787,43 +779,47 @@
TEST_P(GraphicsCompositionTest, SetLayerPlaneAlpha) {
for (ColorMode mode : mTestColorModes) {
- ASSERT_NO_FATAL_FAILURE(
- mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));
+ EXPECT_TRUE(mComposerClient
+ ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
+ .isOk());
- if (!getHasReadbackBuffer()) {
+ const auto& [readbackStatus, isSupported] = getHasReadbackBuffer();
+ EXPECT_TRUE(readbackStatus.isOk());
+ if (!isSupported) {
GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
return;
}
- auto layer = std::make_shared<TestColorLayer>(mComposerClient, mPrimaryDisplay);
+ auto layer = std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId());
layer->setColor(RED);
- layer->setDisplayFrame({0, 0, mDisplayWidth, mDisplayHeight});
+ 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(mPrimaryDisplay, mComposerClient, mDisplayWidth,
- mDisplayHeight, mPixelFormat, mDataspace);
+ ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
+ getDisplayHeight(), mPixelFormat, mDataspace);
ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
writeLayers(layers);
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);
+ mWriter.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
execute();
- if (!mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty()) {
+ if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED();
return;
}
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.presentDisplay(mPrimaryDisplay);
+ mWriter.presentDisplay(getPrimaryDisplayId());
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
- std::vector<Color> expectedColors(static_cast<size_t>(mDisplayWidth * mDisplayHeight));
+ std::vector<Color> expectedColors(
+ static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
mTestRenderEngine->setRenderLayers(layers);
@@ -834,50 +830,54 @@
TEST_P(GraphicsCompositionTest, SetLayerSourceCrop) {
for (ColorMode mode : mTestColorModes) {
- ASSERT_NO_FATAL_FAILURE(
- mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));
+ EXPECT_TRUE(mComposerClient
+ ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
+ .isOk());
- if (!getHasReadbackBuffer()) {
+ const auto& [readbackStatus, isSupported] = getHasReadbackBuffer();
+ EXPECT_TRUE(readbackStatus.isOk());
+ if (!isSupported) {
GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
return;
}
- std::vector<Color> expectedColors(static_cast<size_t>(mDisplayWidth * mDisplayHeight));
- ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
- {0, 0, mDisplayWidth, mDisplayHeight / 4}, RED);
- ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
- {0, mDisplayHeight / 2, mDisplayWidth, mDisplayHeight},
- BLUE);
+ 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, mGraphicBuffer, *mTestRenderEngine, mPrimaryDisplay, mDisplayWidth,
- mDisplayHeight, PixelFormat::RGBA_8888);
- layer->setDisplayFrame({0, 0, mDisplayWidth, mDisplayHeight});
+ mComposerClient, mGraphicBuffer, *mTestRenderEngine, getPrimaryDisplayId(),
+ getDisplayWidth(), getDisplayHeight(), PixelFormat::RGBA_8888);
+ layer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
layer->setZOrder(10);
layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);
- layer->setSourceCrop({0, static_cast<float>(mDisplayHeight / 2),
- static_cast<float>(mDisplayWidth),
- static_cast<float>(mDisplayHeight)});
+ 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, mDisplayWidth,
- {0, 0, mDisplayWidth, mDisplayHeight}, BLUE);
- ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mDisplayWidth,
- mDisplayHeight, mPixelFormat, mDataspace);
+ 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(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);
+ mWriter.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
execute();
- if (!mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty()) {
+ if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED();
return;
}
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.presentDisplay(mPrimaryDisplay);
+ mWriter.presentDisplay(getPrimaryDisplayId());
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
@@ -889,67 +889,72 @@
TEST_P(GraphicsCompositionTest, SetLayerZOrder) {
for (ColorMode mode : mTestColorModes) {
- ASSERT_NO_FATAL_FAILURE(
- mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));
+ EXPECT_TRUE(mComposerClient
+ ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
+ .isOk());
- if (!getHasReadbackBuffer()) {
+ const auto& [readbackStatus, isSupported] = getHasReadbackBuffer();
+ EXPECT_TRUE(readbackStatus.isOk());
+ if (!isSupported) {
GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
return;
}
- common::Rect redRect = {0, 0, mDisplayWidth, mDisplayHeight / 2};
- common::Rect blueRect = {0, mDisplayHeight / 4, mDisplayWidth, mDisplayHeight};
- auto redLayer = std::make_shared<TestColorLayer>(mComposerClient, mPrimaryDisplay);
+ common::Rect redRect = {0, 0, getDisplayWidth(), getDisplayHeight() / 2};
+ common::Rect blueRect = {0, getDisplayHeight() / 4, getDisplayWidth(), getDisplayHeight()};
+ auto redLayer = std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId());
redLayer->setColor(RED);
redLayer->setDisplayFrame(redRect);
- auto blueLayer = std::make_shared<TestColorLayer>(mComposerClient, mPrimaryDisplay);
+ auto blueLayer = std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId());
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>(mDisplayWidth * mDisplayHeight));
+ 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, mDisplayWidth, blueRect, BLUE);
- ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth, redRect, RED);
+ ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), blueRect, BLUE);
+ ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), redRect, RED);
- ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mDisplayWidth,
- mDisplayHeight, mPixelFormat, mDataspace);
+ ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
+ getDisplayHeight(), mPixelFormat, mDataspace);
ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
writeLayers(layers);
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);
+ mWriter.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
execute();
- if (!mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty()) {
+ if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED();
return;
}
- mWriter.presentDisplay(mPrimaryDisplay);
+ mWriter.presentDisplay(getPrimaryDisplayId());
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
redLayer->setZOrder(1);
- ReadbackHelper::clearColors(expectedColors, mDisplayWidth, mDisplayHeight, mDisplayWidth);
- ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth, redRect, RED);
- ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth, blueRect, BLUE);
+ 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(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);
+ mWriter.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
execute();
- ASSERT_TRUE(mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty());
+ ASSERT_TRUE(mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty());
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.presentDisplay(mPrimaryDisplay);
+ mWriter.presentDisplay(getPrimaryDisplayId());
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
@@ -961,9 +966,9 @@
}
TEST_P(GraphicsCompositionTest, SetLayerWhitePointDims) {
- std::vector<DisplayCapability> capabilities;
- const auto error = mComposerClient->getDisplayCapabilities(mPrimaryDisplay, &capabilities);
- ASSERT_TRUE(error.isOk());
+ const auto& [status, capabilities] =
+ mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
+ ASSERT_TRUE(status.isOk());
const bool brightnessSupport = std::find(capabilities.begin(), capabilities.end(),
DisplayCapability::BRIGHTNESS) != capabilities.end();
@@ -974,7 +979,7 @@
}
const std::optional<float> maxBrightnessNitsOptional =
- getMaxDisplayBrightnessNits(mPrimaryDisplay);
+ getMaxDisplayBrightnessNits(getPrimaryDisplayId());
ASSERT_TRUE(maxBrightnessNitsOptional.has_value());
@@ -983,29 +988,34 @@
// Preconditions to successfully run are knowing the max brightness and successfully applying
// the max brightness
ASSERT_GT(maxBrightnessNits, 0.f);
- mWriter.setDisplayBrightness(mPrimaryDisplay, 1.f);
+ mWriter.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 1.f);
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
for (ColorMode mode : mTestColorModes) {
- ASSERT_NO_FATAL_FAILURE(
- mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));
+ EXPECT_TRUE(mComposerClient
+ ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
+ .isOk());
- if (!getHasReadbackBuffer()) {
+ const auto& [readbackStatus, isSupported] = getHasReadbackBuffer();
+ EXPECT_TRUE(readbackStatus.isOk());
+ if (!isSupported) {
GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace for "
"color mode: "
<< toString(mode);
continue;
}
- const common::Rect redRect = {0, 0, mDisplayWidth, mDisplayHeight / 2};
- const common::Rect dimmerRedRect = {0, mDisplayHeight / 2, mDisplayWidth, mDisplayHeight};
- const auto redLayer = std::make_shared<TestColorLayer>(mComposerClient, mPrimaryDisplay);
+ const common::Rect redRect = {0, 0, getDisplayWidth(), getDisplayHeight() / 2};
+ const common::Rect dimmerRedRect = {0, getDisplayHeight() / 2, getDisplayWidth(),
+ getDisplayHeight()};
+ const auto redLayer =
+ std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId());
redLayer->setColor(RED);
redLayer->setDisplayFrame(redRect);
redLayer->setWhitePointNits(maxBrightnessNits);
const auto dimmerRedLayer =
- std::make_shared<TestColorLayer>(mComposerClient, mPrimaryDisplay);
+ std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId());
dimmerRedLayer->setColor(RED);
dimmerRedLayer->setDisplayFrame(dimmerRedRect);
// Intentionally use a small dimming ratio as some implementations may be more likely to
@@ -1014,26 +1024,27 @@
dimmerRedLayer->setWhitePointNits(maxBrightnessNits * kDimmingRatio);
const std::vector<std::shared_ptr<TestLayer>> layers = {redLayer, dimmerRedLayer};
- std::vector<Color> expectedColors(static_cast<size_t>(mDisplayWidth * mDisplayHeight));
+ std::vector<Color> expectedColors(
+ static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
- ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth, redRect, RED);
- ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth, dimmerRedRect, DIM_RED);
+ ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), redRect, RED);
+ ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), dimmerRedRect, DIM_RED);
- ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mDisplayWidth,
- mDisplayHeight, mPixelFormat, mDataspace);
+ ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
+ getDisplayHeight(), mPixelFormat, mDataspace);
ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
writeLayers(layers);
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);
+ mWriter.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
execute();
- if (!mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty()) {
+ if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED()
<< "Readback verification not supported for GPU composition for color mode: "
<< toString(mode);
continue;
}
- mWriter.presentDisplay(mPrimaryDisplay);
+ mWriter.presentDisplay(getPrimaryDisplayId());
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
@@ -1060,19 +1071,22 @@
void setUpLayers(BlendMode blendMode) {
mLayers.clear();
- std::vector<Color> topLayerPixelColors(static_cast<size_t>(mDisplayWidth * mDisplayHeight));
- ReadbackHelper::fillColorsArea(topLayerPixelColors, mDisplayWidth,
- {0, 0, mDisplayWidth, mDisplayHeight}, mTopLayerColor);
+ std::vector<Color> topLayerPixelColors(
+ static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
+ ReadbackHelper::fillColorsArea(topLayerPixelColors, getDisplayWidth(),
+ {0, 0, getDisplayWidth(), getDisplayHeight()},
+ mTopLayerColor);
- auto backgroundLayer = std::make_shared<TestColorLayer>(mComposerClient, mPrimaryDisplay);
- backgroundLayer->setDisplayFrame({0, 0, mDisplayWidth, mDisplayHeight});
+ auto backgroundLayer =
+ std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId());
+ backgroundLayer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
backgroundLayer->setZOrder(0);
backgroundLayer->setColor(mBackgroundColor);
auto layer = std::make_shared<TestBufferLayer>(
- mComposerClient, mGraphicBuffer, *mTestRenderEngine, mPrimaryDisplay, mDisplayWidth,
- mDisplayHeight, PixelFormat::RGBA_8888);
- layer->setDisplayFrame({0, 0, mDisplayWidth, mDisplayHeight});
+ mComposerClient, mGraphicBuffer, *mTestRenderEngine, getPrimaryDisplayId(),
+ getDisplayWidth(), getDisplayHeight(), PixelFormat::RGBA_8888);
+ layer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
layer->setZOrder(10);
layer->setDataspace(Dataspace::UNKNOWN, mWriter);
ASSERT_NO_FATAL_FAILURE(layer->setBuffer(topLayerPixelColors));
@@ -1086,7 +1100,8 @@
void setExpectedColors(std::vector<Color>& expectedColors) {
ASSERT_EQ(2, mLayers.size());
- ReadbackHelper::clearColors(expectedColors, mDisplayWidth, mDisplayHeight, mDisplayWidth);
+ ReadbackHelper::clearColors(expectedColors, getDisplayWidth(), getDisplayHeight(),
+ getDisplayWidth());
auto layer = mLayers[1];
BlendMode blendMode = layer->getBlendMode();
@@ -1126,34 +1141,38 @@
TEST_P(GraphicsBlendModeCompositionTest, None) {
for (ColorMode mode : mTestColorModes) {
- ASSERT_NO_FATAL_FAILURE(
- mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));
+ EXPECT_TRUE(mComposerClient
+ ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
+ .isOk());
- if (!getHasReadbackBuffer()) {
+ const auto& [readbackStatus, isSupported] = getHasReadbackBuffer();
+ EXPECT_TRUE(readbackStatus.isOk());
+ if (!isSupported) {
GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
return;
}
- std::vector<Color> expectedColors(static_cast<size_t>(mDisplayWidth * mDisplayHeight));
+ std::vector<Color> expectedColors(
+ static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
setBackgroundColor(BLACK);
setTopLayerColor(TRANSLUCENT_RED);
setUpLayers(BlendMode::NONE);
setExpectedColors(expectedColors);
- ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mDisplayWidth,
- mDisplayHeight, mPixelFormat, mDataspace);
+ ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
+ getDisplayHeight(), mPixelFormat, mDataspace);
ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
writeLayers(mLayers);
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);
+ mWriter.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
execute();
- if (!mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty()) {
+ if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED();
return;
}
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.presentDisplay(mPrimaryDisplay);
+ mWriter.presentDisplay(getPrimaryDisplayId());
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
@@ -1166,15 +1185,19 @@
TEST_P(GraphicsBlendModeCompositionTest, Coverage) {
for (ColorMode mode : mTestColorModes) {
- ASSERT_NO_FATAL_FAILURE(
- mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));
+ EXPECT_TRUE(mComposerClient
+ ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
+ .isOk());
- if (!getHasReadbackBuffer()) {
+ const auto& [readbackStatus, isSupported] = getHasReadbackBuffer();
+ EXPECT_TRUE(readbackStatus.isOk());
+ if (!isSupported) {
GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
return;
}
- std::vector<Color> expectedColors(static_cast<size_t>(mDisplayWidth * mDisplayHeight));
+ std::vector<Color> expectedColors(
+ static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
setBackgroundColor(BLACK);
setTopLayerColor(TRANSLUCENT_RED);
@@ -1182,19 +1205,19 @@
setUpLayers(BlendMode::COVERAGE);
setExpectedColors(expectedColors);
- ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mDisplayWidth,
- mDisplayHeight, mPixelFormat, mDataspace);
+ ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
+ getDisplayHeight(), mPixelFormat, mDataspace);
ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
writeLayers(mLayers);
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);
+ mWriter.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
execute();
- if (!mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty()) {
+ if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED();
return;
}
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.presentDisplay(mPrimaryDisplay);
+ mWriter.presentDisplay(getPrimaryDisplayId());
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
@@ -1203,34 +1226,38 @@
TEST_P(GraphicsBlendModeCompositionTest, Premultiplied) {
for (ColorMode mode : mTestColorModes) {
- ASSERT_NO_FATAL_FAILURE(
- mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));
+ EXPECT_TRUE(mComposerClient
+ ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
+ .isOk());
- if (!getHasReadbackBuffer()) {
+ const auto& [readbackStatus, isSupported] = getHasReadbackBuffer();
+ EXPECT_TRUE(readbackStatus.isOk());
+ if (!isSupported) {
GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
return;
}
- std::vector<Color> expectedColors(static_cast<size_t>(mDisplayWidth * mDisplayHeight));
+ std::vector<Color> expectedColors(
+ static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
setBackgroundColor(BLACK);
setTopLayerColor(TRANSLUCENT_RED);
setUpLayers(BlendMode::PREMULTIPLIED);
setExpectedColors(expectedColors);
- ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mDisplayWidth,
- mDisplayHeight, mPixelFormat, mDataspace);
+ ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
+ getDisplayHeight(), mPixelFormat, mDataspace);
ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
writeLayers(mLayers);
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);
+ mWriter.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
execute();
- if (!mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty()) {
+ if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED();
return;
}
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.presentDisplay(mPrimaryDisplay);
+ mWriter.presentDisplay(getPrimaryDisplayId());
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
@@ -1245,18 +1272,20 @@
void SetUp() override {
GraphicsCompositionTest::SetUp();
- auto backgroundLayer = std::make_shared<TestColorLayer>(mComposerClient, mPrimaryDisplay);
+ auto backgroundLayer =
+ std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId());
backgroundLayer->setColor({0.0f, 0.0f, 0.0f, 0.0f});
- backgroundLayer->setDisplayFrame({0, 0, mDisplayWidth, mDisplayHeight});
+ backgroundLayer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
backgroundLayer->setZOrder(0);
- mSideLength = mDisplayWidth < mDisplayHeight ? mDisplayWidth : mDisplayHeight;
+ mSideLength =
+ getDisplayWidth() < getDisplayHeight() ? getDisplayWidth() : getDisplayHeight();
common::Rect redRect = {0, 0, mSideLength / 2, mSideLength / 2};
common::Rect blueRect = {mSideLength / 2, mSideLength / 2, mSideLength, mSideLength};
- mLayer = std::make_shared<TestBufferLayer>(mComposerClient, mGraphicBuffer,
- *mTestRenderEngine, mPrimaryDisplay, mSideLength,
- mSideLength, PixelFormat::RGBA_8888);
+ mLayer = std::make_shared<TestBufferLayer>(
+ mComposerClient, mGraphicBuffer, *mTestRenderEngine, getPrimaryDisplayId(),
+ mSideLength, mSideLength, PixelFormat::RGBA_8888);
mLayer->setDisplayFrame({0, 0, mSideLength, mSideLength});
mLayer->setZOrder(10);
@@ -1275,41 +1304,44 @@
TEST_P(GraphicsTransformCompositionTest, FLIP_H) {
for (ColorMode mode : mTestColorModes) {
- auto error =
- mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC);
- if (!error.isOk() &&
- (error.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED ||
- error.getServiceSpecificError() == IComposerClient::EX_BAD_PARAMETER)) {
+ auto status = mComposerClient->setColorMode(getPrimaryDisplayId(), mode,
+ RenderIntent::COLORIMETRIC);
+ if (!status.isOk() &&
+ (status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED ||
+ status.getServiceSpecificError() == IComposerClient::EX_BAD_PARAMETER)) {
SUCCEED() << "ColorMode not supported, skip test";
return;
}
- if (!getHasReadbackBuffer()) {
+ const auto& [readbackStatus, isSupported] = getHasReadbackBuffer();
+ EXPECT_TRUE(readbackStatus.isOk());
+ if (!isSupported) {
GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
return;
}
- ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mDisplayWidth,
- mDisplayHeight, mPixelFormat, mDataspace);
+ ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
+ getDisplayHeight(), mPixelFormat, mDataspace);
ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
mLayer->setTransform(Transform::FLIP_H);
mLayer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);
- std::vector<Color> expectedColors(static_cast<size_t>(mDisplayWidth * mDisplayHeight));
- ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
+ std::vector<Color> expectedColors(
+ static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
+ ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(),
{mSideLength / 2, 0, mSideLength, mSideLength / 2}, RED);
- ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
+ ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(),
{0, mSideLength / 2, mSideLength / 2, mSideLength}, BLUE);
writeLayers(mLayers);
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);
+ mWriter.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
execute();
- if (!mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty()) {
+ if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED();
return;
}
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.presentDisplay(mPrimaryDisplay);
+ mWriter.presentDisplay(getPrimaryDisplayId());
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
@@ -1322,36 +1354,40 @@
TEST_P(GraphicsTransformCompositionTest, FLIP_V) {
for (ColorMode mode : mTestColorModes) {
- ASSERT_NO_FATAL_FAILURE(
- mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));
+ EXPECT_TRUE(mComposerClient
+ ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
+ .isOk());
- if (!getHasReadbackBuffer()) {
+ const auto& [readbackStatus, isSupported] = getHasReadbackBuffer();
+ EXPECT_TRUE(readbackStatus.isOk());
+ if (!isSupported) {
GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
return;
}
- ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mDisplayWidth,
- mDisplayHeight, mPixelFormat, mDataspace);
+ ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
+ getDisplayHeight(), mPixelFormat, mDataspace);
ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
mLayer->setTransform(Transform::FLIP_V);
mLayer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);
- std::vector<Color> expectedColors(static_cast<size_t>(mDisplayWidth * mDisplayHeight));
- ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
+ std::vector<Color> expectedColors(
+ static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
+ ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(),
{0, mSideLength / 2, mSideLength / 2, mSideLength}, RED);
- ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
+ ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(),
{mSideLength / 2, 0, mSideLength, mSideLength / 2}, BLUE);
writeLayers(mLayers);
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);
+ mWriter.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
execute();
- if (!mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty()) {
+ if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED();
return;
}
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.presentDisplay(mPrimaryDisplay);
+ mWriter.presentDisplay(getPrimaryDisplayId());
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
@@ -1363,37 +1399,41 @@
TEST_P(GraphicsTransformCompositionTest, ROT_180) {
for (ColorMode mode : mTestColorModes) {
- ASSERT_NO_FATAL_FAILURE(
- mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));
+ EXPECT_TRUE(mComposerClient
+ ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
+ .isOk());
- if (!getHasReadbackBuffer()) {
+ const auto& [readbackStatus, isSupported] = getHasReadbackBuffer();
+ EXPECT_TRUE(readbackStatus.isOk());
+ if (!isSupported) {
GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
return;
}
- ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mDisplayWidth,
- mDisplayHeight, mPixelFormat, mDataspace);
+ ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
+ getDisplayHeight(), mPixelFormat, mDataspace);
ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
mLayer->setTransform(Transform::ROT_180);
mLayer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);
- std::vector<Color> expectedColors(static_cast<size_t>(mDisplayWidth * mDisplayHeight));
- ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
+ std::vector<Color> expectedColors(
+ static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
+ ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(),
{mSideLength / 2, mSideLength / 2, mSideLength, mSideLength},
RED);
- ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
+ ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(),
{0, 0, mSideLength / 2, mSideLength / 2}, BLUE);
writeLayers(mLayers);
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);
+ mWriter.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
execute();
- if (!mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty()) {
+ if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED();
return;
}
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.presentDisplay(mPrimaryDisplay);
+ mWriter.presentDisplay(getPrimaryDisplayId());
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
diff --git a/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/VtsHalGraphicsComposer3_TargetTest.cpp b/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/VtsHalGraphicsComposer3_TargetTest.cpp
index 026a431..404b548 100644
--- a/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/VtsHalGraphicsComposer3_TargetTest.cpp
+++ b/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/VtsHalGraphicsComposer3_TargetTest.cpp
@@ -1,7 +1,18 @@
-// TODO(b/129481165): remove the #pragma below and fix conversion issues
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wconversion"
-
+/**
+ * Copyright (c) 2022, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
#include <aidl/Gtest.h>
#include <aidl/Vintf.h>
#include <aidl/android/hardware/graphics/common/BlendMode.h>
@@ -11,7 +22,6 @@
#include <aidl/android/hardware/graphics/composer3/Composition.h>
#include <aidl/android/hardware/graphics/composer3/IComposer.h>
#include <android-base/properties.h>
-#include <android/binder_manager.h>
#include <android/binder_process.h>
#include <android/hardware/graphics/composer3/ComposerClientReader.h>
#include <android/hardware/graphics/composer3/ComposerClientWriter.h>
@@ -22,16 +32,10 @@
#include <ui/PixelFormat.h>
#include <algorithm>
#include <numeric>
-#include <regex>
#include <string>
#include <thread>
-#include <unordered_map>
-#include <unordered_set>
-#include <utility>
#include "composer-vts/include/GraphicsComposerCallback.h"
-
-// TODO(b/129481165): remove the #pragma below and fix conversion issues
-#pragma clang diagnostic pop // ignored "-Wconversion
+#include "composer-vts/include/VtsComposerClient.h"
#undef LOG_TAG
#define LOG_TAG "VtsHalGraphicsComposer3_TargetTest"
@@ -44,90 +48,39 @@
using ::android::GraphicBuffer;
using ::android::sp;
-class VtsDisplay {
- public:
- VtsDisplay(int64_t displayId, int32_t displayWidth, int32_t displayHeight)
- : mDisplayId(displayId), mDisplayWidth(displayWidth), mDisplayHeight(displayHeight) {}
-
- int64_t get() const { return mDisplayId; }
-
- FRect getCrop() const {
- return {0, 0, static_cast<float>(mDisplayWidth), static_cast<float>(mDisplayHeight)};
- }
-
- Rect getFrameRect() const { return {0, 0, mDisplayWidth, mDisplayHeight}; }
-
- void setDimensions(int32_t displayWidth, int32_t displayHeight) {
- mDisplayWidth = displayWidth;
- mDisplayHeight = displayHeight;
- }
-
- private:
- const int64_t mDisplayId;
- int32_t mDisplayWidth;
- int32_t mDisplayHeight;
-};
-
class GraphicsComposerAidlTest : public ::testing::TestWithParam<std::string> {
protected:
void SetUp() override {
- std::string name = GetParam();
- ndk::SpAIBinder binder(AServiceManager_waitForService(name.c_str()));
- ASSERT_NE(binder, nullptr);
- ASSERT_NO_FATAL_FAILURE(mComposer = IComposer::fromBinder(binder));
- ASSERT_NE(mComposer, nullptr);
+ mComposerClient = std::make_unique<VtsComposerClient>(GetParam());
+ ASSERT_TRUE(mComposerClient->createClient().isOk());
- ndk::ScopedAStatus status;
- ASSERT_NO_FATAL_FAILURE(status = mComposer->createClient(&mComposerClient));
+ const auto& [status, displays] = mComposerClient->getDisplays();
ASSERT_TRUE(status.isOk());
-
- mComposerCallback = ::ndk::SharedRefBase::make<GraphicsComposerCallback>();
- EXPECT_TRUE(mComposerClient->registerCallback(mComposerCallback).isOk());
-
- // assume the first displays are built-in and are never removed
- mDisplays = waitForDisplays();
- mPrimaryDisplay = mDisplays[0].get();
- ASSERT_NO_FATAL_FAILURE(mInvalidDisplayId = GetInvalidDisplayId());
-
- int32_t activeConfig;
- EXPECT_TRUE(mComposerClient->getActiveConfig(mPrimaryDisplay, &activeConfig).isOk());
- EXPECT_TRUE(mComposerClient
- ->getDisplayAttribute(mPrimaryDisplay, activeConfig,
- DisplayAttribute::WIDTH, &mDisplayWidth)
- .isOk());
- EXPECT_TRUE(mComposerClient
- ->getDisplayAttribute(mPrimaryDisplay, activeConfig,
- DisplayAttribute::HEIGHT, &mDisplayHeight)
- .isOk());
+ mDisplays = displays;
// explicitly disable vsync
for (const auto& display : mDisplays) {
- EXPECT_TRUE(mComposerClient->setVsyncEnabled(display.get(), false).isOk());
+ EXPECT_TRUE(mComposerClient->setVsync(display.getDisplayId(), false).isOk());
}
- mComposerCallback->setVsyncAllowed(false);
+ mComposerClient->setVsyncAllowed(false);
}
void TearDown() override {
- destroyAllLayers();
- if (mComposerCallback != nullptr) {
- EXPECT_EQ(0, mComposerCallback->getInvalidHotplugCount());
- EXPECT_EQ(0, mComposerCallback->getInvalidRefreshCount());
- EXPECT_EQ(0, mComposerCallback->getInvalidVsyncCount());
- EXPECT_EQ(0, mComposerCallback->getInvalidVsyncPeriodChangeCount());
- EXPECT_EQ(0, mComposerCallback->getInvalidSeamlessPossibleCount());
- }
+ ASSERT_TRUE(mComposerClient->tearDown());
+ mComposerClient.reset();
}
- void Test_setContentTypeForDisplay(const int64_t& display,
- const std::vector<ContentType>& capabilities,
- const ContentType& contentType, const char* contentTypeStr) {
- const bool contentTypeSupport = std::find(capabilities.begin(), capabilities.end(),
- contentType) != capabilities.end();
+ void Test_setContentTypeForDisplay(int64_t display,
+ const std::vector<ContentType>& supportedContentTypes,
+ ContentType contentType, const char* contentTypeStr) {
+ const bool contentTypeSupport =
+ std::find(supportedContentTypes.begin(), supportedContentTypes.end(),
+ contentType) != supportedContentTypes.end();
if (!contentTypeSupport) {
- EXPECT_EQ(IComposerClient::EX_UNSUPPORTED,
- mComposerClient->setContentType(display, contentType)
- .getServiceSpecificError());
+ const auto& status = mComposerClient->setContentType(display, contentType);
+ EXPECT_FALSE(status.isOk());
+ EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, status.getServiceSpecificError());
GTEST_SUCCEED() << contentTypeStr << " content type is not supported on display "
<< std::to_string(display) << ", skipping test";
return;
@@ -137,209 +90,79 @@
EXPECT_TRUE(mComposerClient->setContentType(display, ContentType::NONE).isOk());
}
- void Test_setContentType(const ContentType& contentType, const char* contentTypeStr) {
+ void Test_setContentType(ContentType contentType, const char* contentTypeStr) {
for (const auto& display : mDisplays) {
- std::vector<ContentType> supportedContentTypes;
- const auto error = mComposerClient->getSupportedContentTypes(display.get(),
- &supportedContentTypes);
- EXPECT_TRUE(error.isOk());
-
- Test_setContentTypeForDisplay(display.get(), supportedContentTypes, contentType,
- contentTypeStr);
+ const auto& [status, supportedContentTypes] =
+ mComposerClient->getSupportedContentTypes(display.getDisplayId());
+ EXPECT_TRUE(status.isOk());
+ Test_setContentTypeForDisplay(display.getDisplayId(), supportedContentTypes,
+ contentType, contentTypeStr);
}
}
- int64_t createLayer(const VtsDisplay& display) {
- int64_t layer;
- EXPECT_TRUE(mComposerClient->createLayer(display.get(), kBufferSlotCount, &layer).isOk());
-
- auto resourceIt = mDisplayResources.find(display.get());
- if (resourceIt == mDisplayResources.end()) {
- resourceIt = mDisplayResources.insert({display.get(), DisplayResource(false)}).first;
- }
-
- EXPECT_TRUE(resourceIt->second.layers.insert(layer).second)
- << "duplicated layer id " << layer;
-
- return layer;
- }
-
- void destroyAllLayers() {
- for (const auto& it : mDisplayResources) {
- auto display = it.first;
- const DisplayResource& resource = it.second;
-
- for (auto layer : resource.layers) {
- const auto error = mComposerClient->destroyLayer(display, layer);
- EXPECT_TRUE(error.isOk());
- }
-
- if (resource.isVirtual) {
- const auto error = mComposerClient->destroyVirtualDisplay(display);
- EXPECT_TRUE(error.isOk());
- }
- }
- mDisplayResources.clear();
- }
-
- void destroyLayer(const VtsDisplay& display, int64_t layer) {
- auto const error = mComposerClient->destroyLayer(display.get(), layer);
- ASSERT_TRUE(error.isOk()) << "failed to destroy layer " << layer;
-
- auto resourceIt = mDisplayResources.find(display.get());
- ASSERT_NE(mDisplayResources.end(), resourceIt);
- resourceIt->second.layers.erase(layer);
- }
-
bool hasCapability(Capability capability) {
- std::vector<Capability> capabilities;
- EXPECT_TRUE(mComposer->getCapabilities(&capabilities).isOk());
+ const auto& [status, capabilities] = mComposerClient->getCapabilities();
+ EXPECT_TRUE(status.isOk());
return std::any_of(
capabilities.begin(), capabilities.end(),
[&](const Capability& activeCapability) { return activeCapability == capability; });
}
- // returns an invalid display id (one that has not been registered to a
- // display. Currently assuming that a device will never have close to
- // std::numeric_limit<uint64_t>::max() displays registered while running tests
- int64_t GetInvalidDisplayId() {
- int64_t id = std::numeric_limits<int64_t>::max();
- while (id > 0) {
- if (std::none_of(mDisplays.begin(), mDisplays.end(),
- [&](const VtsDisplay& display) { return id == display.get(); })) {
- return id;
- }
- id--;
- }
+ const VtsDisplay& getPrimaryDisplay() const { return mDisplays[0]; }
- // Although 0 could be an invalid display, a return value of 0
- // from GetInvalidDisplayId means all other ids are in use, a condition which
- // we are assuming a device will never have
- EXPECT_NE(0, id);
- return id;
- }
+ int64_t getPrimaryDisplayId() const { return getPrimaryDisplay().getDisplayId(); }
- std::vector<VtsDisplay> waitForDisplays() {
- while (true) {
- // Sleep for a small period of time to allow all built-in displays
- // to post hotplug events
- std::this_thread::sleep_for(5ms);
- std::vector<int64_t> displays = mComposerCallback->getDisplays();
- if (displays.empty()) {
- continue;
- }
+ int64_t getInvalidDisplayId() const { return mComposerClient->getInvalidDisplayId(); }
- std::vector<VtsDisplay> vtsDisplays;
- vtsDisplays.reserve(displays.size());
- for (int64_t display : displays) {
- int32_t activeConfig;
- EXPECT_TRUE(mComposerClient->getActiveConfig(display, &activeConfig).isOk());
- int32_t displayWidth;
- EXPECT_TRUE(mComposerClient
- ->getDisplayAttribute(display, activeConfig,
- DisplayAttribute::WIDTH, &displayWidth)
- .isOk());
- int32_t displayHeight;
- EXPECT_TRUE(mComposerClient
- ->getDisplayAttribute(display, activeConfig,
- DisplayAttribute::HEIGHT, &displayHeight)
- .isOk());
- vtsDisplays.emplace_back(VtsDisplay{display, displayWidth, displayHeight});
- }
-
- return vtsDisplays;
- }
- }
-
- // returns an invalid config id which is std::numeric_limit<int32_t>::max()
- int32_t GetInvalidConfigId() { return IComposerClient::INVALID_CONFIGURATION; }
-
- ndk::ScopedAStatus setActiveConfigWithConstraints(
- VtsDisplay& display, int32_t config, const VsyncPeriodChangeConstraints& constraints,
- VsyncPeriodChangeTimeline* timeline) {
- auto error = mComposerClient->setActiveConfigWithConstraints(display.get(), config,
- constraints, timeline);
- if (error.isOk()) {
- int32_t displayWidth;
- EXPECT_TRUE(mComposerClient
- ->getDisplayAttribute(display.get(), config,
- DisplayAttribute::WIDTH, &displayWidth)
- .isOk());
- int32_t displayHeight;
- EXPECT_TRUE(mComposerClient
- ->getDisplayAttribute(display.get(), config,
- DisplayAttribute::HEIGHT, &displayHeight)
- .isOk());
- display.setDimensions(displayWidth, displayHeight);
- }
- return error;
- }
+ VtsDisplay& getEditablePrimaryDisplay() { return mDisplays[0]; }
struct TestParameters {
nsecs_t delayForChange;
bool refreshMiss;
};
- // Keep track of all virtual displays and layers. When a test fails with
- // ASSERT_*, the destructor will clean up the resources for the test.
- struct DisplayResource {
- DisplayResource(bool isVirtual_) : isVirtual(isVirtual_) {}
-
- bool isVirtual;
- std::unordered_set<int64_t> layers;
- };
-
- std::shared_ptr<IComposer> mComposer;
- std::shared_ptr<IComposerClient> mComposerClient;
- int64_t mInvalidDisplayId;
- int64_t mPrimaryDisplay;
+ std::unique_ptr<VtsComposerClient> mComposerClient;
std::vector<VtsDisplay> mDisplays;
- std::shared_ptr<GraphicsComposerCallback> mComposerCallback;
// use the slot count usually set by SF
static constexpr uint32_t kBufferSlotCount = 64;
- std::unordered_map<int64_t, DisplayResource> mDisplayResources;
- int32_t mDisplayWidth;
- int32_t mDisplayHeight;
};
-TEST_P(GraphicsComposerAidlTest, getDisplayCapabilitiesBadDisplay) {
- std::vector<DisplayCapability> capabilities;
- const auto error = mComposerClient->getDisplayCapabilities(mInvalidDisplayId, &capabilities);
+TEST_P(GraphicsComposerAidlTest, GetDisplayCapabilities_BadDisplay) {
+ const auto& [status, _] = mComposerClient->getDisplayCapabilities(getInvalidDisplayId());
- EXPECT_FALSE(error.isOk());
- EXPECT_EQ(IComposerClient::EX_BAD_DISPLAY, error.getServiceSpecificError());
+ EXPECT_FALSE(status.isOk());
+ EXPECT_EQ(IComposerClient::EX_BAD_DISPLAY, status.getServiceSpecificError());
}
-TEST_P(GraphicsComposerAidlTest, getDisplayCapabilities) {
+TEST_P(GraphicsComposerAidlTest, GetDisplayCapabilities) {
for (const auto& display : mDisplays) {
- std::vector<DisplayCapability> capabilities;
+ const auto& [status, capabilities] =
+ mComposerClient->getDisplayCapabilities(display.getDisplayId());
- EXPECT_TRUE(mComposerClient->getDisplayCapabilities(display.get(), &capabilities).isOk());
+ EXPECT_TRUE(status.isOk());
}
}
TEST_P(GraphicsComposerAidlTest, DumpDebugInfo) {
- std::string debugInfo;
- EXPECT_TRUE(mComposer->dumpDebugInfo(&debugInfo).isOk());
+ ASSERT_TRUE(mComposerClient->dumpDebugInfo().isOk());
}
TEST_P(GraphicsComposerAidlTest, CreateClientSingleton) {
std::shared_ptr<IComposerClient> composerClient;
- const auto error = mComposer->createClient(&composerClient);
+ const auto& status = mComposerClient->createClient();
- EXPECT_FALSE(error.isOk());
- EXPECT_EQ(IComposerClient::EX_NO_RESOURCES, error.getServiceSpecificError());
+ EXPECT_FALSE(status.isOk());
+ EXPECT_EQ(IComposerClient::EX_NO_RESOURCES, status.getServiceSpecificError());
}
TEST_P(GraphicsComposerAidlTest, GetDisplayIdentificationData) {
- DisplayIdentification displayIdentification0;
-
- const auto error =
- mComposerClient->getDisplayIdentificationData(mPrimaryDisplay, &displayIdentification0);
- if (error.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
+ const auto& [status0, displayIdentification0] =
+ mComposerClient->getDisplayIdentificationData(getPrimaryDisplayId());
+ if (!status0.isOk() && status0.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
+ GTEST_SUCCEED() << "Display identification data not supported, skipping test";
return;
}
- ASSERT_TRUE(error.isOk()) << "failed to get display identification data";
+ ASSERT_TRUE(status0.isOk()) << "failed to get display identification data";
ASSERT_FALSE(displayIdentification0.data.empty());
constexpr size_t kEdidBlockSize = 128;
@@ -355,10 +178,9 @@
static_cast<uint8_t>(0)))
<< "EDID base block doesn't checksum";
- DisplayIdentification displayIdentification1;
- ASSERT_TRUE(
- mComposerClient->getDisplayIdentificationData(mPrimaryDisplay, &displayIdentification1)
- .isOk());
+ const auto& [status1, displayIdentification1] =
+ mComposerClient->getDisplayIdentificationData(getPrimaryDisplayId());
+ ASSERT_TRUE(status1.isOk());
ASSERT_EQ(displayIdentification0.port, displayIdentification1.port) << "ports are not stable";
ASSERT_TRUE(displayIdentification0.data.size() == displayIdentification1.data.size() &&
@@ -368,42 +190,42 @@
}
TEST_P(GraphicsComposerAidlTest, GetHdrCapabilities) {
- HdrCapabilities hdrCapabilities;
- const auto error = mComposerClient->getHdrCapabilities(mPrimaryDisplay, &hdrCapabilities);
+ const auto& [status, hdrCapabilities] =
+ mComposerClient->getHdrCapabilities(getPrimaryDisplayId());
- ASSERT_TRUE(error.isOk());
- ASSERT_TRUE(hdrCapabilities.maxLuminance >= hdrCapabilities.minLuminance);
+ ASSERT_TRUE(status.isOk());
+ EXPECT_TRUE(hdrCapabilities.maxLuminance >= hdrCapabilities.minLuminance);
}
TEST_P(GraphicsComposerAidlTest, GetPerFrameMetadataKeys) {
- std::vector<PerFrameMetadataKey> keys;
- const auto error = mComposerClient->getPerFrameMetadataKeys(mPrimaryDisplay, &keys);
-
- if (error.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
+ const auto& [status, keys] = mComposerClient->getPerFrameMetadataKeys(getPrimaryDisplayId());
+ if (!status.isOk() && status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
GTEST_SUCCEED() << "getPerFrameMetadataKeys is not supported";
return;
}
- EXPECT_TRUE(error.isOk());
- ASSERT_TRUE(keys.size() >= 0);
+
+ ASSERT_TRUE(status.isOk());
+ EXPECT_TRUE(keys.size() >= 0);
}
TEST_P(GraphicsComposerAidlTest, GetReadbackBufferAttributes) {
- ReadbackBufferAttributes readBackBufferAttributes;
- const auto error = mComposerClient->getReadbackBufferAttributes(mPrimaryDisplay,
- &readBackBufferAttributes);
-
- if (error.isOk()) {
- EXPECT_EQ(EX_NONE, error.getServiceSpecificError());
+ const auto& [status, _] = mComposerClient->getReadbackBufferAttributes(getPrimaryDisplayId());
+ if (!status.isOk() && status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
+ GTEST_SUCCEED() << "getReadbackBufferAttributes is not supported";
+ return;
}
+
+ ASSERT_TRUE(status.isOk());
}
TEST_P(GraphicsComposerAidlTest, GetRenderIntents) {
- std::vector<ColorMode> modes;
- EXPECT_TRUE(mComposerClient->getColorModes(mPrimaryDisplay, &modes).isOk());
- for (auto mode : modes) {
- std::vector<RenderIntent> intents;
- EXPECT_TRUE(mComposerClient->getRenderIntents(mPrimaryDisplay, mode, &intents).isOk());
+ const auto& [status, modes] = mComposerClient->getColorModes(getPrimaryDisplayId());
+ EXPECT_TRUE(status.isOk());
+ for (auto mode : modes) {
+ const auto& [intentStatus, intents] =
+ mComposerClient->getRenderIntents(getPrimaryDisplayId(), mode);
+ EXPECT_TRUE(intentStatus.isOk());
bool isHdr;
switch (mode) {
case ColorMode::BT2100_PQ:
@@ -417,158 +239,157 @@
RenderIntent requiredIntent =
isHdr ? RenderIntent::TONE_MAP_COLORIMETRIC : RenderIntent::COLORIMETRIC;
- auto iter = std::find(intents.cbegin(), intents.cend(), requiredIntent);
+ const auto iter = std::find(intents.cbegin(), intents.cend(), requiredIntent);
EXPECT_NE(intents.cend(), iter);
}
}
-TEST_P(GraphicsComposerAidlTest, GetRenderIntentsBadDisplay) {
- std::vector<ColorMode> modes;
- EXPECT_TRUE(mComposerClient->getColorModes(mPrimaryDisplay, &modes).isOk());
+TEST_P(GraphicsComposerAidlTest, GetRenderIntents_BadDisplay) {
+ const auto& [status, modes] = mComposerClient->getColorModes(getPrimaryDisplayId());
+ ASSERT_TRUE(status.isOk());
+
for (auto mode : modes) {
- std::vector<RenderIntent> renderIntents;
- const auto error =
- mComposerClient->getRenderIntents(mInvalidDisplayId, mode, &renderIntents);
- EXPECT_FALSE(error.isOk());
- EXPECT_EQ(IComposerClient::EX_BAD_DISPLAY, error.getServiceSpecificError());
+ const auto& [intentStatus, _] =
+ mComposerClient->getRenderIntents(getInvalidDisplayId(), mode);
+
+ EXPECT_FALSE(intentStatus.isOk());
+ EXPECT_EQ(IComposerClient::EX_BAD_DISPLAY, intentStatus.getServiceSpecificError());
}
}
-TEST_P(GraphicsComposerAidlTest, GetRenderIntentsBadParameter) {
- std::vector<RenderIntent> renderIntents;
- const auto error = mComposerClient->getRenderIntents(
- mPrimaryDisplay, static_cast<ColorMode>(-1), &renderIntents);
- EXPECT_FALSE(error.isOk());
- EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, error.getServiceSpecificError());
+TEST_P(GraphicsComposerAidlTest, GetRenderIntents_BadParameter) {
+ const auto& [status, _] =
+ mComposerClient->getRenderIntents(getPrimaryDisplayId(), static_cast<ColorMode>(-1));
+
+ EXPECT_FALSE(status.isOk());
+ EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, status.getServiceSpecificError());
}
TEST_P(GraphicsComposerAidlTest, GetColorModes) {
- std::vector<ColorMode> colorModes;
- EXPECT_TRUE(mComposerClient->getColorModes(mPrimaryDisplay, &colorModes).isOk());
+ const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
+ ASSERT_TRUE(status.isOk());
- auto native = std::find(colorModes.cbegin(), colorModes.cend(), ColorMode::NATIVE);
- ASSERT_NE(colorModes.cend(), native);
+ const auto native = std::find(colorModes.cbegin(), colorModes.cend(), ColorMode::NATIVE);
+ EXPECT_NE(colorModes.cend(), native);
}
-TEST_P(GraphicsComposerAidlTest, GetColorModeBadDisplay) {
- std::vector<ColorMode> colorModes;
- const auto error = mComposerClient->getColorModes(mInvalidDisplayId, &colorModes);
+TEST_P(GraphicsComposerAidlTest, GetColorMode_BadDisplay) {
+ const auto& [status, _] = mComposerClient->getColorModes(getInvalidDisplayId());
- EXPECT_FALSE(error.isOk());
- EXPECT_EQ(IComposerClient::EX_BAD_DISPLAY, error.getServiceSpecificError());
+ EXPECT_FALSE(status.isOk());
+ EXPECT_EQ(IComposerClient::EX_BAD_DISPLAY, status.getServiceSpecificError());
}
TEST_P(GraphicsComposerAidlTest, SetColorMode) {
- std::vector<ColorMode> colorModes;
- EXPECT_TRUE(mComposerClient->getColorModes(mPrimaryDisplay, &colorModes).isOk());
+ const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
+ EXPECT_TRUE(status.isOk());
+
for (auto mode : colorModes) {
- std::vector<RenderIntent> intents;
- EXPECT_TRUE(mComposerClient->getRenderIntents(mPrimaryDisplay, mode, &intents).isOk())
- << "failed to get render intents";
+ const auto& [intentStatus, intents] =
+ mComposerClient->getRenderIntents(getPrimaryDisplayId(), mode);
+ EXPECT_TRUE(intentStatus.isOk()) << "failed to get render intents";
+
for (auto intent : intents) {
- const auto error = mComposerClient->setColorMode(mPrimaryDisplay, mode, intent);
- EXPECT_TRUE(error.isOk() ||
- IComposerClient::EX_UNSUPPORTED == error.getServiceSpecificError())
+ const auto modeStatus =
+ mComposerClient->setColorMode(getPrimaryDisplayId(), mode, intent);
+ EXPECT_TRUE(modeStatus.isOk() ||
+ IComposerClient::EX_UNSUPPORTED == modeStatus.getServiceSpecificError())
<< "failed to set color mode";
}
}
- const auto error = mComposerClient->setColorMode(mPrimaryDisplay, ColorMode::NATIVE,
- RenderIntent::COLORIMETRIC);
- EXPECT_TRUE(error.isOk() || IComposerClient::EX_UNSUPPORTED == error.getServiceSpecificError())
+ const auto modeStatus = mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE,
+ RenderIntent::COLORIMETRIC);
+ EXPECT_TRUE(modeStatus.isOk() ||
+ IComposerClient::EX_UNSUPPORTED == modeStatus.getServiceSpecificError())
<< "failed to set color mode";
}
-TEST_P(GraphicsComposerAidlTest, SetColorModeBadDisplay) {
- std::vector<ColorMode> colorModes;
- EXPECT_TRUE(mComposerClient->getColorModes(mPrimaryDisplay, &colorModes).isOk());
- for (auto mode : colorModes) {
- std::vector<RenderIntent> intents;
- EXPECT_TRUE(mComposerClient->getRenderIntents(mPrimaryDisplay, mode, &intents).isOk())
- << "failed to get render intents";
- for (auto intent : intents) {
- auto const error = mComposerClient->setColorMode(mInvalidDisplayId, mode, intent);
+TEST_P(GraphicsComposerAidlTest, SetColorMode_BadDisplay) {
+ const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
+ ASSERT_TRUE(status.isOk());
- EXPECT_FALSE(error.isOk());
- ASSERT_EQ(IComposerClient::EX_BAD_DISPLAY, error.getServiceSpecificError());
+ for (auto mode : colorModes) {
+ const auto& [intentStatus, intents] =
+ mComposerClient->getRenderIntents(getPrimaryDisplayId(), mode);
+ ASSERT_TRUE(intentStatus.isOk()) << "failed to get render intents";
+
+ for (auto intent : intents) {
+ auto const modeStatus =
+ mComposerClient->setColorMode(getInvalidDisplayId(), mode, intent);
+
+ EXPECT_FALSE(modeStatus.isOk());
+ EXPECT_EQ(IComposerClient::EX_BAD_DISPLAY, modeStatus.getServiceSpecificError());
}
}
}
-TEST_P(GraphicsComposerAidlTest, SetColorModeBadParameter) {
- const auto colorModeError = mComposerClient->setColorMode(
- mPrimaryDisplay, static_cast<ColorMode>(-1), RenderIntent::COLORIMETRIC);
+TEST_P(GraphicsComposerAidlTest, SetColorMode_BadParameter) {
+ auto status = mComposerClient->setColorMode(getPrimaryDisplayId(), static_cast<ColorMode>(-1),
+ RenderIntent::COLORIMETRIC);
- EXPECT_FALSE(colorModeError.isOk());
- EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, colorModeError.getServiceSpecificError());
+ EXPECT_FALSE(status.isOk());
+ EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, status.getServiceSpecificError());
- const auto renderIntentError = mComposerClient->setColorMode(mPrimaryDisplay, ColorMode::NATIVE,
- static_cast<RenderIntent>(-1));
+ status = mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE,
+ static_cast<RenderIntent>(-1));
- EXPECT_FALSE(renderIntentError.isOk());
- EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, renderIntentError.getServiceSpecificError());
+ EXPECT_FALSE(status.isOk());
+ EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, status.getServiceSpecificError());
}
TEST_P(GraphicsComposerAidlTest, GetDisplayedContentSamplingAttributes) {
- int constexpr invalid = -1;
+ int constexpr kInvalid = -1;
+ const auto& [status, format] =
+ mComposerClient->getDisplayedContentSamplingAttributes(getPrimaryDisplayId());
- DisplayContentSamplingAttributes format;
- auto error = mComposerClient->getDisplayedContentSamplingAttributes(mPrimaryDisplay, &format);
-
- if (error.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
+ if (!status.isOk() && status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
SUCCEED() << "Device does not support optional extension. Test skipped";
return;
}
- EXPECT_TRUE(error.isOk());
- EXPECT_NE(format.format, static_cast<common::PixelFormat>(invalid));
- EXPECT_NE(format.dataspace, static_cast<common::Dataspace>(invalid));
- EXPECT_NE(format.componentMask, static_cast<FormatColorComponent>(invalid));
+ ASSERT_TRUE(status.isOk());
+ EXPECT_NE(kInvalid, static_cast<int>(format.format));
+ EXPECT_NE(kInvalid, static_cast<int>(format.dataspace));
+ EXPECT_NE(kInvalid, static_cast<int>(format.componentMask));
};
TEST_P(GraphicsComposerAidlTest, SetDisplayedContentSamplingEnabled) {
- auto const maxFrames = 10;
+ int constexpr kMaxFrames = 10;
FormatColorComponent enableAllComponents = FormatColorComponent::FORMAT_COMPONENT_0;
- auto error = mComposerClient->setDisplayedContentSamplingEnabled(
- mPrimaryDisplay, true, enableAllComponents, maxFrames);
- if (error.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
+ auto status = mComposerClient->setDisplayedContentSamplingEnabled(
+ getPrimaryDisplayId(), /*isEnabled*/ true, enableAllComponents, kMaxFrames);
+ if (!status.isOk() && status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
SUCCEED() << "Device does not support optional extension. Test skipped";
return;
}
- EXPECT_TRUE(error.isOk());
+ EXPECT_TRUE(status.isOk());
- error = mComposerClient->setDisplayedContentSamplingEnabled(mPrimaryDisplay, false,
- enableAllComponents, maxFrames);
- EXPECT_TRUE(error.isOk());
+ status = mComposerClient->setDisplayedContentSamplingEnabled(
+ getPrimaryDisplayId(), /*isEnabled*/ false, enableAllComponents, kMaxFrames);
+ EXPECT_TRUE(status.isOk());
}
TEST_P(GraphicsComposerAidlTest, GetDisplayedContentSample) {
- DisplayContentSamplingAttributes displayContentSamplingAttributes;
- int constexpr invalid = -1;
- displayContentSamplingAttributes.format = static_cast<common::PixelFormat>(invalid);
- displayContentSamplingAttributes.dataspace = static_cast<common::Dataspace>(invalid);
- displayContentSamplingAttributes.componentMask = static_cast<FormatColorComponent>(invalid);
- auto error = mComposerClient->getDisplayedContentSamplingAttributes(
- mPrimaryDisplay, &displayContentSamplingAttributes);
- if (error.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
+ const auto& [status, displayContentSamplingAttributes] =
+ mComposerClient->getDisplayedContentSamplingAttributes(getPrimaryDisplayId());
+ if (!status.isOk() && status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
SUCCEED() << "Sampling attributes aren't supported on this device, test skipped";
return;
}
- int64_t maxFrames = 10;
- int64_t timestamp = 0;
- int64_t frameCount = 0;
- DisplayContentSample displayContentSample;
- error = mComposerClient->getDisplayedContentSample(mPrimaryDisplay, maxFrames, timestamp,
- &displayContentSample);
- if (error.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
+ int64_t constexpr kMaxFrames = 10;
+ int64_t constexpr kTimestamp = 0;
+ const auto& [sampleStatus, displayContentSample] = mComposerClient->getDisplayedContentSample(
+ getPrimaryDisplayId(), kMaxFrames, kTimestamp);
+ if (!sampleStatus.isOk() &&
+ sampleStatus.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
SUCCEED() << "Device does not support optional extension. Test skipped";
return;
}
- EXPECT_TRUE(error.isOk());
- EXPECT_LE(frameCount, maxFrames);
- std::vector<std::vector<int64_t>> histogram = {
+ EXPECT_TRUE(sampleStatus.isOk());
+ const std::vector<std::vector<int64_t>> histogram = {
displayContentSample.sampleComponent0, displayContentSample.sampleComponent1,
displayContentSample.sampleComponent2, displayContentSample.sampleComponent3};
@@ -579,18 +400,24 @@
}
}
-TEST_P(GraphicsComposerAidlTest, getDisplayConnectionType) {
- DisplayConnectionType type;
- EXPECT_FALSE(mComposerClient->getDisplayConnectionType(mInvalidDisplayId, &type).isOk());
+TEST_P(GraphicsComposerAidlTest, GetDisplayConnectionType) {
+ const auto& [status, type] = mComposerClient->getDisplayConnectionType(getInvalidDisplayId());
+
+ EXPECT_FALSE(status.isOk());
+ EXPECT_EQ(IComposerClient::EX_BAD_DISPLAY, status.getServiceSpecificError());
+
for (const auto& display : mDisplays) {
- EXPECT_TRUE(mComposerClient->getDisplayConnectionType(display.get(), &type).isOk());
+ const auto& [connectionTypeStatus, _] =
+ mComposerClient->getDisplayConnectionType(display.getDisplayId());
+ EXPECT_TRUE(connectionTypeStatus.isOk());
}
}
-TEST_P(GraphicsComposerAidlTest, getDisplayAttribute) {
+TEST_P(GraphicsComposerAidlTest, GetDisplayAttribute) {
for (const auto& display : mDisplays) {
- std::vector<int32_t> configs;
- EXPECT_TRUE(mComposerClient->getDisplayConfigs(display.get(), &configs).isOk());
+ const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
+ EXPECT_TRUE(status.isOk());
+
for (const auto& config : configs) {
const std::array<DisplayAttribute, 4> requiredAttributes = {{
DisplayAttribute::WIDTH,
@@ -598,11 +425,10 @@
DisplayAttribute::VSYNC_PERIOD,
DisplayAttribute::CONFIG_GROUP,
}};
- int32_t value;
for (const auto& attribute : requiredAttributes) {
- EXPECT_TRUE(mComposerClient
- ->getDisplayAttribute(display.get(), config, attribute, &value)
- .isOk());
+ const auto& [attribStatus, value] = mComposerClient->getDisplayAttribute(
+ display.getDisplayId(), config, attribute);
+ EXPECT_TRUE(attribStatus.isOk());
EXPECT_NE(-1, value);
}
@@ -611,22 +437,19 @@
DisplayAttribute::DPI_Y,
}};
for (const auto& attribute : optionalAttributes) {
- const auto error = mComposerClient->getDisplayAttribute(display.get(), config,
- attribute, &value);
- if (error.isOk()) {
- EXPECT_EQ(EX_NONE, error.getServiceSpecificError());
- } else {
- EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, error.getServiceSpecificError());
- }
+ const auto& [attribStatus, value] = mComposerClient->getDisplayAttribute(
+ display.getDisplayId(), config, attribute);
+ EXPECT_TRUE(attribStatus.isOk() || IComposerClient::EX_UNSUPPORTED ==
+ attribStatus.getServiceSpecificError());
}
}
}
}
-TEST_P(GraphicsComposerAidlTest, checkConfigsAreValid) {
+TEST_P(GraphicsComposerAidlTest, CheckConfigsAreValid) {
for (const auto& display : mDisplays) {
- std::vector<int32_t> configs;
- EXPECT_TRUE(mComposerClient->getDisplayConfigs(display.get(), &configs).isOk());
+ const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
+ EXPECT_TRUE(status.isOk());
EXPECT_FALSE(std::any_of(configs.begin(), configs.end(), [](auto config) {
return config == IComposerClient::INVALID_CONFIGURATION;
@@ -634,349 +457,287 @@
}
}
-TEST_P(GraphicsComposerAidlTest, getDisplayAttributeConfigsInAGroupDifferOnlyByVsyncPeriod) {
- struct Resolution {
- int32_t width;
- int32_t height;
- };
- struct Dpi {
- int32_t x;
- int32_t y;
- };
- for (const auto& display : mDisplays) {
- std::vector<int32_t> configs;
- EXPECT_TRUE(mComposerClient->getDisplayConfigs(display.get(), &configs).isOk());
- std::unordered_map<int32_t, Resolution> configGroupToResolutionMap;
- std::unordered_map<int32_t, Dpi> configGroupToDpiMap;
- for (const auto& config : configs) {
- int32_t configGroup = -1;
- EXPECT_TRUE(mComposerClient
- ->getDisplayAttribute(display.get(), config,
- DisplayAttribute::CONFIG_GROUP, &configGroup)
- .isOk());
- int32_t width = -1;
- EXPECT_TRUE(mComposerClient
- ->getDisplayAttribute(display.get(), config,
- DisplayAttribute::WIDTH, &width)
- .isOk());
- int32_t height = -1;
- EXPECT_TRUE(mComposerClient
- ->getDisplayAttribute(display.get(), config,
- DisplayAttribute::HEIGHT, &height)
- .isOk());
- if (configGroupToResolutionMap.find(configGroup) == configGroupToResolutionMap.end()) {
- configGroupToResolutionMap[configGroup] = {width, height};
- }
- EXPECT_EQ(configGroupToResolutionMap[configGroup].width, width);
- EXPECT_EQ(configGroupToResolutionMap[configGroup].height, height);
+TEST_P(GraphicsComposerAidlTest, GetDisplayVsyncPeriod_BadDisplay) {
+ const auto& [status, vsyncPeriodNanos] =
+ mComposerClient->getDisplayVsyncPeriod(getInvalidDisplayId());
- int32_t dpiX = -1;
- mComposerClient->getDisplayAttribute(display.get(), config, DisplayAttribute::DPI_X,
- &dpiX);
-
- int32_t dpiY = -1;
- mComposerClient->getDisplayAttribute(display.get(), config, DisplayAttribute::DPI_Y,
- &dpiY);
- if (dpiX == -1 && dpiY == -1) {
- continue;
- }
-
- if (configGroupToDpiMap.find(configGroup) == configGroupToDpiMap.end()) {
- configGroupToDpiMap[configGroup] = {dpiX, dpiY};
- }
- EXPECT_EQ(configGroupToDpiMap[configGroup].x, dpiX);
- EXPECT_EQ(configGroupToDpiMap[configGroup].y, dpiY);
- }
- }
+ EXPECT_FALSE(status.isOk());
+ EXPECT_EQ(IComposerClient::EX_BAD_DISPLAY, status.getServiceSpecificError());
}
-TEST_P(GraphicsComposerAidlTest, getDisplayVsyncPeriod_BadDisplay) {
- int32_t vsyncPeriodNanos;
- const auto error = mComposerClient->getDisplayVsyncPeriod(mInvalidDisplayId, &vsyncPeriodNanos);
- EXPECT_FALSE(error.isOk());
- EXPECT_EQ(IComposerClient::EX_BAD_DISPLAY, error.getServiceSpecificError());
-}
-
-TEST_P(GraphicsComposerAidlTest, setActiveConfigWithConstraints_BadDisplay) {
- VsyncPeriodChangeTimeline timeline;
+TEST_P(GraphicsComposerAidlTest, SetActiveConfigWithConstraints_BadDisplay) {
VsyncPeriodChangeConstraints constraints;
-
constraints.seamlessRequired = false;
constraints.desiredTimeNanos = systemTime();
- int32_t config = 0;
- auto const error = mComposerClient->setActiveConfigWithConstraints(mInvalidDisplayId, config,
- constraints, &timeline);
+ auto invalidDisplay = VtsDisplay(getInvalidDisplayId());
- EXPECT_FALSE(error.isOk());
- EXPECT_EQ(IComposerClient::EX_BAD_DISPLAY, error.getServiceSpecificError());
+ const auto& [status, timeline] = mComposerClient->setActiveConfigWithConstraints(
+ &invalidDisplay, /*config*/ 0, constraints);
+
+ EXPECT_FALSE(status.isOk());
+ EXPECT_EQ(IComposerClient::EX_BAD_DISPLAY, status.getServiceSpecificError());
}
-TEST_P(GraphicsComposerAidlTest, setActiveConfigWithConstraints_BadConfig) {
- VsyncPeriodChangeTimeline timeline;
+TEST_P(GraphicsComposerAidlTest, SetActiveConfigWithConstraints_BadConfig) {
VsyncPeriodChangeConstraints constraints;
-
constraints.seamlessRequired = false;
constraints.desiredTimeNanos = systemTime();
for (VtsDisplay& display : mDisplays) {
- int32_t invalidConfigId = GetInvalidConfigId();
- const auto error =
- setActiveConfigWithConstraints(display, invalidConfigId, constraints, &timeline);
- EXPECT_FALSE(error.isOk());
- EXPECT_EQ(IComposerClient::EX_BAD_CONFIG, error.getServiceSpecificError());
+ int32_t constexpr kInvalidConfigId = IComposerClient::INVALID_CONFIGURATION;
+ const auto& [status, _] = mComposerClient->setActiveConfigWithConstraints(
+ &display, kInvalidConfigId, constraints);
+
+ EXPECT_FALSE(status.isOk());
+ EXPECT_EQ(IComposerClient::EX_BAD_CONFIG, status.getServiceSpecificError());
}
}
-TEST_P(GraphicsComposerAidlTest, setBootDisplayConfig_BadDisplay) {
- int32_t config = 0;
- auto const error = mComposerClient->setBootDisplayConfig(mInvalidDisplayId, config);
+TEST_P(GraphicsComposerAidlTest, SetBootDisplayConfig_BadDisplay) {
+ const auto& status = mComposerClient->setBootDisplayConfig(getInvalidDisplayId(), /*config*/ 0);
- EXPECT_FALSE(error.isOk());
- EXPECT_EQ(IComposerClient::EX_BAD_DISPLAY, error.getServiceSpecificError());
+ EXPECT_FALSE(status.isOk());
+ EXPECT_EQ(IComposerClient::EX_BAD_DISPLAY, status.getServiceSpecificError());
}
-TEST_P(GraphicsComposerAidlTest, setBootDisplayConfig_BadConfig) {
+TEST_P(GraphicsComposerAidlTest, SetBootDisplayConfig_BadConfig) {
for (VtsDisplay& display : mDisplays) {
- int32_t invalidConfigId = GetInvalidConfigId();
- const auto error = mComposerClient->setBootDisplayConfig(display.get(), invalidConfigId);
- EXPECT_FALSE(error.isOk());
- EXPECT_EQ(IComposerClient::EX_BAD_CONFIG, error.getServiceSpecificError());
+ int32_t constexpr kInvalidConfigId = IComposerClient::INVALID_CONFIGURATION;
+ const auto& status =
+ mComposerClient->setBootDisplayConfig(display.getDisplayId(), kInvalidConfigId);
+
+ EXPECT_FALSE(status.isOk());
+ EXPECT_EQ(IComposerClient::EX_BAD_CONFIG, status.getServiceSpecificError());
}
}
-TEST_P(GraphicsComposerAidlTest, setBootDisplayConfig) {
- std::vector<int32_t> configs;
- EXPECT_TRUE(mComposerClient->getDisplayConfigs(mPrimaryDisplay, &configs).isOk());
- for (auto config : configs) {
- EXPECT_TRUE(mComposerClient->setBootDisplayConfig(mPrimaryDisplay, config).isOk());
+TEST_P(GraphicsComposerAidlTest, SetBootDisplayConfig) {
+ const auto& [status, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
+ EXPECT_TRUE(status.isOk());
+ for (const auto& config : configs) {
+ EXPECT_TRUE(mComposerClient->setBootDisplayConfig(getPrimaryDisplayId(), config).isOk());
}
}
-TEST_P(GraphicsComposerAidlTest, clearBootDisplayConfig_BadDisplay) {
- auto const error = mComposerClient->clearBootDisplayConfig(mInvalidDisplayId);
+TEST_P(GraphicsComposerAidlTest, ClearBootDisplayConfig_BadDisplay) {
+ const auto& status = mComposerClient->clearBootDisplayConfig(getInvalidDisplayId());
- EXPECT_FALSE(error.isOk());
- EXPECT_EQ(IComposerClient::EX_BAD_DISPLAY, error.getServiceSpecificError());
+ EXPECT_FALSE(status.isOk());
+ EXPECT_EQ(IComposerClient::EX_BAD_DISPLAY, status.getServiceSpecificError());
}
-TEST_P(GraphicsComposerAidlTest, clearBootDisplayConfig) {
- EXPECT_TRUE(mComposerClient->clearBootDisplayConfig(mPrimaryDisplay).isOk());
+TEST_P(GraphicsComposerAidlTest, ClearBootDisplayConfig) {
+ EXPECT_TRUE(mComposerClient->clearBootDisplayConfig(getPrimaryDisplayId()).isOk());
}
-TEST_P(GraphicsComposerAidlTest, getPreferredBootDisplayConfig_BadDisplay) {
- int32_t config;
- auto const error = mComposerClient->getPreferredBootDisplayConfig(mInvalidDisplayId, &config);
+TEST_P(GraphicsComposerAidlTest, GetPreferredBootDisplayConfig_BadDisplay) {
+ const auto& [status, _] = mComposerClient->getPreferredBootDisplayConfig(getInvalidDisplayId());
- EXPECT_FALSE(error.isOk());
- EXPECT_EQ(IComposerClient::EX_BAD_DISPLAY, error.getServiceSpecificError());
+ EXPECT_FALSE(status.isOk());
+ EXPECT_EQ(IComposerClient::EX_BAD_DISPLAY, status.getServiceSpecificError());
}
-TEST_P(GraphicsComposerAidlTest, getPreferredBootDisplayConfig) {
- int32_t preferredDisplayConfig = 0;
- auto const error = mComposerClient->getPreferredBootDisplayConfig(mPrimaryDisplay,
- &preferredDisplayConfig);
- EXPECT_TRUE(error.isOk());
+TEST_P(GraphicsComposerAidlTest, GetPreferredBootDisplayConfig) {
+ const auto& [status, preferredDisplayConfig] =
+ mComposerClient->getPreferredBootDisplayConfig(getPrimaryDisplayId());
+ EXPECT_TRUE(status.isOk());
- std::vector<int32_t> configs;
- EXPECT_TRUE(mComposerClient->getDisplayConfigs(mPrimaryDisplay, &configs).isOk());
+ const auto& [configStatus, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
+
+ EXPECT_TRUE(configStatus.isOk());
EXPECT_NE(configs.end(), std::find(configs.begin(), configs.end(), preferredDisplayConfig));
}
-TEST_P(GraphicsComposerAidlTest, setAutoLowLatencyModeBadDisplay) {
- EXPECT_EQ(IComposerClient::EX_BAD_DISPLAY,
- mComposerClient->setAutoLowLatencyMode(mInvalidDisplayId, true)
- .getServiceSpecificError());
- EXPECT_EQ(IComposerClient::EX_BAD_DISPLAY,
- mComposerClient->setAutoLowLatencyMode(mInvalidDisplayId, false)
- .getServiceSpecificError());
+TEST_P(GraphicsComposerAidlTest, SetAutoLowLatencyMode_BadDisplay) {
+ auto status = mComposerClient->setAutoLowLatencyMode(getInvalidDisplayId(), /*isEnabled*/ true);
+ EXPECT_FALSE(status.isOk());
+ EXPECT_EQ(IComposerClient::EX_BAD_DISPLAY, status.getServiceSpecificError());
+
+ status = mComposerClient->setAutoLowLatencyMode(getInvalidDisplayId(), /*isEnabled*/ false);
+ EXPECT_FALSE(status.isOk());
+ EXPECT_EQ(IComposerClient::EX_BAD_DISPLAY, status.getServiceSpecificError());
}
-TEST_P(GraphicsComposerAidlTest, setAutoLowLatencyMode) {
+TEST_P(GraphicsComposerAidlTest, SetAutoLowLatencyMode) {
for (const auto& display : mDisplays) {
- std::vector<DisplayCapability> capabilities;
- const auto error = mComposerClient->getDisplayCapabilities(display.get(), &capabilities);
- EXPECT_TRUE(error.isOk());
+ const auto& [status, capabilities] =
+ mComposerClient->getDisplayCapabilities(display.getDisplayId());
+ ASSERT_TRUE(status.isOk());
const bool allmSupport =
std::find(capabilities.begin(), capabilities.end(),
DisplayCapability::AUTO_LOW_LATENCY_MODE) != capabilities.end();
if (!allmSupport) {
- const auto errorIsOn = mComposerClient->setAutoLowLatencyMode(display.get(), true);
- EXPECT_FALSE(errorIsOn.isOk());
- EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, errorIsOn.getServiceSpecificError());
- const auto errorIsOff = mComposerClient->setAutoLowLatencyMode(display.get(), false);
- EXPECT_FALSE(errorIsOff.isOk());
- EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, errorIsOff.getServiceSpecificError());
+ const auto& statusIsOn = mComposerClient->setAutoLowLatencyMode(display.getDisplayId(),
+ /*isEnabled*/ true);
+ EXPECT_FALSE(statusIsOn.isOk());
+ EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, statusIsOn.getServiceSpecificError());
+ const auto& statusIsOff = mComposerClient->setAutoLowLatencyMode(display.getDisplayId(),
+ /*isEnabled*/ false);
+ EXPECT_FALSE(statusIsOff.isOk());
+ EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, statusIsOff.getServiceSpecificError());
GTEST_SUCCEED() << "Auto Low Latency Mode is not supported on display "
- << std::to_string(display.get()) << ", skipping test";
+ << std::to_string(display.getDisplayId()) << ", skipping test";
return;
}
- EXPECT_TRUE(mComposerClient->setAutoLowLatencyMode(display.get(), true).isOk());
- EXPECT_TRUE(mComposerClient->setAutoLowLatencyMode(display.get(), false).isOk());
+ EXPECT_TRUE(mComposerClient->setAutoLowLatencyMode(display.getDisplayId(), true).isOk());
+ EXPECT_TRUE(mComposerClient->setAutoLowLatencyMode(display.getDisplayId(), false).isOk());
}
}
-TEST_P(GraphicsComposerAidlTest, getSupportedContentTypesBadDisplay) {
- std::vector<ContentType> supportedContentTypes;
- const auto error =
- mComposerClient->getSupportedContentTypes(mInvalidDisplayId, &supportedContentTypes);
- EXPECT_FALSE(error.isOk());
- EXPECT_EQ(IComposerClient::EX_BAD_DISPLAY, error.getServiceSpecificError());
+TEST_P(GraphicsComposerAidlTest, GetSupportedContentTypes_BadDisplay) {
+ const auto& [status, _] = mComposerClient->getSupportedContentTypes(getInvalidDisplayId());
+
+ EXPECT_FALSE(status.isOk());
+ EXPECT_EQ(IComposerClient::EX_BAD_DISPLAY, status.getServiceSpecificError());
}
-TEST_P(GraphicsComposerAidlTest, getSupportedContentTypes) {
- std::vector<ContentType> supportedContentTypes;
+TEST_P(GraphicsComposerAidlTest, GetSupportedContentTypes) {
for (const auto& display : mDisplays) {
- supportedContentTypes.clear();
- const auto error =
- mComposerClient->getSupportedContentTypes(display.get(), &supportedContentTypes);
-
- ASSERT_TRUE(error.isOk());
+ const auto& [status, supportedContentTypes] =
+ mComposerClient->getSupportedContentTypes(display.getDisplayId());
+ ASSERT_TRUE(status.isOk());
const bool noneSupported =
std::find(supportedContentTypes.begin(), supportedContentTypes.end(),
ContentType::NONE) != supportedContentTypes.end();
+
EXPECT_FALSE(noneSupported);
}
}
-TEST_P(GraphicsComposerAidlTest, setContentTypeNoneAlwaysAccepted) {
+TEST_P(GraphicsComposerAidlTest, SetContentTypeNoneAlwaysAccepted) {
for (const auto& display : mDisplays) {
- const auto error = mComposerClient->setContentType(display.get(), ContentType::NONE);
- EXPECT_TRUE(error.isOk());
+ EXPECT_TRUE(
+ mComposerClient->setContentType(display.getDisplayId(), ContentType::NONE).isOk());
}
}
-TEST_P(GraphicsComposerAidlTest, setContentTypeBadDisplay) {
+TEST_P(GraphicsComposerAidlTest, SetContentType_BadDisplay) {
constexpr ContentType types[] = {ContentType::NONE, ContentType::GRAPHICS, ContentType::PHOTO,
ContentType::CINEMA, ContentType::GAME};
for (const auto& type : types) {
- auto const error = mComposerClient->setContentType(mInvalidDisplayId, type);
+ const auto& status = mComposerClient->setContentType(getInvalidDisplayId(), type);
- EXPECT_FALSE(error.isOk());
- EXPECT_EQ(IComposerClient::EX_BAD_DISPLAY, error.getServiceSpecificError());
+ EXPECT_FALSE(status.isOk());
+ EXPECT_EQ(IComposerClient::EX_BAD_DISPLAY, status.getServiceSpecificError());
}
}
-TEST_P(GraphicsComposerAidlTest, setGraphicsContentType) {
+TEST_P(GraphicsComposerAidlTest, SetGraphicsContentType) {
Test_setContentType(ContentType::GRAPHICS, "GRAPHICS");
}
-TEST_P(GraphicsComposerAidlTest, setPhotoContentType) {
+TEST_P(GraphicsComposerAidlTest, SetPhotoContentType) {
Test_setContentType(ContentType::PHOTO, "PHOTO");
}
-TEST_P(GraphicsComposerAidlTest, setCinemaContentType) {
+TEST_P(GraphicsComposerAidlTest, SetCinemaContentType) {
Test_setContentType(ContentType::CINEMA, "CINEMA");
}
-TEST_P(GraphicsComposerAidlTest, setGameContentType) {
+TEST_P(GraphicsComposerAidlTest, SetGameContentType) {
Test_setContentType(ContentType::GAME, "GAME");
}
TEST_P(GraphicsComposerAidlTest, CreateVirtualDisplay) {
- int32_t maxVirtualDisplayCount;
- EXPECT_TRUE(mComposerClient->getMaxVirtualDisplayCount(&maxVirtualDisplayCount).isOk());
+ const auto& [status, maxVirtualDisplayCount] = mComposerClient->getMaxVirtualDisplayCount();
+ EXPECT_TRUE(status.isOk());
+
if (maxVirtualDisplayCount == 0) {
GTEST_SUCCEED() << "no virtual display support";
return;
}
- VirtualDisplay virtualDisplay;
+ const auto& [virtualDisplayStatus, virtualDisplay] = mComposerClient->createVirtualDisplay(
+ /*width*/ 64, /*height*/ 64, common::PixelFormat::IMPLEMENTATION_DEFINED,
+ kBufferSlotCount);
- EXPECT_TRUE(mComposerClient
- ->createVirtualDisplay(64, 64, common::PixelFormat::IMPLEMENTATION_DEFINED,
- kBufferSlotCount, &virtualDisplay)
- .isOk());
-
- ASSERT_TRUE(mDisplayResources.insert({virtualDisplay.display, DisplayResource(true)}).second)
- << "duplicated virtual display id " << virtualDisplay.display;
-
+ ASSERT_TRUE(virtualDisplayStatus.isOk());
EXPECT_TRUE(mComposerClient->destroyVirtualDisplay(virtualDisplay.display).isOk());
}
-TEST_P(GraphicsComposerAidlTest, DestroyVirtualDisplayBadDisplay) {
- int32_t maxDisplayCount = 0;
- EXPECT_TRUE(mComposerClient->getMaxVirtualDisplayCount(&maxDisplayCount).isOk());
+TEST_P(GraphicsComposerAidlTest, DestroyVirtualDisplay_BadDisplay) {
+ const auto& [status, maxDisplayCount] = mComposerClient->getMaxVirtualDisplayCount();
+ EXPECT_TRUE(status.isOk());
+
if (maxDisplayCount == 0) {
GTEST_SUCCEED() << "no virtual display support";
return;
}
- const auto error = mComposerClient->destroyVirtualDisplay(mInvalidDisplayId);
- EXPECT_FALSE(error.isOk());
- ASSERT_EQ(IComposerClient::EX_BAD_DISPLAY, error.getServiceSpecificError());
+ const auto& destroyStatus = mComposerClient->destroyVirtualDisplay(getInvalidDisplayId());
+
+ EXPECT_FALSE(destroyStatus.isOk());
+ ASSERT_EQ(IComposerClient::EX_BAD_DISPLAY, destroyStatus.getServiceSpecificError());
}
TEST_P(GraphicsComposerAidlTest, CreateLayer) {
- int64_t layer;
- EXPECT_TRUE(mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount, &layer).isOk());
+ const auto& [status, layer] =
+ mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
- EXPECT_TRUE(mComposerClient->destroyLayer(mPrimaryDisplay, layer).isOk());
+ EXPECT_TRUE(status.isOk());
+ EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
}
-TEST_P(GraphicsComposerAidlTest, CreateLayerBadDisplay) {
- int64_t layer;
- const auto error = mComposerClient->createLayer(mInvalidDisplayId, kBufferSlotCount, &layer);
+TEST_P(GraphicsComposerAidlTest, CreateLayer_BadDisplay) {
+ const auto& [status, _] = mComposerClient->createLayer(getInvalidDisplayId(), kBufferSlotCount);
- EXPECT_FALSE(error.isOk());
- ASSERT_EQ(IComposerClient::EX_BAD_DISPLAY, error.getServiceSpecificError());
+ EXPECT_FALSE(status.isOk());
+ ASSERT_EQ(IComposerClient::EX_BAD_DISPLAY, status.getServiceSpecificError());
}
-TEST_P(GraphicsComposerAidlTest, DestroyLayerBadDisplay) {
- int64_t layer;
- EXPECT_TRUE(mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount, &layer).isOk());
+TEST_P(GraphicsComposerAidlTest, DestroyLayer_BadDisplay) {
+ const auto& [status, layer] =
+ mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
+ EXPECT_TRUE(status.isOk());
- const auto error = mComposerClient->destroyLayer(mInvalidDisplayId, layer);
+ const auto& destroyStatus = mComposerClient->destroyLayer(getInvalidDisplayId(), layer);
- EXPECT_FALSE(error.isOk());
- EXPECT_EQ(IComposerClient::EX_BAD_DISPLAY, error.getServiceSpecificError());
- EXPECT_TRUE(mComposerClient->destroyLayer(mPrimaryDisplay, layer).isOk());
+ EXPECT_FALSE(destroyStatus.isOk());
+ EXPECT_EQ(IComposerClient::EX_BAD_DISPLAY, destroyStatus.getServiceSpecificError());
+ ASSERT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
}
-TEST_P(GraphicsComposerAidlTest, DestroyLayerBadLayerError) {
+TEST_P(GraphicsComposerAidlTest, DestroyLayer_BadLayerError) {
// We haven't created any layers yet, so any id should be invalid
- const auto error = mComposerClient->destroyLayer(mPrimaryDisplay, 1);
+ const auto& status = mComposerClient->destroyLayer(getPrimaryDisplayId(), /*layer*/ 1);
- EXPECT_FALSE(error.isOk());
- EXPECT_EQ(IComposerClient::EX_BAD_LAYER, error.getServiceSpecificError());
+ EXPECT_FALSE(status.isOk());
+ EXPECT_EQ(IComposerClient::EX_BAD_LAYER, status.getServiceSpecificError());
}
-TEST_P(GraphicsComposerAidlTest, GetActiveConfigBadDisplay) {
- int32_t config;
- const auto error = mComposerClient->getActiveConfig(mInvalidDisplayId, &config);
+TEST_P(GraphicsComposerAidlTest, GetActiveConfig_BadDisplay) {
+ const auto& [status, _] = mComposerClient->getActiveConfig(getInvalidDisplayId());
- EXPECT_FALSE(error.isOk());
- ASSERT_EQ(IComposerClient::EX_BAD_DISPLAY, error.getServiceSpecificError());
+ EXPECT_FALSE(status.isOk());
+ ASSERT_EQ(IComposerClient::EX_BAD_DISPLAY, status.getServiceSpecificError());
}
TEST_P(GraphicsComposerAidlTest, GetDisplayConfig) {
- std::vector<int32_t> configs;
- EXPECT_TRUE(mComposerClient->getDisplayConfigs(mPrimaryDisplay, &configs).isOk());
+ const auto& [status, _] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
+ EXPECT_TRUE(status.isOk());
}
-TEST_P(GraphicsComposerAidlTest, GetDisplayConfigBadDisplay) {
- std::vector<int32_t> configs;
- const auto error = mComposerClient->getDisplayConfigs(mInvalidDisplayId, &configs);
+TEST_P(GraphicsComposerAidlTest, GetDisplayConfig_BadDisplay) {
+ const auto& [status, _] = mComposerClient->getDisplayConfigs(getInvalidDisplayId());
- EXPECT_FALSE(error.isOk());
- ASSERT_EQ(IComposerClient::EX_BAD_DISPLAY, error.getServiceSpecificError());
+ EXPECT_FALSE(status.isOk());
+ ASSERT_EQ(IComposerClient::EX_BAD_DISPLAY, status.getServiceSpecificError());
}
TEST_P(GraphicsComposerAidlTest, GetDisplayName) {
- std::string displayName;
- EXPECT_TRUE(mComposerClient->getDisplayName(mPrimaryDisplay, &displayName).isOk());
+ const auto& [status, _] = mComposerClient->getDisplayName(getPrimaryDisplayId());
+ EXPECT_TRUE(status.isOk());
}
-TEST_P(GraphicsComposerAidlTest, GetDisplayPhysicalOrientationBadDisplay) {
- Transform displayOrientation;
- const auto error =
- mComposerClient->getDisplayPhysicalOrientation(mInvalidDisplayId, &displayOrientation);
+TEST_P(GraphicsComposerAidlTest, GetDisplayPhysicalOrientation_BadDisplay) {
+ const auto& [status, _] = mComposerClient->getDisplayPhysicalOrientation(getInvalidDisplayId());
- EXPECT_FALSE(error.isOk());
- ASSERT_EQ(IComposerClient::EX_BAD_DISPLAY, error.getServiceSpecificError());
+ EXPECT_FALSE(status.isOk());
+ ASSERT_EQ(IComposerClient::EX_BAD_DISPLAY, status.getServiceSpecificError());
}
TEST_P(GraphicsComposerAidlTest, GetDisplayPhysicalOrientation) {
@@ -987,94 +748,111 @@
Transform::ROT_270,
};
- Transform displayOrientation;
- const auto error =
- mComposerClient->getDisplayPhysicalOrientation(mPrimaryDisplay, &displayOrientation);
+ const auto& [status, displayOrientation] =
+ mComposerClient->getDisplayPhysicalOrientation(getPrimaryDisplayId());
- EXPECT_TRUE(error.isOk());
+ EXPECT_TRUE(status.isOk());
EXPECT_NE(std::find(allowedDisplayOrientations.begin(), allowedDisplayOrientations.end(),
displayOrientation),
allowedDisplayOrientations.end());
}
TEST_P(GraphicsComposerAidlTest, SetClientTargetSlotCount) {
- EXPECT_TRUE(
- mComposerClient->setClientTargetSlotCount(mPrimaryDisplay, kBufferSlotCount).isOk());
+ EXPECT_TRUE(mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kBufferSlotCount)
+ .isOk());
}
TEST_P(GraphicsComposerAidlTest, SetActiveConfig) {
- std::vector<int32_t> configs;
- EXPECT_TRUE(mComposerClient->getDisplayConfigs(mPrimaryDisplay, &configs).isOk());
- for (auto config : configs) {
- EXPECT_TRUE(mComposerClient->setActiveConfig(mPrimaryDisplay, config).isOk());
- int32_t config1;
- EXPECT_TRUE(mComposerClient->getActiveConfig(mPrimaryDisplay, &config1).isOk());
+ const auto& [status, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
+ EXPECT_TRUE(status.isOk());
+
+ for (const auto& config : configs) {
+ auto display = getEditablePrimaryDisplay();
+ EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config).isOk());
+ const auto& [configStatus, config1] =
+ mComposerClient->getActiveConfig(getPrimaryDisplayId());
+ EXPECT_TRUE(configStatus.isOk());
EXPECT_EQ(config, config1);
}
}
TEST_P(GraphicsComposerAidlTest, SetActiveConfigPowerCycle) {
- EXPECT_TRUE(mComposerClient->setPowerMode(mPrimaryDisplay, PowerMode::OFF).isOk());
- EXPECT_TRUE(mComposerClient->setPowerMode(mPrimaryDisplay, PowerMode::ON).isOk());
+ EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
+ EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
- std::vector<int32_t> configs;
- EXPECT_TRUE(mComposerClient->getDisplayConfigs(mPrimaryDisplay, &configs).isOk());
- for (auto config : configs) {
- EXPECT_TRUE(mComposerClient->setActiveConfig(mPrimaryDisplay, config).isOk());
- int32_t config1;
- EXPECT_TRUE(mComposerClient->getActiveConfig(mPrimaryDisplay, &config1).isOk());
+ const auto& [status, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
+ EXPECT_TRUE(status.isOk());
+
+ for (const auto& config : configs) {
+ auto display = getEditablePrimaryDisplay();
+ EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config).isOk());
+ const auto& [config1Status, config1] =
+ mComposerClient->getActiveConfig(getPrimaryDisplayId());
+ EXPECT_TRUE(config1Status.isOk());
EXPECT_EQ(config, config1);
- EXPECT_TRUE(mComposerClient->setPowerMode(mPrimaryDisplay, PowerMode::OFF).isOk());
- EXPECT_TRUE(mComposerClient->setPowerMode(mPrimaryDisplay, PowerMode::ON).isOk());
- EXPECT_TRUE(mComposerClient->getActiveConfig(mPrimaryDisplay, &config1).isOk());
- EXPECT_EQ(config, config1);
+ EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
+ EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
+ const auto& [config2Status, config2] =
+ mComposerClient->getActiveConfig(getPrimaryDisplayId());
+ EXPECT_TRUE(config2Status.isOk());
+ EXPECT_EQ(config, config2);
}
}
TEST_P(GraphicsComposerAidlTest, SetPowerModeUnsupported) {
- std::vector<DisplayCapability> capabilities;
- auto error = mComposerClient->getDisplayCapabilities(mPrimaryDisplay, &capabilities);
- ASSERT_TRUE(error.isOk());
+ const auto& [status, capabilities] =
+ mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
+ ASSERT_TRUE(status.isOk());
+
const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
DisplayCapability::DOZE) != capabilities.end();
const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
DisplayCapability::SUSPEND) != capabilities.end();
- if (!isDozeSupported) {
- error = mComposerClient->setPowerMode(mPrimaryDisplay, PowerMode::DOZE);
- EXPECT_FALSE(error.isOk());
- EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, error.getServiceSpecificError());
- error = mComposerClient->setPowerMode(mPrimaryDisplay, PowerMode::DOZE_SUSPEND);
- EXPECT_FALSE(error.isOk());
- EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, error.getServiceSpecificError());
+ if (!isDozeSupported) {
+ const auto& powerModeDozeStatus =
+ mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE);
+ EXPECT_FALSE(powerModeDozeStatus.isOk());
+ EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, powerModeDozeStatus.getServiceSpecificError());
+
+ const auto& powerModeDozeSuspendStatus =
+ mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE_SUSPEND);
+ EXPECT_FALSE(powerModeDozeSuspendStatus.isOk());
+ EXPECT_EQ(IComposerClient::EX_UNSUPPORTED,
+ powerModeDozeSuspendStatus.getServiceSpecificError());
}
if (!isSuspendSupported) {
- error = mComposerClient->setPowerMode(mPrimaryDisplay, PowerMode::ON_SUSPEND);
- EXPECT_FALSE(error.isOk());
- EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, error.getServiceSpecificError());
+ const auto& powerModeSuspendStatus =
+ mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON_SUSPEND);
+ EXPECT_FALSE(powerModeSuspendStatus.isOk());
+ EXPECT_EQ(IComposerClient::EX_UNSUPPORTED,
+ powerModeSuspendStatus.getServiceSpecificError());
- error = mComposerClient->setPowerMode(mPrimaryDisplay, PowerMode::DOZE_SUSPEND);
- EXPECT_FALSE(error.isOk());
- EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, error.getServiceSpecificError());
+ const auto& powerModeDozeSuspendStatus =
+ mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE_SUSPEND);
+ EXPECT_FALSE(powerModeDozeSuspendStatus.isOk());
+ EXPECT_EQ(IComposerClient::EX_UNSUPPORTED,
+ powerModeDozeSuspendStatus.getServiceSpecificError());
}
}
TEST_P(GraphicsComposerAidlTest, SetVsyncEnabled) {
- mComposerCallback->setVsyncAllowed(true);
+ mComposerClient->setVsyncAllowed(true);
- EXPECT_TRUE(mComposerClient->setVsyncEnabled(mPrimaryDisplay, true).isOk());
+ EXPECT_TRUE(mComposerClient->setVsync(getPrimaryDisplayId(), true).isOk());
usleep(60 * 1000);
- EXPECT_TRUE(mComposerClient->setVsyncEnabled(mPrimaryDisplay, false).isOk());
+ EXPECT_TRUE(mComposerClient->setVsync(getPrimaryDisplayId(), false).isOk());
- mComposerCallback->setVsyncAllowed(false);
+ mComposerClient->setVsyncAllowed(false);
}
TEST_P(GraphicsComposerAidlTest, SetPowerMode) {
- std::vector<DisplayCapability> capabilities;
- const auto error = mComposerClient->getDisplayCapabilities(mPrimaryDisplay, &capabilities);
- ASSERT_TRUE(error.isOk());
+ const auto& [status, capabilities] =
+ mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
+ ASSERT_TRUE(status.isOk());
+
const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
DisplayCapability::DOZE) != capabilities.end();
const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
@@ -1097,14 +875,15 @@
}
for (auto mode : modes) {
- EXPECT_TRUE(mComposerClient->setPowerMode(mPrimaryDisplay, mode).isOk());
+ EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
}
}
TEST_P(GraphicsComposerAidlTest, SetPowerModeVariations) {
- std::vector<DisplayCapability> capabilities;
- const auto error = mComposerClient->getDisplayCapabilities(mPrimaryDisplay, &capabilities);
- ASSERT_TRUE(error.isOk());
+ const auto& [status, capabilities] =
+ mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
+ ASSERT_TRUE(status.isOk());
+
const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
DisplayCapability::DOZE) != capabilities.end();
const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
@@ -1116,21 +895,21 @@
modes.push_back(PowerMode::ON);
modes.push_back(PowerMode::OFF);
for (auto mode : modes) {
- EXPECT_TRUE(mComposerClient->setPowerMode(mPrimaryDisplay, mode).isOk());
+ EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
}
modes.clear();
modes.push_back(PowerMode::OFF);
modes.push_back(PowerMode::OFF);
for (auto mode : modes) {
- EXPECT_TRUE(mComposerClient->setPowerMode(mPrimaryDisplay, mode).isOk());
+ EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
}
modes.clear();
modes.push_back(PowerMode::ON);
modes.push_back(PowerMode::ON);
for (auto mode : modes) {
- EXPECT_TRUE(mComposerClient->setPowerMode(mPrimaryDisplay, mode).isOk());
+ EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
}
modes.clear();
@@ -1138,7 +917,7 @@
modes.push_back(PowerMode::ON_SUSPEND);
modes.push_back(PowerMode::ON_SUSPEND);
for (auto mode : modes) {
- EXPECT_TRUE(mComposerClient->setPowerMode(mPrimaryDisplay, mode).isOk());
+ EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
}
modes.clear();
}
@@ -1147,7 +926,7 @@
modes.push_back(PowerMode::DOZE);
modes.push_back(PowerMode::DOZE);
for (auto mode : modes) {
- EXPECT_TRUE(mComposerClient->setPowerMode(mPrimaryDisplay, mode).isOk());
+ EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
}
modes.clear();
}
@@ -1156,46 +935,46 @@
modes.push_back(PowerMode::DOZE_SUSPEND);
modes.push_back(PowerMode::DOZE_SUSPEND);
for (auto mode : modes) {
- EXPECT_TRUE(mComposerClient->setPowerMode(mPrimaryDisplay, mode).isOk());
+ EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
}
modes.clear();
}
}
-TEST_P(GraphicsComposerAidlTest, SetPowerModeBadDisplay) {
- const auto error = mComposerClient->setPowerMode(mInvalidDisplayId, PowerMode::ON);
+TEST_P(GraphicsComposerAidlTest, SetPowerMode_BadDisplay) {
+ const auto& status = mComposerClient->setPowerMode(getInvalidDisplayId(), PowerMode::ON);
- EXPECT_FALSE(error.isOk());
- ASSERT_EQ(IComposerClient::EX_BAD_DISPLAY, error.getServiceSpecificError());
+ EXPECT_FALSE(status.isOk());
+ ASSERT_EQ(IComposerClient::EX_BAD_DISPLAY, status.getServiceSpecificError());
}
-TEST_P(GraphicsComposerAidlTest, SetPowerModeBadParameter) {
- const auto error = mComposerClient->setPowerMode(mPrimaryDisplay, static_cast<PowerMode>(-1));
+TEST_P(GraphicsComposerAidlTest, SetPowerMode_BadParameter) {
+ const auto& status =
+ mComposerClient->setPowerMode(getPrimaryDisplayId(), static_cast<PowerMode>(-1));
- EXPECT_FALSE(error.isOk());
- ASSERT_EQ(IComposerClient::EX_BAD_PARAMETER, error.getServiceSpecificError());
+ EXPECT_FALSE(status.isOk());
+ ASSERT_EQ(IComposerClient::EX_BAD_PARAMETER, status.getServiceSpecificError());
}
TEST_P(GraphicsComposerAidlTest, GetDataspaceSaturationMatrix) {
- std::vector<float> matrix;
- EXPECT_TRUE(
- mComposerClient->getDataspaceSaturationMatrix(common::Dataspace::SRGB_LINEAR, &matrix)
- .isOk());
+ const auto& [status, matrix] =
+ mComposerClient->getDataspaceSaturationMatrix(common::Dataspace::SRGB_LINEAR);
+ ASSERT_TRUE(status.isOk());
+ ASSERT_EQ(16, matrix.size()); // matrix should not be empty if call succeeded.
// the last row is known
- ASSERT_EQ(0.0f, matrix[12]);
- ASSERT_EQ(0.0f, matrix[13]);
- ASSERT_EQ(0.0f, matrix[14]);
- ASSERT_EQ(1.0f, matrix[15]);
+ EXPECT_EQ(0.0f, matrix[12]);
+ EXPECT_EQ(0.0f, matrix[13]);
+ EXPECT_EQ(0.0f, matrix[14]);
+ EXPECT_EQ(1.0f, matrix[15]);
}
-TEST_P(GraphicsComposerAidlTest, GetDataspaceSaturationMatrixBadParameter) {
- std::vector<float> matrix;
- const auto error =
- mComposerClient->getDataspaceSaturationMatrix(common::Dataspace::UNKNOWN, &matrix);
+TEST_P(GraphicsComposerAidlTest, GetDataspaceSaturationMatrix_BadParameter) {
+ const auto& [status, matrix] =
+ mComposerClient->getDataspaceSaturationMatrix(common::Dataspace::UNKNOWN);
- EXPECT_FALSE(error.isOk());
- EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, error.getServiceSpecificError());
+ EXPECT_FALSE(status.isOk());
+ EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, status.getServiceSpecificError());
}
// Tests for Command.
@@ -1204,8 +983,8 @@
void TearDown() override {
const auto errors = mReader.takeErrors();
ASSERT_TRUE(mReader.takeErrors().empty());
- ASSERT_TRUE(mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty());
- ASSERT_TRUE(mReader.takeBufferAheadResultLayers(mPrimaryDisplay).empty());
+ ASSERT_TRUE(mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty());
+ ASSERT_TRUE(mReader.takeBufferAheadResultLayers(getPrimaryDisplayId()).empty());
ASSERT_NO_FATAL_FAILURE(GraphicsComposerAidlTest::TearDown());
}
@@ -1217,8 +996,7 @@
return;
}
- std::vector<CommandResultPayload> results;
- const auto status = mComposerClient->executeCommands(commands, &results);
+ auto [status, results] = mComposerClient->executeCommands(commands);
ASSERT_TRUE(status.isOk()) << "executeCommands failed " << status.getDescription();
mReader.parse(std::move(results));
@@ -1229,24 +1007,9 @@
return std::chrono::time_point<std::chrono::steady_clock>(std::chrono::nanoseconds(time));
}
- void setActiveConfig(VtsDisplay& display, int32_t config) {
- EXPECT_TRUE(mComposerClient->setActiveConfig(display.get(), config).isOk());
- int32_t displayWidth;
- EXPECT_TRUE(mComposerClient
- ->getDisplayAttribute(display.get(), config, DisplayAttribute::WIDTH,
- &displayWidth)
- .isOk());
- int32_t displayHeight;
- EXPECT_TRUE(mComposerClient
- ->getDisplayAttribute(display.get(), config, DisplayAttribute::HEIGHT,
- &displayHeight)
- .isOk());
- display.setDimensions(displayWidth, displayHeight);
- }
-
void forEachTwoConfigs(int64_t display, std::function<void(int32_t, int32_t)> func) {
- std::vector<int32_t> displayConfigs;
- EXPECT_TRUE(mComposerClient->getDisplayConfigs(display, &displayConfigs).isOk());
+ const auto& [status, displayConfigs] = mComposerClient->getDisplayConfigs(display);
+ ASSERT_TRUE(status.isOk());
for (const int32_t config1 : displayConfigs) {
for (const int32_t config2 : displayConfigs) {
if (config1 != config2) {
@@ -1261,8 +1024,9 @@
int64_t newPeriodNanos) {
const auto kChangeDeadline = toTimePoint(timeline.newVsyncAppliedTimeNanos) + 100ms;
while (std::chrono::steady_clock::now() <= kChangeDeadline) {
- int32_t vsyncPeriodNanos;
- EXPECT_TRUE(mComposerClient->getDisplayVsyncPeriod(display, &vsyncPeriodNanos).isOk());
+ const auto& [status, vsyncPeriodNanos] =
+ mComposerClient->getDisplayVsyncPeriod(display);
+ EXPECT_TRUE(status.isOk());
if (systemTime() <= desiredTimeNanos) {
EXPECT_EQ(vsyncPeriodNanos, oldPeriodNanos);
} else if (vsyncPeriodNanos == newPeriodNanos) {
@@ -1274,9 +1038,10 @@
sp<GraphicBuffer> allocate() {
return sp<GraphicBuffer>::make(
- static_cast<uint32_t>(mDisplayWidth), static_cast<uint32_t>(mDisplayHeight),
+ static_cast<uint32_t>(getPrimaryDisplay().getDisplayWidth()),
+ static_cast<uint32_t>(getPrimaryDisplay().getDisplayHeight()),
::android::PIXEL_FORMAT_RGBA_8888,
- /*layerCount*/ 1,
+ /*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)),
@@ -1291,39 +1056,32 @@
std::this_thread::sleep_until(toTimePoint(timeline->refreshTimeNanos));
}
- EXPECT_TRUE(mComposerClient->setPowerMode(display.get(), PowerMode::ON).isOk());
- EXPECT_TRUE(
- mComposerClient
- ->setColorMode(display.get(), ColorMode::NATIVE, RenderIntent::COLORIMETRIC)
- .isOk());
+ EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::ON).isOk());
+ EXPECT_TRUE(mComposerClient
+ ->setColorMode(display.getDisplayId(), ColorMode::NATIVE,
+ RenderIntent::COLORIMETRIC)
+ .isOk());
- int64_t layer = 0;
- ASSERT_NO_FATAL_FAILURE(layer = createLayer(display));
+ const auto& [status, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount);
+ EXPECT_TRUE(status.isOk());
{
const auto buffer = allocate();
ASSERT_NE(nullptr, buffer);
ASSERT_EQ(::android::OK, buffer->initCheck());
ASSERT_NE(nullptr, buffer->handle);
- mWriter.setLayerCompositionType(display.get(), layer, Composition::DEVICE);
- mWriter.setLayerDisplayFrame(display.get(), layer, display.getFrameRect());
- mWriter.setLayerPlaneAlpha(display.get(), layer, 1);
- mWriter.setLayerSourceCrop(display.get(), layer, display.getCrop());
- mWriter.setLayerTransform(display.get(), layer, static_cast<Transform>(0));
- mWriter.setLayerVisibleRegion(display.get(), layer,
- std::vector<Rect>(1, display.getFrameRect()));
- mWriter.setLayerZOrder(display.get(), layer, 10);
- mWriter.setLayerBlendMode(display.get(), layer, BlendMode::NONE);
- mWriter.setLayerSurfaceDamage(display.get(), layer,
- std::vector<Rect>(1, display.getFrameRect()));
- mWriter.setLayerBuffer(display.get(), layer, 0, buffer->handle, -1);
- mWriter.setLayerDataspace(display.get(), layer, common::Dataspace::UNKNOWN);
+ configureLayer(display, layer, Composition::DEVICE, display.getFrameRect(),
+ display.getCrop());
+ mWriter.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, buffer->handle,
+ /*acquireFence*/ -1);
+ mWriter.setLayerDataspace(display.getDisplayId(), layer, common::Dataspace::UNKNOWN);
- mWriter.validateDisplay(display.get(), ComposerClientWriter::kNoTimestamp);
+ mWriter.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp);
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.presentDisplay(display.get());
+ mWriter.presentDisplay(display.getDisplayId());
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
}
@@ -1332,31 +1090,32 @@
const auto buffer = allocate();
ASSERT_NE(nullptr, buffer->handle);
- mWriter.setLayerBuffer(display.get(), layer, 0, buffer->handle, -1);
- mWriter.setLayerSurfaceDamage(display.get(), layer,
+ mWriter.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, buffer->handle,
+ /*acquireFence*/ -1);
+ mWriter.setLayerSurfaceDamage(display.getDisplayId(), layer,
std::vector<Rect>(1, {0, 0, 10, 10}));
- mWriter.validateDisplay(display.get(), ComposerClientWriter::kNoTimestamp);
+ mWriter.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp);
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.presentDisplay(display.get());
+ mWriter.presentDisplay(display.getDisplayId());
execute();
}
- ASSERT_NO_FATAL_FAILURE(destroyLayer(display, layer));
+ EXPECT_TRUE(mComposerClient->destroyLayer(display.getDisplayId(), layer).isOk());
}
sp<::android::Fence> presentAndGetFence(
std::optional<ClockMonotonicTimestamp> expectedPresentTime) {
- mWriter.validateDisplay(mPrimaryDisplay, expectedPresentTime);
+ mWriter.validateDisplay(getPrimaryDisplayId(), expectedPresentTime);
execute();
EXPECT_TRUE(mReader.takeErrors().empty());
- mWriter.presentDisplay(mPrimaryDisplay);
+ mWriter.presentDisplay(getPrimaryDisplayId());
execute();
EXPECT_TRUE(mReader.takeErrors().empty());
- auto presentFence = mReader.takePresentFence(mPrimaryDisplay);
+ auto presentFence = mReader.takePresentFence(getPrimaryDisplayId());
// take ownership
const int fenceOwner = presentFence.get();
*presentFence.getR() = -1;
@@ -1365,74 +1124,49 @@
}
int32_t getVsyncPeriod() {
- int32_t activeConfig;
- EXPECT_TRUE(mComposerClient->getActiveConfig(mPrimaryDisplay, &activeConfig).isOk());
+ const auto& [status, activeConfig] =
+ mComposerClient->getActiveConfig(getPrimaryDisplayId());
+ EXPECT_TRUE(status.isOk());
- int32_t vsyncPeriod;
- EXPECT_TRUE(mComposerClient
- ->getDisplayAttribute(mPrimaryDisplay, activeConfig,
- DisplayAttribute::VSYNC_PERIOD, &vsyncPeriod)
- .isOk());
+ const auto& [vsyncPeriodStatus, vsyncPeriod] = mComposerClient->getDisplayAttribute(
+ getPrimaryDisplayId(), activeConfig, DisplayAttribute::VSYNC_PERIOD);
+ EXPECT_TRUE(vsyncPeriodStatus.isOk());
return vsyncPeriod;
}
int64_t createOnScreenLayer() {
- const int64_t layer = createLayer(mDisplays[0]);
- mWriter.setLayerCompositionType(mPrimaryDisplay, layer, Composition::DEVICE);
- mWriter.setLayerDisplayFrame(mPrimaryDisplay, layer, {0, 0, mDisplayWidth, mDisplayHeight});
- mWriter.setLayerPlaneAlpha(mPrimaryDisplay, layer, 1);
- mWriter.setLayerSourceCrop(
- mPrimaryDisplay, layer,
- {0, 0, static_cast<float>(mDisplayWidth), static_cast<float>(mDisplayHeight)});
- mWriter.setLayerTransform(mPrimaryDisplay, layer, static_cast<Transform>(0));
- mWriter.setLayerVisibleRegion(mPrimaryDisplay, layer,
- std::vector<Rect>(1, {0, 0, mDisplayWidth, mDisplayHeight}));
- mWriter.setLayerZOrder(mPrimaryDisplay, layer, 10);
- mWriter.setLayerBlendMode(mPrimaryDisplay, layer, BlendMode::NONE);
- mWriter.setLayerSurfaceDamage(mPrimaryDisplay, layer,
- std::vector<Rect>(1, {0, 0, mDisplayWidth, mDisplayHeight}));
- mWriter.setLayerDataspace(mPrimaryDisplay, layer, common::Dataspace::UNKNOWN);
+ const auto& [status, layer] =
+ mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
+ EXPECT_TRUE(status.isOk());
+ Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
+ getPrimaryDisplay().getDisplayHeight()};
+ FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
+ (float)getPrimaryDisplay().getDisplayHeight()};
+ configureLayer(getPrimaryDisplay(), layer, Composition::DEVICE, displayFrame, cropRect);
+ mWriter.setLayerDataspace(getPrimaryDisplayId(), layer, common::Dataspace::UNKNOWN);
return layer;
}
bool hasDisplayCapability(int64_t display, DisplayCapability cap) {
- std::vector<DisplayCapability> capabilities;
- const auto error = mComposerClient->getDisplayCapabilities(display, &capabilities);
- EXPECT_TRUE(error.isOk());
+ const auto& [status, capabilities] = mComposerClient->getDisplayCapabilities(display);
+ EXPECT_TRUE(status.isOk());
return std::find(capabilities.begin(), capabilities.end(), cap) != capabilities.end();
}
void Test_setActiveConfigWithConstraints(const TestParameters& params) {
for (VtsDisplay& display : mDisplays) {
- forEachTwoConfigs(display.get(), [&](int32_t config1, int32_t config2) {
- setActiveConfig(display, config1);
+ forEachTwoConfigs(display.getDisplayId(), [&](int32_t config1, int32_t config2) {
+ EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
sendRefreshFrame(display, nullptr);
- int32_t vsyncPeriod1;
- EXPECT_TRUE(mComposerClient
- ->getDisplayAttribute(display.get(), config1,
- DisplayAttribute::VSYNC_PERIOD,
- &vsyncPeriod1)
- .isOk());
- int32_t configGroup1;
- EXPECT_TRUE(mComposerClient
- ->getDisplayAttribute(display.get(), config1,
- DisplayAttribute::CONFIG_GROUP,
- &configGroup1)
- .isOk());
- int32_t vsyncPeriod2;
- EXPECT_TRUE(mComposerClient
- ->getDisplayAttribute(display.get(), config2,
- DisplayAttribute::VSYNC_PERIOD,
- &vsyncPeriod2)
- .isOk());
- int32_t configGroup2;
- EXPECT_TRUE(mComposerClient
- ->getDisplayAttribute(display.get(), config2,
- DisplayAttribute::CONFIG_GROUP,
- &configGroup2)
- .isOk());
+ const auto displayConfigGroup1 = display.getDisplayConfig(config1);
+ int32_t vsyncPeriod1 = displayConfigGroup1.vsyncPeriod;
+ int32_t configGroup1 = displayConfigGroup1.configGroup;
+
+ const auto displayConfigGroup2 = display.getDisplayConfig(config2);
+ int32_t vsyncPeriod2 = displayConfigGroup2.vsyncPeriod;
+ int32_t configGroup2 = displayConfigGroup2.configGroup;
if (vsyncPeriod1 == vsyncPeriod2) {
return; // continue
@@ -1443,12 +1177,12 @@
return; // continue
}
- VsyncPeriodChangeTimeline timeline;
VsyncPeriodChangeConstraints constraints = {
.desiredTimeNanos = systemTime() + params.delayForChange,
.seamlessRequired = false};
- EXPECT_TRUE(setActiveConfigWithConstraints(display, config2, constraints, &timeline)
- .isOk());
+ const auto& [status, timeline] = mComposerClient->setActiveConfigWithConstraints(
+ &display, config2, constraints);
+ EXPECT_TRUE(status.isOk());
EXPECT_TRUE(timeline.newVsyncAppliedTimeNanos >= constraints.desiredTimeNanos);
// Refresh rate should change within a reasonable time
@@ -1465,13 +1199,13 @@
}
sendRefreshFrame(display, &timeline);
}
- waitForVsyncPeriodChange(display.get(), timeline, constraints.desiredTimeNanos,
- vsyncPeriod1, vsyncPeriod2);
+ waitForVsyncPeriodChange(display.getDisplayId(), timeline,
+ constraints.desiredTimeNanos, vsyncPeriod1, vsyncPeriod2);
// At this point the refresh rate should have changed already, however in rare
// cases the implementation might have missed the deadline. In this case a new
// timeline should have been provided.
- auto newTimeline = mComposerCallback->takeLastVsyncPeriodChangeTimeline();
+ auto newTimeline = mComposerClient->takeLastVsyncPeriodChangeTimeline();
if (timeline.refreshRequired && params.refreshMiss) {
EXPECT_TRUE(newTimeline.has_value());
}
@@ -1480,14 +1214,14 @@
if (newTimeline->refreshRequired) {
sendRefreshFrame(display, &newTimeline.value());
}
- waitForVsyncPeriodChange(display.get(), newTimeline.value(),
+ waitForVsyncPeriodChange(display.getDisplayId(), newTimeline.value(),
constraints.desiredTimeNanos, vsyncPeriod1,
vsyncPeriod2);
}
- int32_t vsyncPeriodNanos;
- EXPECT_TRUE(mComposerClient->getDisplayVsyncPeriod(display.get(), &vsyncPeriodNanos)
- .isOk());
+ const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanos] =
+ mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
+ EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
EXPECT_EQ(vsyncPeriodNanos, vsyncPeriod2);
});
}
@@ -1499,7 +1233,7 @@
return;
}
- ASSERT_TRUE(mComposerClient->setPowerMode(mPrimaryDisplay, PowerMode::ON).isOk());
+ ASSERT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
const auto vsyncPeriod = getVsyncPeriod();
@@ -1509,7 +1243,8 @@
ASSERT_NE(nullptr, buffer2);
const auto layer = createOnScreenLayer();
- mWriter.setLayerBuffer(mPrimaryDisplay, layer, 0, buffer1->handle, -1);
+ mWriter.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer1->handle,
+ /*acquireFence*/ -1);
const sp<::android::Fence> presentFence1 =
presentAndGetFence(ComposerClientWriter::kNoTimestamp);
presentFence1->waitForever(LOG_TAG);
@@ -1519,7 +1254,8 @@
expectedPresentTime += *framesDelay * vsyncPeriod;
}
- mWriter.setLayerBuffer(mPrimaryDisplay, layer, 0, buffer2->handle, -1);
+ mWriter.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer2->handle,
+ /*acquireFence*/ -1);
const auto setExpectedPresentTime = [&]() -> std::optional<ClockMonotonicTimestamp> {
if (!framesDelay.has_value()) {
return ComposerClientWriter::kNoTimestamp;
@@ -1535,9 +1271,23 @@
const auto actualPresentTime = presentFence2->getSignalTime();
EXPECT_GE(actualPresentTime, expectedPresentTime - vsyncPeriod / 2);
- ASSERT_TRUE(mComposerClient->setPowerMode(mPrimaryDisplay, PowerMode::OFF).isOk());
+ ASSERT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
}
+ void configureLayer(const VtsDisplay& display, int64_t layer, Composition composition,
+ const Rect& displayFrame, const FRect& cropRect) {
+ mWriter.setLayerCompositionType(display.getDisplayId(), layer, composition);
+ mWriter.setLayerDisplayFrame(display.getDisplayId(), layer, displayFrame);
+ mWriter.setLayerPlaneAlpha(display.getDisplayId(), layer, /*alpha*/ 1);
+ mWriter.setLayerSourceCrop(display.getDisplayId(), layer, cropRect);
+ mWriter.setLayerTransform(display.getDisplayId(), layer, static_cast<Transform>(0));
+ mWriter.setLayerVisibleRegion(display.getDisplayId(), layer,
+ std::vector<Rect>(1, displayFrame));
+ mWriter.setLayerZOrder(display.getDisplayId(), layer, /*z*/ 10);
+ mWriter.setLayerBlendMode(display.getDisplayId(), layer, BlendMode::NONE);
+ mWriter.setLayerSurfaceDamage(display.getDisplayId(), layer,
+ std::vector<Rect>(1, displayFrame));
+ }
// clang-format off
const std::array<float, 16> kIdentity = {{
1.0f, 0.0f, 0.0f, 0.0f,
@@ -1551,15 +1301,16 @@
ComposerClientReader mReader;
};
-TEST_P(GraphicsComposerAidlCommandTest, SET_COLOR_TRANSFORM) {
- mWriter.setColorTransform(mPrimaryDisplay, kIdentity.data());
+TEST_P(GraphicsComposerAidlCommandTest, SetColorTransform) {
+ mWriter.setColorTransform(getPrimaryDisplayId(), kIdentity.data());
execute();
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerColorTransform) {
- int64_t layer;
- EXPECT_TRUE(mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount, &layer).isOk());
- mWriter.setLayerColorTransform(mPrimaryDisplay, layer, kIdentity.data());
+ const auto& [status, layer] =
+ mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
+ EXPECT_TRUE(status.isOk());
+ mWriter.setLayerColorTransform(getPrimaryDisplayId(), layer, kIdentity.data());
execute();
const auto errors = mReader.takeErrors();
@@ -1570,13 +1321,13 @@
}
TEST_P(GraphicsComposerAidlCommandTest, SetDisplayBrightness) {
- std::vector<DisplayCapability> capabilities;
- auto error = mComposerClient->getDisplayCapabilities(mPrimaryDisplay, &capabilities);
- ASSERT_TRUE(error.isOk());
+ const auto& [status, capabilities] =
+ mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
+ ASSERT_TRUE(status.isOk());
bool brightnessSupport = std::find(capabilities.begin(), capabilities.end(),
DisplayCapability::BRIGHTNESS) != capabilities.end();
if (!brightnessSupport) {
- mWriter.setDisplayBrightness(mPrimaryDisplay, 0.5f);
+ mWriter.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.5f);
execute();
const auto errors = mReader.takeErrors();
EXPECT_EQ(1, errors.size());
@@ -1585,23 +1336,23 @@
return;
}
- mWriter.setDisplayBrightness(mPrimaryDisplay, 0.0f);
+ mWriter.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.0f);
execute();
EXPECT_TRUE(mReader.takeErrors().empty());
- mWriter.setDisplayBrightness(mPrimaryDisplay, 0.5f);
+ mWriter.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.5f);
execute();
EXPECT_TRUE(mReader.takeErrors().empty());
- mWriter.setDisplayBrightness(mPrimaryDisplay, 1.0f);
+ mWriter.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 1.0f);
execute();
EXPECT_TRUE(mReader.takeErrors().empty());
- mWriter.setDisplayBrightness(mPrimaryDisplay, -1.0f);
+ mWriter.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ -1.0f);
execute();
EXPECT_TRUE(mReader.takeErrors().empty());
- mWriter.setDisplayBrightness(mPrimaryDisplay, 2.0f);
+ mWriter.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 2.0f);
execute();
{
const auto errors = mReader.takeErrors();
@@ -1609,7 +1360,7 @@
EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
}
- mWriter.setDisplayBrightness(mPrimaryDisplay, -2.0f);
+ mWriter.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ -2.0f);
execute();
{
const auto errors = mReader.takeErrors();
@@ -1618,51 +1369,49 @@
}
}
-TEST_P(GraphicsComposerAidlCommandTest, SET_CLIENT_TARGET) {
- EXPECT_TRUE(
- mComposerClient->setClientTargetSlotCount(mPrimaryDisplay, kBufferSlotCount).isOk());
+TEST_P(GraphicsComposerAidlCommandTest, SetClientTarget) {
+ EXPECT_TRUE(mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kBufferSlotCount)
+ .isOk());
- mWriter.setClientTarget(mPrimaryDisplay, 0, nullptr, -1, Dataspace::UNKNOWN,
- std::vector<Rect>());
+ mWriter.setClientTarget(getPrimaryDisplayId(), /*slot*/ 0, nullptr, /*acquireFence*/ -1,
+ Dataspace::UNKNOWN, std::vector<Rect>());
execute();
}
-TEST_P(GraphicsComposerAidlCommandTest, SET_OUTPUT_BUFFER) {
- int32_t virtualDisplayCount;
- EXPECT_TRUE(mComposerClient->getMaxVirtualDisplayCount(&virtualDisplayCount).isOk());
+TEST_P(GraphicsComposerAidlCommandTest, SetOutputBuffer) {
+ const auto& [status, virtualDisplayCount] = mComposerClient->getMaxVirtualDisplayCount();
+ EXPECT_TRUE(status.isOk());
if (virtualDisplayCount == 0) {
GTEST_SUCCEED() << "no virtual display support";
return;
}
- VirtualDisplay display;
- EXPECT_TRUE(mComposerClient
- ->createVirtualDisplay(64, 64, common::PixelFormat::IMPLEMENTATION_DEFINED,
- kBufferSlotCount, &display)
- .isOk());
+ const auto& [displayStatus, display] = mComposerClient->createVirtualDisplay(
+ /*width*/ 64, /*height*/ 64, common::PixelFormat::IMPLEMENTATION_DEFINED,
+ kBufferSlotCount);
+ EXPECT_TRUE(displayStatus.isOk());
const auto buffer = allocate();
const auto handle = buffer->handle;
- mWriter.setOutputBuffer(display.display, 0, handle, -1);
+ mWriter.setOutputBuffer(display.display, /*slot*/ 0, handle, /*releaseFence*/ -1);
execute();
}
-TEST_P(GraphicsComposerAidlCommandTest, VALIDATE_DISPLAY) {
- mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);
+TEST_P(GraphicsComposerAidlCommandTest, ValidDisplay) {
+ mWriter.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
execute();
}
-TEST_P(GraphicsComposerAidlCommandTest, ACCEPT_DISPLAY_CHANGES) {
- mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);
- mWriter.acceptDisplayChanges(mPrimaryDisplay);
+TEST_P(GraphicsComposerAidlCommandTest, AcceptDisplayChanges) {
+ mWriter.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
+ mWriter.acceptDisplayChanges(getPrimaryDisplayId());
execute();
}
-// TODO(b/208441745) fix the test failure
-TEST_P(GraphicsComposerAidlCommandTest, PRESENT_DISPLAY) {
- mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);
- mWriter.presentDisplay(mPrimaryDisplay);
+TEST_P(GraphicsComposerAidlCommandTest, PresentDisplay) {
+ mWriter.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
+ mWriter.presentDisplay(getPrimaryDisplayId());
execute();
}
@@ -1673,236 +1422,237 @@
* additional call to validateDisplay when only the layer buffer handle and
* surface damage have been set
*/
-// TODO(b/208441745) fix the test failure
-TEST_P(GraphicsComposerAidlCommandTest, PRESENT_DISPLAY_NO_LAYER_STATE_CHANGES) {
+TEST_P(GraphicsComposerAidlCommandTest, PresentDisplayNoLayerStateChanges) {
if (!hasCapability(Capability::SKIP_VALIDATE)) {
GTEST_SUCCEED() << "Device does not have skip validate capability, skipping";
return;
}
- mComposerClient->setPowerMode(mPrimaryDisplay, PowerMode::ON);
+ EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
- std::vector<RenderIntent> renderIntents;
- mComposerClient->getRenderIntents(mPrimaryDisplay, ColorMode::NATIVE, &renderIntents);
+ const auto& [renderIntentsStatus, renderIntents] =
+ mComposerClient->getRenderIntents(getPrimaryDisplayId(), ColorMode::NATIVE);
+ EXPECT_TRUE(renderIntentsStatus.isOk());
for (auto intent : renderIntents) {
- mComposerClient->setColorMode(mPrimaryDisplay, ColorMode::NATIVE, intent);
+ EXPECT_TRUE(mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE, intent)
+ .isOk());
const auto buffer = allocate();
const auto handle = buffer->handle;
ASSERT_NE(nullptr, handle);
- Rect displayFrame{0, 0, mDisplayWidth, mDisplayHeight};
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
+ EXPECT_TRUE(layerStatus.isOk());
- int64_t layer;
- EXPECT_TRUE(mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount, &layer).isOk());
- mWriter.setLayerCompositionType(mPrimaryDisplay, layer, Composition::DEVICE);
- mWriter.setLayerDisplayFrame(mPrimaryDisplay, layer, displayFrame);
- mWriter.setLayerPlaneAlpha(mPrimaryDisplay, layer, 1);
- mWriter.setLayerSourceCrop(mPrimaryDisplay, layer,
- {0, 0, (float)mDisplayWidth, (float)mDisplayHeight});
- mWriter.setLayerTransform(mPrimaryDisplay, layer, static_cast<Transform>(0));
- mWriter.setLayerVisibleRegion(mPrimaryDisplay, layer, std::vector<Rect>(1, displayFrame));
- mWriter.setLayerZOrder(mPrimaryDisplay, layer, 10);
- mWriter.setLayerBlendMode(mPrimaryDisplay, layer, BlendMode::NONE);
- mWriter.setLayerSurfaceDamage(mPrimaryDisplay, layer, std::vector<Rect>(1, displayFrame));
- mWriter.setLayerBuffer(mPrimaryDisplay, layer, 0, handle, -1);
- mWriter.setLayerDataspace(mPrimaryDisplay, layer, Dataspace::UNKNOWN);
-
- mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);
+ Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
+ getPrimaryDisplay().getDisplayHeight()};
+ FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
+ (float)getPrimaryDisplay().getDisplayHeight()};
+ configureLayer(getPrimaryDisplay(), layer, Composition::CURSOR, displayFrame, cropRect);
+ mWriter.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle,
+ /*acquireFence*/ -1);
+ mWriter.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
+ mWriter.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
execute();
- if (!mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty()) {
+ if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED() << "Composition change requested, skipping test";
return;
}
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.presentDisplay(mPrimaryDisplay);
+ mWriter.presentDisplay(getPrimaryDisplayId());
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
const auto buffer2 = allocate();
const auto handle2 = buffer2->handle;
ASSERT_NE(nullptr, handle2);
- mWriter.setLayerBuffer(mPrimaryDisplay, layer, 0, handle2, -1);
- mWriter.setLayerSurfaceDamage(mPrimaryDisplay, layer, std::vector<Rect>(1, {0, 0, 10, 10}));
- mWriter.presentDisplay(mPrimaryDisplay);
+ mWriter.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle2,
+ /*acquireFence*/ -1);
+ mWriter.setLayerSurfaceDamage(getPrimaryDisplayId(), layer,
+ std::vector<Rect>(1, {0, 0, 10, 10}));
+ mWriter.presentDisplay(getPrimaryDisplayId());
execute();
}
}
-// TODO(b/208441745) fix the test failure
-TEST_P(GraphicsComposerAidlCommandTest, SET_LAYER_CURSOR_POSITION) {
- int64_t layer;
- EXPECT_TRUE(mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount, &layer).isOk());
+TEST_P(GraphicsComposerAidlCommandTest, SetLayerCursorPosition) {
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
+ EXPECT_TRUE(layerStatus.isOk());
const auto buffer = allocate();
const auto handle = buffer->handle;
ASSERT_NE(nullptr, handle);
- Rect displayFrame{0, 0, mDisplayWidth, mDisplayHeight};
- mWriter.setLayerBuffer(mPrimaryDisplay, layer, 0, handle, -1);
- mWriter.setLayerCompositionType(mPrimaryDisplay, layer, Composition::CURSOR);
- mWriter.setLayerDisplayFrame(mPrimaryDisplay, layer, displayFrame);
- mWriter.setLayerPlaneAlpha(mPrimaryDisplay, layer, 1);
- mWriter.setLayerSourceCrop(mPrimaryDisplay, layer,
- {0, 0, (float)mDisplayWidth, (float)mDisplayHeight});
- mWriter.setLayerTransform(mPrimaryDisplay, layer, static_cast<Transform>(0));
- mWriter.setLayerVisibleRegion(mPrimaryDisplay, layer, std::vector<Rect>(1, displayFrame));
- mWriter.setLayerZOrder(mPrimaryDisplay, layer, 10);
- mWriter.setLayerBlendMode(mPrimaryDisplay, layer, BlendMode::NONE);
- mWriter.setLayerSurfaceDamage(mPrimaryDisplay, layer, std::vector<Rect>(1, displayFrame));
- mWriter.setLayerDataspace(mPrimaryDisplay, layer, Dataspace::UNKNOWN);
- mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);
+ mWriter.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle, /*acquireFence*/ -1);
+
+ Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
+ getPrimaryDisplay().getDisplayHeight()};
+ FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
+ (float)getPrimaryDisplay().getDisplayHeight()};
+ configureLayer(getPrimaryDisplay(), layer, Composition::CURSOR, displayFrame, cropRect);
+ mWriter.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
+ mWriter.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
execute();
- if (!mReader.takeChangedCompositionTypes(mPrimaryDisplay).empty()) {
+ if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED() << "Composition change requested, skipping test";
return;
}
- mWriter.presentDisplay(mPrimaryDisplay);
+ mWriter.presentDisplay(getPrimaryDisplayId());
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.setLayerCursorPosition(mPrimaryDisplay, layer, 1, 1);
+ mWriter.setLayerCursorPosition(getPrimaryDisplayId(), layer, /*x*/ 1, /*y*/ 1);
execute();
- mWriter.setLayerCursorPosition(mPrimaryDisplay, layer, 0, 0);
- mWriter.validateDisplay(mPrimaryDisplay, ComposerClientWriter::kNoTimestamp);
- mWriter.presentDisplay(mPrimaryDisplay);
+ mWriter.setLayerCursorPosition(getPrimaryDisplayId(), layer, /*x*/ 0, /*y*/ 0);
+ mWriter.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp);
+ mWriter.presentDisplay(getPrimaryDisplayId());
execute();
}
-TEST_P(GraphicsComposerAidlCommandTest, SET_LAYER_BUFFER) {
+TEST_P(GraphicsComposerAidlCommandTest, SetLayerBuffer) {
const auto buffer = allocate();
const auto handle = buffer->handle;
ASSERT_NE(nullptr, handle);
- int64_t layer;
- EXPECT_TRUE(mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount, &layer).isOk());
- mWriter.setLayerBuffer(mPrimaryDisplay, layer, 0, handle, -1);
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
+ EXPECT_TRUE(layerStatus.isOk());
+ mWriter.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle, /*acquireFence*/ -1);
execute();
}
-TEST_P(GraphicsComposerAidlCommandTest, SET_LAYER_SURFACE_DAMAGE) {
- int64_t layer;
- EXPECT_TRUE(mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount, &layer).isOk());
+TEST_P(GraphicsComposerAidlCommandTest, SetLayerSurfaceDamage) {
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
+ EXPECT_TRUE(layerStatus.isOk());
Rect empty{0, 0, 0, 0};
Rect unit{0, 0, 1, 1};
- mWriter.setLayerSurfaceDamage(mPrimaryDisplay, layer, std::vector<Rect>(1, empty));
+ mWriter.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.setLayerSurfaceDamage(mPrimaryDisplay, layer, std::vector<Rect>(1, unit));
+ mWriter.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.setLayerSurfaceDamage(mPrimaryDisplay, layer, std::vector<Rect>());
+ mWriter.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>());
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
}
-TEST_P(GraphicsComposerAidlCommandTest, SET_LAYER_BLOCKING_REGION) {
- int64_t layer;
- EXPECT_TRUE(mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount, &layer).isOk());
+TEST_P(GraphicsComposerAidlCommandTest, SetLayerBlockingRegion) {
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
+ EXPECT_TRUE(layerStatus.isOk());
Rect empty{0, 0, 0, 0};
Rect unit{0, 0, 1, 1};
- mWriter.setLayerBlockingRegion(mPrimaryDisplay, layer, std::vector<Rect>(1, empty));
+ mWriter.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.setLayerBlockingRegion(mPrimaryDisplay, layer, std::vector<Rect>(1, unit));
+ mWriter.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.setLayerBlockingRegion(mPrimaryDisplay, layer, std::vector<Rect>());
+ mWriter.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>());
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
}
-TEST_P(GraphicsComposerAidlCommandTest, SET_LAYER_BLEND_MODE) {
- int64_t layer;
- EXPECT_TRUE(mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount, &layer).isOk());
+TEST_P(GraphicsComposerAidlCommandTest, SetLayerBlendMode) {
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
+ EXPECT_TRUE(layerStatus.isOk());
- mWriter.setLayerBlendMode(mPrimaryDisplay, layer, BlendMode::NONE);
+ mWriter.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::NONE);
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.setLayerBlendMode(mPrimaryDisplay, layer, BlendMode::PREMULTIPLIED);
+ mWriter.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::PREMULTIPLIED);
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.setLayerBlendMode(mPrimaryDisplay, layer, BlendMode::COVERAGE);
+ mWriter.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::COVERAGE);
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
}
-TEST_P(GraphicsComposerAidlCommandTest, SET_LAYER_COLOR) {
- int64_t layer;
- EXPECT_TRUE(mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount, &layer).isOk());
+TEST_P(GraphicsComposerAidlCommandTest, SetLayerColor) {
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
+ EXPECT_TRUE(layerStatus.isOk());
- mWriter.setLayerColor(mPrimaryDisplay, layer, Color{1.0f, 1.0f, 1.0f, 1.0f});
+ mWriter.setLayerColor(getPrimaryDisplayId(), layer, Color{1.0f, 1.0f, 1.0f, 1.0f});
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.setLayerColor(mPrimaryDisplay, layer, Color{0.0f, 0.0f, 0.0f, 0.0f});
+ mWriter.setLayerColor(getPrimaryDisplayId(), layer, Color{0.0f, 0.0f, 0.0f, 0.0f});
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
}
-TEST_P(GraphicsComposerAidlCommandTest, SET_LAYER_COMPOSITION_TYPE) {
- int64_t layer;
- EXPECT_TRUE(mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount, &layer).isOk());
+TEST_P(GraphicsComposerAidlCommandTest, SetLayerCompositionType) {
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
+ EXPECT_TRUE(layerStatus.isOk());
- mWriter.setLayerCompositionType(mPrimaryDisplay, layer, Composition::CLIENT);
+ mWriter.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::CLIENT);
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.setLayerCompositionType(mPrimaryDisplay, layer, Composition::DEVICE);
+ mWriter.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::DEVICE);
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.setLayerCompositionType(mPrimaryDisplay, layer, Composition::SOLID_COLOR);
+ mWriter.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::SOLID_COLOR);
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.setLayerCompositionType(mPrimaryDisplay, layer, Composition::CURSOR);
+ mWriter.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::CURSOR);
+ execute();
+}
+
+TEST_P(GraphicsComposerAidlCommandTest, SetLayerDataspace) {
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
+ EXPECT_TRUE(layerStatus.isOk());
+
+ mWriter.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
+ execute();
+}
+
+TEST_P(GraphicsComposerAidlCommandTest, SetLayerDisplayFrame) {
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
+ EXPECT_TRUE(layerStatus.isOk());
+
+ mWriter.setLayerDisplayFrame(getPrimaryDisplayId(), layer, Rect{0, 0, 1, 1});
+ execute();
+}
+
+TEST_P(GraphicsComposerAidlCommandTest, SetLayerPlaneAlpha) {
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
+ EXPECT_TRUE(layerStatus.isOk());
+
+ mWriter.setLayerPlaneAlpha(getPrimaryDisplayId(), layer, /*alpha*/ 0.0f);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
+
+ mWriter.setLayerPlaneAlpha(getPrimaryDisplayId(), layer, /*alpha*/ 1.0f);
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
}
-TEST_P(GraphicsComposerAidlCommandTest, SET_LAYER_DATASPACE) {
- int64_t layer;
- EXPECT_TRUE(mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount, &layer).isOk());
-
- mWriter.setLayerDataspace(mPrimaryDisplay, layer, Dataspace::UNKNOWN);
- execute();
-}
-
-TEST_P(GraphicsComposerAidlCommandTest, SET_LAYER_DISPLAY_FRAME) {
- int64_t layer;
- EXPECT_TRUE(mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount, &layer).isOk());
-
- mWriter.setLayerDisplayFrame(mPrimaryDisplay, layer, Rect{0, 0, 1, 1});
- execute();
-}
-
-TEST_P(GraphicsComposerAidlCommandTest, SET_LAYER_PLANE_ALPHA) {
- int64_t layer;
- EXPECT_TRUE(mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount, &layer).isOk());
-
- mWriter.setLayerPlaneAlpha(mPrimaryDisplay, layer, 0.0f);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
-
- mWriter.setLayerPlaneAlpha(mPrimaryDisplay, layer, 1.0f);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
-}
-
-TEST_P(GraphicsComposerAidlCommandTest, SET_LAYER_SIDEBAND_STREAM) {
+TEST_P(GraphicsComposerAidlCommandTest, SetLayerSidebandStream) {
if (!hasCapability(Capability::SIDEBAND_STREAM)) {
GTEST_SUCCEED() << "no sideband stream support";
return;
@@ -1912,98 +1662,104 @@
const auto handle = buffer->handle;
ASSERT_NE(nullptr, handle);
- int64_t layer;
- EXPECT_TRUE(mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount, &layer).isOk());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
+ EXPECT_TRUE(layerStatus.isOk());
- mWriter.setLayerSidebandStream(mPrimaryDisplay, layer, handle);
+ mWriter.setLayerSidebandStream(getPrimaryDisplayId(), layer, handle);
execute();
}
-TEST_P(GraphicsComposerAidlCommandTest, SET_LAYER_SOURCE_CROP) {
- int64_t layer;
- EXPECT_TRUE(mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount, &layer).isOk());
+TEST_P(GraphicsComposerAidlCommandTest, SetLayerSourceCrop) {
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
+ EXPECT_TRUE(layerStatus.isOk());
- mWriter.setLayerSourceCrop(mPrimaryDisplay, layer, FRect{0.0f, 0.0f, 1.0f, 1.0f});
+ mWriter.setLayerSourceCrop(getPrimaryDisplayId(), layer, FRect{0.0f, 0.0f, 1.0f, 1.0f});
execute();
}
-TEST_P(GraphicsComposerAidlCommandTest, SET_LAYER_TRANSFORM) {
- int64_t layer;
- EXPECT_TRUE(mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount, &layer).isOk());
+TEST_P(GraphicsComposerAidlCommandTest, SetLayerTransform) {
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
+ EXPECT_TRUE(layerStatus.isOk());
- mWriter.setLayerTransform(mPrimaryDisplay, layer, static_cast<Transform>(0));
+ mWriter.setLayerTransform(getPrimaryDisplayId(), layer, static_cast<Transform>(0));
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.setLayerTransform(mPrimaryDisplay, layer, Transform::FLIP_H);
+ mWriter.setLayerTransform(getPrimaryDisplayId(), layer, Transform::FLIP_H);
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.setLayerTransform(mPrimaryDisplay, layer, Transform::FLIP_V);
+ mWriter.setLayerTransform(getPrimaryDisplayId(), layer, Transform::FLIP_V);
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.setLayerTransform(mPrimaryDisplay, layer, Transform::ROT_90);
+ mWriter.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_90);
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.setLayerTransform(mPrimaryDisplay, layer, Transform::ROT_180);
+ mWriter.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_180);
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.setLayerTransform(mPrimaryDisplay, layer, Transform::ROT_270);
+ mWriter.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_270);
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.setLayerTransform(mPrimaryDisplay, layer,
+ mWriter.setLayerTransform(getPrimaryDisplayId(), layer,
static_cast<Transform>(static_cast<int>(Transform::FLIP_H) |
static_cast<int>(Transform::ROT_90)));
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.setLayerTransform(mPrimaryDisplay, layer,
+ mWriter.setLayerTransform(getPrimaryDisplayId(), layer,
static_cast<Transform>(static_cast<int>(Transform::FLIP_V) |
static_cast<int>(Transform::ROT_90)));
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
}
-TEST_P(GraphicsComposerAidlCommandTest, SET_LAYER_VISIBLE_REGION) {
- int64_t layer;
- EXPECT_TRUE(mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount, &layer).isOk());
+TEST_P(GraphicsComposerAidlCommandTest, SetLayerVisibleRegion) {
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
+ EXPECT_TRUE(layerStatus.isOk());
Rect empty{0, 0, 0, 0};
Rect unit{0, 0, 1, 1};
- mWriter.setLayerVisibleRegion(mPrimaryDisplay, layer, std::vector<Rect>(1, empty));
+ mWriter.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.setLayerVisibleRegion(mPrimaryDisplay, layer, std::vector<Rect>(1, unit));
+ mWriter.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.setLayerVisibleRegion(mPrimaryDisplay, layer, std::vector<Rect>());
+ mWriter.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>());
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
}
-TEST_P(GraphicsComposerAidlCommandTest, SET_LAYER_Z_ORDER) {
- int64_t layer;
- EXPECT_TRUE(mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount, &layer).isOk());
+TEST_P(GraphicsComposerAidlCommandTest, SetLayerZOrder) {
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
+ EXPECT_TRUE(layerStatus.isOk());
- mWriter.setLayerZOrder(mPrimaryDisplay, layer, 10);
+ mWriter.setLayerZOrder(getPrimaryDisplayId(), layer, /*z*/ 10);
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.setLayerZOrder(mPrimaryDisplay, layer, 0);
+ mWriter.setLayerZOrder(getPrimaryDisplayId(), layer, /*z*/ 0);
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
}
-TEST_P(GraphicsComposerAidlCommandTest, SET_LAYER_PER_FRAME_METADATA) {
- int64_t layer;
- EXPECT_TRUE(mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount, &layer).isOk());
+TEST_P(GraphicsComposerAidlCommandTest, SetLayerPerFrameMetadata) {
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
+ EXPECT_TRUE(layerStatus.isOk());
/**
* DISPLAY_P3 is a color space that uses the DCI_P3 primaries,
@@ -2030,88 +1786,86 @@
aidlMetadata.push_back({PerFrameMetadataKey::MIN_LUMINANCE, 0.1f});
aidlMetadata.push_back({PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL, 78.0});
aidlMetadata.push_back({PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL, 62.0});
- mWriter.setLayerPerFrameMetadata(mPrimaryDisplay, layer, aidlMetadata);
+ mWriter.setLayerPerFrameMetadata(getPrimaryDisplayId(), layer, aidlMetadata);
execute();
const auto errors = mReader.takeErrors();
if (errors.size() == 1 && errors[0].errorCode == EX_UNSUPPORTED_OPERATION) {
GTEST_SUCCEED() << "SetLayerPerFrameMetadata is not supported";
- EXPECT_TRUE(mComposerClient->destroyLayer(mPrimaryDisplay, layer).isOk());
+ EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
return;
}
- EXPECT_TRUE(mComposerClient->destroyLayer(mPrimaryDisplay, layer).isOk());
+ EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer).isOk());
}
-TEST_P(GraphicsComposerAidlCommandTest, setLayerWhitePointNits) {
- int64_t layer;
- EXPECT_TRUE(mComposerClient->createLayer(mPrimaryDisplay, kBufferSlotCount, &layer).isOk());
+TEST_P(GraphicsComposerAidlCommandTest, SetLayerWhitePointNits) {
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount);
+ EXPECT_TRUE(layerStatus.isOk());
- mWriter.setLayerWhitePointNits(mPrimaryDisplay, layer, 200.f);
+ mWriter.setLayerWhitePointNits(getPrimaryDisplayId(), layer, /*whitePointNits*/ 200.f);
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.setLayerWhitePointNits(mPrimaryDisplay, layer, 1000.f);
+ mWriter.setLayerWhitePointNits(getPrimaryDisplayId(), layer, /*whitePointNits*/ 1000.f);
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.setLayerWhitePointNits(mPrimaryDisplay, layer, 0.f);
+ mWriter.setLayerWhitePointNits(getPrimaryDisplayId(), layer, /*whitePointNits*/ 0.f);
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
- mWriter.setLayerWhitePointNits(mPrimaryDisplay, layer, -1.f);
+ mWriter.setLayerWhitePointNits(getPrimaryDisplayId(), layer, /*whitePointNits*/ -1.f);
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
}
-TEST_P(GraphicsComposerAidlCommandTest, setActiveConfigWithConstraints) {
+TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints) {
Test_setActiveConfigWithConstraints({.delayForChange = 0, .refreshMiss = false});
}
-TEST_P(GraphicsComposerAidlCommandTest, setActiveConfigWithConstraints_Delayed) {
+TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_Delayed) {
Test_setActiveConfigWithConstraints({.delayForChange = 300'000'000, // 300ms
.refreshMiss = false});
}
-TEST_P(GraphicsComposerAidlCommandTest, setActiveConfigWithConstraints_MissRefresh) {
+TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_MissRefresh) {
Test_setActiveConfigWithConstraints({.delayForChange = 0, .refreshMiss = true});
}
-TEST_P(GraphicsComposerAidlCommandTest, getDisplayVsyncPeriod) {
+TEST_P(GraphicsComposerAidlCommandTest, GetDisplayVsyncPeriod) {
for (VtsDisplay& display : mDisplays) {
- std::vector<int32_t> configs;
- EXPECT_TRUE(mComposerClient->getDisplayConfigs(display.get(), &configs).isOk());
- for (int32_t config : configs) {
- int32_t expectedVsyncPeriodNanos = -1;
- EXPECT_TRUE(mComposerClient
- ->getDisplayAttribute(display.get(), config,
- DisplayAttribute::VSYNC_PERIOD,
- &expectedVsyncPeriodNanos)
- .isOk());
+ const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
+ EXPECT_TRUE(status.isOk());
- VsyncPeriodChangeTimeline timeline;
+ for (int32_t config : configs) {
+ int32_t expectedVsyncPeriodNanos = display.getDisplayConfig(config).vsyncPeriod;
+
VsyncPeriodChangeConstraints constraints;
constraints.desiredTimeNanos = systemTime();
constraints.seamlessRequired = false;
- EXPECT_TRUE(mComposerClient
- ->setActiveConfigWithConstraints(display.get(), config, constraints,
- &timeline)
- .isOk());
+
+ const auto& [timelineStatus, timeline] =
+ mComposerClient->setActiveConfigWithConstraints(&display, config, constraints);
+ EXPECT_TRUE(timelineStatus.isOk());
if (timeline.refreshRequired) {
sendRefreshFrame(display, &timeline);
}
- waitForVsyncPeriodChange(display.get(), timeline, constraints.desiredTimeNanos, 0,
- expectedVsyncPeriodNanos);
+ waitForVsyncPeriodChange(display.getDisplayId(), timeline, constraints.desiredTimeNanos,
+ /*odPeriodNanos*/ 0, expectedVsyncPeriodNanos);
int32_t vsyncPeriodNanos;
int retryCount = 100;
do {
std::this_thread::sleep_for(10ms);
- vsyncPeriodNanos = 0;
- EXPECT_TRUE(mComposerClient->getDisplayVsyncPeriod(display.get(), &vsyncPeriodNanos)
- .isOk());
+ const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanosValue] =
+ mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
+
+ EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
+ vsyncPeriodNanos = vsyncPeriodNanosValue;
--retryCount;
} while (vsyncPeriodNanos != expectedVsyncPeriodNanos && retryCount > 0);
@@ -2124,122 +1878,121 @@
std::this_thread::sleep_for(timeout);
timeout *= 2;
vsyncPeriodNanos = 0;
- EXPECT_TRUE(mComposerClient->getDisplayVsyncPeriod(display.get(), &vsyncPeriodNanos)
- .isOk());
+ const auto& [vsyncPeriodNanosStatus, vsyncPeriodNanosValue] =
+ mComposerClient->getDisplayVsyncPeriod(display.getDisplayId());
+
+ EXPECT_TRUE(vsyncPeriodNanosStatus.isOk());
+ vsyncPeriodNanos = vsyncPeriodNanosValue;
EXPECT_EQ(vsyncPeriodNanos, expectedVsyncPeriodNanos);
}
}
}
}
-TEST_P(GraphicsComposerAidlCommandTest, setActiveConfigWithConstraints_SeamlessNotAllowed) {
- VsyncPeriodChangeTimeline timeline;
+TEST_P(GraphicsComposerAidlCommandTest, SetActiveConfigWithConstraints_SeamlessNotAllowed) {
VsyncPeriodChangeConstraints constraints;
-
constraints.seamlessRequired = true;
constraints.desiredTimeNanos = systemTime();
for (VtsDisplay& display : mDisplays) {
- forEachTwoConfigs(display.get(), [&](int32_t config1, int32_t config2) {
- int32_t configGroup1;
- EXPECT_TRUE(mComposerClient
- ->getDisplayAttribute(display.get(), config1,
- DisplayAttribute::CONFIG_GROUP, &configGroup1)
- .isOk());
- int32_t configGroup2;
- EXPECT_TRUE(mComposerClient
- ->getDisplayAttribute(display.get(), config2,
- DisplayAttribute::CONFIG_GROUP, &configGroup2)
- .isOk());
+ forEachTwoConfigs(display.getDisplayId(), [&](int32_t config1, int32_t config2) {
+ int32_t configGroup1 = display.getDisplayConfig(config1).configGroup;
+ int32_t configGroup2 = display.getDisplayConfig(config2).configGroup;
if (configGroup1 != configGroup2) {
- setActiveConfig(display, config1);
+ EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
sendRefreshFrame(display, nullptr);
+ const auto& [status, _] = mComposerClient->setActiveConfigWithConstraints(
+ &display, config2, constraints);
+ EXPECT_FALSE(status.isOk());
EXPECT_EQ(IComposerClient::EX_SEAMLESS_NOT_ALLOWED,
- setActiveConfigWithConstraints(display, config2, constraints, &timeline)
- .getServiceSpecificError());
+ status.getServiceSpecificError());
}
});
}
}
-TEST_P(GraphicsComposerAidlCommandTest, expectedPresentTime_NoTimestamp) {
- ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(std::nullopt));
+TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_NoTimestamp) {
+ ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ std::nullopt));
}
-TEST_P(GraphicsComposerAidlCommandTest, expectedPresentTime_0) {
- ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(0));
+TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_0) {
+ ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ 0));
}
-TEST_P(GraphicsComposerAidlCommandTest, expectedPresentTime_5) {
- ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(5));
+TEST_P(GraphicsComposerAidlCommandTest, ExpectedPresentTime_5) {
+ ASSERT_NO_FATAL_FAILURE(Test_expectedPresentTime(/*framesDelay*/ 5));
}
-TEST_P(GraphicsComposerAidlCommandTest, setIdleTimerEnabled_Unsupported) {
- const bool hasDisplayIdleTimerSupport = hasDisplayCapability(mPrimaryDisplay,
- DisplayCapability::DISPLAY_IDLE_TIMER);
+TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Unsupported) {
+ const bool hasDisplayIdleTimerSupport =
+ hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
if (!hasDisplayIdleTimerSupport) {
- const auto error = mComposerClient->setIdleTimerEnabled(mPrimaryDisplay, 0);
- EXPECT_FALSE(error.isOk());
- EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, error.getServiceSpecificError());
+ const auto& status =
+ mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0);
+ EXPECT_FALSE(status.isOk());
+ EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, status.getServiceSpecificError());
}
}
-TEST_P(GraphicsComposerAidlCommandTest, setIdleTimerEnabled_BadParameter) {
- const bool hasDisplayIdleTimerSupport = hasDisplayCapability(mPrimaryDisplay,
- DisplayCapability::DISPLAY_IDLE_TIMER);
+TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_BadParameter) {
+ const bool hasDisplayIdleTimerSupport =
+ hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
if (!hasDisplayIdleTimerSupport) {
GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
return;
}
- const auto error = mComposerClient->setIdleTimerEnabled(mPrimaryDisplay, -1);
- EXPECT_FALSE(error.isOk());
- EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, error.getServiceSpecificError());
+ const auto& status =
+ mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ -1);
+ EXPECT_FALSE(status.isOk());
+ EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, status.getServiceSpecificError());
}
-TEST_P(GraphicsComposerAidlCommandTest, setIdleTimerEnabled_Disable) {
- const bool hasDisplayIdleTimerSupport = hasDisplayCapability(mPrimaryDisplay,
- DisplayCapability::DISPLAY_IDLE_TIMER);
+TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Disable) {
+ const bool hasDisplayIdleTimerSupport =
+ hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
if (!hasDisplayIdleTimerSupport) {
GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
return;
}
- EXPECT_TRUE(mComposerClient->setIdleTimerEnabled(mPrimaryDisplay, 0).isOk());
+ EXPECT_TRUE(mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0).isOk());
std::this_thread::sleep_for(1s);
- EXPECT_EQ(0, mComposerCallback->getVsyncIdleCount());
+ EXPECT_EQ(0, mComposerClient->getVsyncIdleCount());
}
-TEST_P(GraphicsComposerAidlCommandTest, setIdleTimerEnabled_Timeout_2) {
- const bool hasDisplayIdleTimerSupport = hasDisplayCapability(mPrimaryDisplay,
- DisplayCapability::DISPLAY_IDLE_TIMER);
+TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Timeout_2) {
+ const bool hasDisplayIdleTimerSupport =
+ hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
if (!hasDisplayIdleTimerSupport) {
GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
return;
}
- EXPECT_TRUE(mComposerClient->setPowerMode(mPrimaryDisplay, PowerMode::ON).isOk());
- EXPECT_TRUE(mComposerClient->setIdleTimerEnabled(mPrimaryDisplay, 0).isOk());
+ EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
+ EXPECT_TRUE(mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0).isOk());
const auto buffer = allocate();
ASSERT_NE(nullptr, buffer->handle);
const auto layer = createOnScreenLayer();
- mWriter.setLayerBuffer(mPrimaryDisplay, layer, 0, buffer->handle, -1);
- int32_t vsyncIdleCount = mComposerCallback->getVsyncIdleCount();
+ mWriter.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer->handle,
+ /*acquireFence*/ -1);
+ int32_t vsyncIdleCount = mComposerClient->getVsyncIdleCount();
auto earlyVsyncIdleTime = systemTime() + std::chrono::nanoseconds(2s).count();
- EXPECT_TRUE(mComposerClient->setIdleTimerEnabled(mPrimaryDisplay, 2000).isOk());
+ EXPECT_TRUE(
+ mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 2000).isOk());
const sp<::android::Fence> presentFence =
- presentAndGetFence(ComposerClientWriter::kNoTimestamp);
+ presentAndGetFence(ComposerClientWriter::kNoTimestamp);
presentFence->waitForever(LOG_TAG);
std::this_thread::sleep_for(3s);
- if (vsyncIdleCount < mComposerCallback->getVsyncIdleCount()) {
- EXPECT_GE(mComposerCallback->getVsyncIdleTime(), earlyVsyncIdleTime);
+ if (vsyncIdleCount < mComposerClient->getVsyncIdleCount()) {
+ EXPECT_GE(mComposerClient->getVsyncIdleTime(), earlyVsyncIdleTime);
}
- EXPECT_TRUE(mComposerClient->setPowerMode(mPrimaryDisplay, PowerMode::OFF).isOk());
+ EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
}
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsComposerAidlCommandTest);
diff --git a/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/composer-vts/Android.bp b/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/composer-vts/Android.bp
deleted file mode 100644
index df038db..0000000
--- a/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/composer-vts/Android.bp
+++ /dev/null
@@ -1,78 +0,0 @@
-/**
- * Copyright (c) 2021, The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package {
- // See: http://go/android-license-faq
- // A large-scale-change added 'default_applicable_licenses' to import
- // all of the 'license_kinds' from "hardware_interfaces_license"
- // to get the below license kinds:
- // SPDX-license-identifier-Apache-2.0
- default_applicable_licenses: ["hardware_interfaces_license"],
-}
-
-cc_library_static {
- name: "android.hardware.graphics.composer@3-vts",
- defaults: ["hidl_defaults"],
- srcs: [
- "GraphicsComposerCallback.cpp",
- "ReadbackVts.cpp",
- "RenderEngineVts.cpp",
- ],
- header_libs: [
- "android.hardware.graphics.composer3-command-buffer",
- ],
- static_libs: [
- "android.hardware.graphics.composer3-V1-ndk",
- "android.hardware.graphics.common-V3-ndk",
- "android.hardware.common-V2-ndk",
- "android.hardware.common.fmq-V1-ndk",
- "libarect",
- "libgtest",
- "libbase",
- "libfmq",
- "libsync",
- "libmath",
- "libaidlcommonsupport",
- "libnativewindow",
- "librenderengine",
- "libshaders",
- "libtonemap",
- "android.hardware.graphics.mapper@2.0-vts",
- "android.hardware.graphics.mapper@2.1-vts",
- "android.hardware.graphics.mapper@3.0-vts",
- "android.hardware.graphics.mapper@4.0-vts",
- ],
- shared_libs: [
- "libbinder_ndk",
- "libhidlbase",
- "libui",
- "android.hardware.graphics.composer3-V1-ndk",
- ],
- export_static_lib_headers: [
- "android.hardware.graphics.mapper@2.1-vts",
- "librenderengine",
- ],
- cflags: [
- "-O0",
- "-g",
- "-DLOG_TAG=\"ComposerVts\"",
- "-Wconversion",
- ],
- export_header_lib_headers: [
- "android.hardware.graphics.composer3-command-buffer",
- ],
- export_include_dirs: ["include"],
-}
diff --git a/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/composer-vts/ReadbackVts.cpp b/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/composer-vts/ReadbackVts.cpp
index 587c523..1aca76f 100644
--- a/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/composer-vts/ReadbackVts.cpp
+++ b/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/composer-vts/ReadbackVts.cpp
@@ -14,19 +14,12 @@
* limitations under the License.
*/
-// TODO(b/129481165): remove the #pragma below and fix conversion issues
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wconversion"
-
#include "include/ReadbackVts.h"
#include <aidl/android/hardware/graphics/common/BufferUsage.h>
#include "include/RenderEngineVts.h"
#include "renderengine/ExternalTexture.h"
#include "renderengine/impl/ExternalTexture.h"
-// TODO(b/129481165): remove the #pragma below and fix conversion issues
-#pragma clang diagnostic pop // ignored "-Wconversion
-
namespace aidl::android::hardware::graphics::composer3::vts {
const std::vector<ColorMode> ReadbackHelper::colorModes = {ColorMode::SRGB, ColorMode::DISPLAY_P3};
@@ -195,13 +188,12 @@
}
}
-ReadbackBuffer::ReadbackBuffer(int64_t display, const std::shared_ptr<IComposerClient>& client,
+ReadbackBuffer::ReadbackBuffer(int64_t display, const std::shared_ptr<VtsComposerClient>& client,
int32_t width, int32_t height, common::PixelFormat pixelFormat,
- common::Dataspace dataspace) {
+ common::Dataspace dataspace)
+ : mComposerClient(client) {
mDisplay = display;
- mComposerClient = client;
-
mPixelFormat = pixelFormat;
mDataspace = dataspace;
@@ -227,23 +219,22 @@
mGraphicBuffer = allocate();
ASSERT_NE(nullptr, mGraphicBuffer);
ASSERT_EQ(::android::OK, mGraphicBuffer->initCheck());
- aidl::android::hardware::common::NativeHandle bufferHandle =
- ::android::dupToAidl(mGraphicBuffer->handle);
+ const auto& bufferHandle = mGraphicBuffer->handle;
::ndk::ScopedFileDescriptor fence = ::ndk::ScopedFileDescriptor(-1);
EXPECT_TRUE(mComposerClient->setReadbackBuffer(mDisplay, bufferHandle, fence).isOk());
}
-void ReadbackBuffer::checkReadbackBuffer(std::vector<Color> expectedColors) {
+void ReadbackBuffer::checkReadbackBuffer(const std::vector<Color>& expectedColors) {
ASSERT_NE(nullptr, mGraphicBuffer);
// lock buffer for reading
- ndk::ScopedFileDescriptor fenceHandle;
- EXPECT_TRUE(mComposerClient->getReadbackBufferFence(mDisplay, &fenceHandle).isOk());
+ const auto& [fenceStatus, bufferFence] = mComposerClient->getReadbackBufferFence(mDisplay);
+ EXPECT_TRUE(fenceStatus.isOk());
int bytesPerPixel = -1;
int bytesPerStride = -1;
void* bufData = nullptr;
- auto status = mGraphicBuffer->lockAsync(mUsage, mAccessRegion, &bufData, dup(fenceHandle.get()),
+ auto status = mGraphicBuffer->lockAsync(mUsage, mAccessRegion, &bufData, dup(bufferFence.get()),
&bytesPerPixel, &bytesPerStride);
EXPECT_EQ(::android::OK, status);
ASSERT_TRUE(mPixelFormat == PixelFormat::RGB_888 || mPixelFormat == PixelFormat::RGBA_8888);
@@ -270,7 +261,7 @@
return layerSettings;
}
-TestBufferLayer::TestBufferLayer(const std::shared_ptr<IComposerClient>& client,
+TestBufferLayer::TestBufferLayer(const std::shared_ptr<VtsComposerClient>& client,
const ::android::sp<::android::GraphicBuffer>& graphicBuffer,
TestRenderEngine& renderEngine, int64_t display, uint32_t width,
uint32_t height, common::PixelFormat format,
@@ -318,8 +309,8 @@
const float translateY = mSourceCrop.top / (static_cast<float>(mHeight));
layerSettings.source.buffer.textureTransform =
- ::android::mat4::translate(::android::vec4(translateX, translateY, 0, 1.0)) *
- ::android::mat4::scale(::android::vec4(scaleX, scaleY, 1.0, 1.0));
+ ::android::mat4::translate(::android::vec4(translateX, translateY, 0.0f, 1.0f)) *
+ ::android::mat4::scale(::android::vec4(scaleX, scaleY, 1.0f, 1.0f));
return layerSettings;
}
diff --git a/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/composer-vts/VtsComposerClient.cpp b/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/composer-vts/VtsComposerClient.cpp
new file mode 100644
index 0000000..8c882d0
--- /dev/null
+++ b/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/composer-vts/VtsComposerClient.cpp
@@ -0,0 +1,502 @@
+/**
+ * Copyright (c) 2022, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "include/VtsComposerClient.h"
+#include <aidlcommonsupport/NativeHandle.h>
+#include <android-base/logging.h>
+#include <log/log_main.h>
+
+#undef LOG_TAG
+#define LOG_TAG "VtsComposerClient"
+
+using namespace std::chrono_literals;
+
+namespace aidl::android::hardware::graphics::composer3::vts {
+
+VtsComposerClient::VtsComposerClient(const std::string& name) {
+ SpAIBinder binder(AServiceManager_waitForService(name.c_str()));
+ ALOGE_IF(binder == nullptr, "Could not initialize the service binder");
+ if (binder != nullptr) {
+ mComposer = IComposer::fromBinder(binder);
+ ALOGE_IF(mComposer == nullptr, "Failed to acquire the composer from the binder");
+ }
+}
+
+ScopedAStatus VtsComposerClient::createClient() {
+ if (mComposer == nullptr) {
+ ALOGE("IComposer not initialized");
+ return ScopedAStatus::fromServiceSpecificError(IComposerClient::INVALID_CONFIGURATION);
+ }
+ auto status = mComposer->createClient(&mComposerClient);
+ if (!status.isOk() || mComposerClient == nullptr) {
+ ALOGE("Failed to create client for IComposerClient with %s",
+ status.getDescription().c_str());
+ return status;
+ }
+ mComposerCallback = SharedRefBase::make<GraphicsComposerCallback>();
+ if (mComposerCallback == nullptr) {
+ ALOGE("Unable to create ComposerCallback");
+ return ScopedAStatus::fromServiceSpecificError(IComposerClient::INVALID_CONFIGURATION);
+ }
+ return mComposerClient->registerCallback(mComposerCallback);
+}
+
+bool VtsComposerClient::tearDown() {
+ return verifyComposerCallbackParams() && destroyAllLayers();
+}
+
+std::pair<ScopedAStatus, VirtualDisplay> VtsComposerClient::createVirtualDisplay(
+ int32_t width, int32_t height, PixelFormat pixelFormat, int32_t bufferSlotCount) {
+ VirtualDisplay outVirtualDisplay;
+ auto status = mComposerClient->createVirtualDisplay(width, height, pixelFormat, bufferSlotCount,
+ &outVirtualDisplay);
+ if (!status.isOk()) {
+ return {std::move(status), outVirtualDisplay};
+ }
+ return {addDisplayToDisplayResources(outVirtualDisplay.display, /*isVirtual*/ true),
+ outVirtualDisplay};
+}
+
+ScopedAStatus VtsComposerClient::destroyVirtualDisplay(int64_t display) {
+ auto status = mComposerClient->destroyVirtualDisplay(display);
+ if (!status.isOk()) {
+ return status;
+ }
+ mDisplayResources.erase(display);
+ return status;
+}
+
+std::pair<ScopedAStatus, int64_t> VtsComposerClient::createLayer(int64_t display,
+ int32_t bufferSlotCount) {
+ int64_t outLayer;
+ auto status = mComposerClient->createLayer(display, bufferSlotCount, &outLayer);
+
+ if (!status.isOk()) {
+ return {std::move(status), outLayer};
+ }
+ return {addLayerToDisplayResources(display, outLayer), outLayer};
+}
+
+ScopedAStatus VtsComposerClient::destroyLayer(int64_t display, int64_t layer) {
+ auto status = mComposerClient->destroyLayer(display, layer);
+
+ if (!status.isOk()) {
+ return status;
+ }
+ removeLayerFromDisplayResources(display, layer);
+ return status;
+}
+
+std::pair<ScopedAStatus, int32_t> VtsComposerClient::getActiveConfig(int64_t display) {
+ int32_t outConfig;
+ return {mComposerClient->getActiveConfig(display, &outConfig), outConfig};
+}
+
+ScopedAStatus VtsComposerClient::setActiveConfig(VtsDisplay* vtsDisplay, int32_t config) {
+ auto status = mComposerClient->setActiveConfig(vtsDisplay->getDisplayId(), config);
+ if (!status.isOk()) {
+ return status;
+ }
+ return updateDisplayProperties(vtsDisplay, config);
+}
+
+std::pair<ScopedAStatus, int32_t> VtsComposerClient::getDisplayAttribute(
+ int64_t display, int32_t config, DisplayAttribute displayAttribute) {
+ int32_t outDisplayAttribute;
+ return {mComposerClient->getDisplayAttribute(display, config, displayAttribute,
+ &outDisplayAttribute),
+ outDisplayAttribute};
+}
+
+ScopedAStatus VtsComposerClient::setPowerMode(int64_t display, PowerMode powerMode) {
+ return mComposerClient->setPowerMode(display, powerMode);
+}
+
+ScopedAStatus VtsComposerClient::setVsync(int64_t display, bool enable) {
+ return mComposerClient->setVsyncEnabled(display, enable);
+}
+
+void VtsComposerClient::setVsyncAllowed(bool isAllowed) {
+ mComposerCallback->setVsyncAllowed(isAllowed);
+}
+
+std::pair<ScopedAStatus, std::vector<float>> VtsComposerClient::getDataspaceSaturationMatrix(
+ Dataspace dataspace) {
+ std::vector<float> outMatrix;
+ return {mComposerClient->getDataspaceSaturationMatrix(dataspace, &outMatrix), outMatrix};
+}
+
+std::pair<ScopedAStatus, std::vector<CommandResultPayload>> VtsComposerClient::executeCommands(
+ const std::vector<DisplayCommand>& commands) {
+ std::vector<CommandResultPayload> outResultPayload;
+ return {mComposerClient->executeCommands(commands, &outResultPayload),
+ std::move(outResultPayload)};
+}
+
+std::optional<VsyncPeriodChangeTimeline> VtsComposerClient::takeLastVsyncPeriodChangeTimeline() {
+ return mComposerCallback->takeLastVsyncPeriodChangeTimeline();
+}
+
+ScopedAStatus VtsComposerClient::setContentType(int64_t display, ContentType contentType) {
+ return mComposerClient->setContentType(display, contentType);
+}
+
+std::pair<ScopedAStatus, VsyncPeriodChangeTimeline>
+VtsComposerClient::setActiveConfigWithConstraints(VtsDisplay* vtsDisplay, int32_t config,
+ const VsyncPeriodChangeConstraints& constraints) {
+ VsyncPeriodChangeTimeline outTimeline;
+ auto status = mComposerClient->setActiveConfigWithConstraints(
+ vtsDisplay->getDisplayId(), config, constraints, &outTimeline);
+ if (!status.isOk()) {
+ return {std::move(status), outTimeline};
+ }
+ return {updateDisplayProperties(vtsDisplay, config), outTimeline};
+}
+
+std::pair<ScopedAStatus, std::vector<DisplayCapability>> VtsComposerClient::getDisplayCapabilities(
+ int64_t display) {
+ std::vector<DisplayCapability> outCapabilities;
+ return {mComposerClient->getDisplayCapabilities(display, &outCapabilities), outCapabilities};
+}
+
+ScopedAStatus VtsComposerClient::dumpDebugInfo() {
+ std::string debugInfo;
+ return mComposer->dumpDebugInfo(&debugInfo);
+}
+
+std::pair<ScopedAStatus, DisplayIdentification> VtsComposerClient::getDisplayIdentificationData(
+ int64_t display) {
+ DisplayIdentification outDisplayIdentification;
+ return {mComposerClient->getDisplayIdentificationData(display, &outDisplayIdentification),
+ outDisplayIdentification};
+}
+
+std::pair<ScopedAStatus, HdrCapabilities> VtsComposerClient::getHdrCapabilities(int64_t display) {
+ HdrCapabilities outHdrCapabilities;
+ return {mComposerClient->getHdrCapabilities(display, &outHdrCapabilities), outHdrCapabilities};
+}
+
+std::pair<ScopedAStatus, std::vector<PerFrameMetadataKey>>
+VtsComposerClient::getPerFrameMetadataKeys(int64_t display) {
+ std::vector<PerFrameMetadataKey> outPerFrameMetadataKeys;
+ return {mComposerClient->getPerFrameMetadataKeys(display, &outPerFrameMetadataKeys),
+ outPerFrameMetadataKeys};
+}
+
+std::pair<ScopedAStatus, ReadbackBufferAttributes> VtsComposerClient::getReadbackBufferAttributes(
+ int64_t display) {
+ ReadbackBufferAttributes outReadbackBufferAttributes;
+ return {mComposerClient->getReadbackBufferAttributes(display, &outReadbackBufferAttributes),
+ outReadbackBufferAttributes};
+}
+
+ScopedAStatus VtsComposerClient::setReadbackBuffer(int64_t display, const native_handle_t* buffer,
+ const ScopedFileDescriptor& releaseFence) {
+ return mComposerClient->setReadbackBuffer(display, ::android::dupToAidl(buffer), releaseFence);
+}
+
+std::pair<ScopedAStatus, ScopedFileDescriptor> VtsComposerClient::getReadbackBufferFence(
+ int64_t display) {
+ ScopedFileDescriptor outReleaseFence;
+ return {mComposerClient->getReadbackBufferFence(display, &outReleaseFence),
+ std::move(outReleaseFence)};
+}
+
+std::pair<ScopedAStatus, std::vector<ColorMode>> VtsComposerClient::getColorModes(int64_t display) {
+ std::vector<ColorMode> outColorModes;
+ return {mComposerClient->getColorModes(display, &outColorModes), outColorModes};
+}
+
+std::pair<ScopedAStatus, std::vector<RenderIntent>> VtsComposerClient::getRenderIntents(
+ int64_t display, ColorMode colorMode) {
+ std::vector<RenderIntent> outRenderIntents;
+ return {mComposerClient->getRenderIntents(display, colorMode, &outRenderIntents),
+ outRenderIntents};
+}
+
+ScopedAStatus VtsComposerClient::setColorMode(int64_t display, ColorMode colorMode,
+ RenderIntent renderIntent) {
+ return mComposerClient->setColorMode(display, colorMode, renderIntent);
+}
+
+std::pair<ScopedAStatus, DisplayContentSamplingAttributes>
+VtsComposerClient::getDisplayedContentSamplingAttributes(int64_t display) {
+ DisplayContentSamplingAttributes outAttributes;
+ return {mComposerClient->getDisplayedContentSamplingAttributes(display, &outAttributes),
+ outAttributes};
+}
+
+ScopedAStatus VtsComposerClient::setDisplayedContentSamplingEnabled(
+ int64_t display, bool isEnabled, FormatColorComponent formatColorComponent,
+ int64_t maxFrames) {
+ return mComposerClient->setDisplayedContentSamplingEnabled(display, isEnabled,
+ formatColorComponent, maxFrames);
+}
+
+std::pair<ScopedAStatus, DisplayContentSample> VtsComposerClient::getDisplayedContentSample(
+ int64_t display, int64_t maxFrames, int64_t timestamp) {
+ DisplayContentSample outDisplayContentSample;
+ return {mComposerClient->getDisplayedContentSample(display, maxFrames, timestamp,
+ &outDisplayContentSample),
+ outDisplayContentSample};
+}
+
+std::pair<ScopedAStatus, DisplayConnectionType> VtsComposerClient::getDisplayConnectionType(
+ int64_t display) {
+ DisplayConnectionType outDisplayConnectionType;
+ return {mComposerClient->getDisplayConnectionType(display, &outDisplayConnectionType),
+ outDisplayConnectionType};
+}
+
+std::pair<ScopedAStatus, std::vector<int32_t>> VtsComposerClient::getDisplayConfigs(
+ int64_t display) {
+ std::vector<int32_t> outConfigs;
+ return {mComposerClient->getDisplayConfigs(display, &outConfigs), outConfigs};
+}
+
+std::pair<ScopedAStatus, int32_t> VtsComposerClient::getDisplayVsyncPeriod(int64_t display) {
+ int32_t outVsyncPeriodNanos;
+ return {mComposerClient->getDisplayVsyncPeriod(display, &outVsyncPeriodNanos),
+ outVsyncPeriodNanos};
+}
+
+ScopedAStatus VtsComposerClient::setAutoLowLatencyMode(int64_t display, bool isEnabled) {
+ return mComposerClient->setAutoLowLatencyMode(display, isEnabled);
+}
+
+std::pair<ScopedAStatus, std::vector<ContentType>> VtsComposerClient::getSupportedContentTypes(
+ int64_t display) {
+ std::vector<ContentType> outContentTypes;
+ return {mComposerClient->getSupportedContentTypes(display, &outContentTypes), outContentTypes};
+}
+
+std::pair<ScopedAStatus, int32_t> VtsComposerClient::getMaxVirtualDisplayCount() {
+ int32_t outMaxVirtualDisplayCount;
+ return {mComposerClient->getMaxVirtualDisplayCount(&outMaxVirtualDisplayCount),
+ outMaxVirtualDisplayCount};
+}
+
+std::pair<ScopedAStatus, std::string> VtsComposerClient::getDisplayName(int64_t display) {
+ std::string outDisplayName;
+ return {mComposerClient->getDisplayName(display, &outDisplayName), outDisplayName};
+}
+
+ScopedAStatus VtsComposerClient::setClientTargetSlotCount(int64_t display,
+ int32_t bufferSlotCount) {
+ return mComposerClient->setClientTargetSlotCount(display, bufferSlotCount);
+}
+
+std::pair<ScopedAStatus, std::vector<Capability>> VtsComposerClient::getCapabilities() {
+ std::vector<Capability> outCapabilities;
+ return {mComposer->getCapabilities(&outCapabilities), outCapabilities};
+}
+
+ScopedAStatus VtsComposerClient::setBootDisplayConfig(int64_t display, int32_t config) {
+ return mComposerClient->setBootDisplayConfig(display, config);
+}
+
+ScopedAStatus VtsComposerClient::clearBootDisplayConfig(int64_t display) {
+ return mComposerClient->clearBootDisplayConfig(display);
+}
+
+std::pair<ScopedAStatus, int32_t> VtsComposerClient::getPreferredBootDisplayConfig(
+ int64_t display) {
+ int32_t outConfig;
+ return {mComposerClient->getPreferredBootDisplayConfig(display, &outConfig), outConfig};
+}
+
+std::pair<ScopedAStatus, common::Transform> VtsComposerClient::getDisplayPhysicalOrientation(
+ int64_t display) {
+ common::Transform outDisplayOrientation;
+ return {mComposerClient->getDisplayPhysicalOrientation(display, &outDisplayOrientation),
+ outDisplayOrientation};
+}
+
+ScopedAStatus VtsComposerClient::setIdleTimerEnabled(int64_t display, int32_t timeoutMs) {
+ return mComposerClient->setIdleTimerEnabled(display, timeoutMs);
+}
+
+int32_t VtsComposerClient::getVsyncIdleCount() {
+ return mComposerCallback->getVsyncIdleCount();
+}
+
+int64_t VtsComposerClient::getVsyncIdleTime() {
+ return mComposerCallback->getVsyncIdleTime();
+}
+
+int64_t VtsComposerClient::getInvalidDisplayId() {
+ // returns an invalid display id (one that has not been registered to a
+ // display. Currently assuming that a device will never have close to
+ // std::numeric_limit<uint64_t>::max() displays registered while running tests
+ int64_t id = std::numeric_limits<int64_t>::max();
+ std::vector<int64_t> displays = mComposerCallback->getDisplays();
+ while (id > 0) {
+ if (std::none_of(displays.begin(), displays.end(),
+ [id](const auto& display) { return id == display; })) {
+ return id;
+ }
+ id--;
+ }
+
+ // Although 0 could be an invalid display, a return value of 0
+ // from getInvalidDisplayId means all other ids are in use, a condition which
+ // we are assuming a device will never have
+ EXPECT_NE(0, id);
+ return id;
+}
+
+std::pair<ScopedAStatus, std::vector<VtsDisplay>> VtsComposerClient::getDisplays() {
+ while (true) {
+ // Sleep for a small period of time to allow all built-in displays
+ // to post hotplug events
+ std::this_thread::sleep_for(5ms);
+ std::vector<int64_t> displays = mComposerCallback->getDisplays();
+ if (displays.empty()) {
+ continue;
+ }
+
+ std::vector<VtsDisplay> vtsDisplays;
+ vtsDisplays.reserve(displays.size());
+ for (int64_t display : displays) {
+ auto vtsDisplay = VtsDisplay{display};
+ auto configs = getDisplayConfigs(display);
+ if (!configs.first.isOk()) {
+ ALOGE("Unable to get the displays for test, failed to get the configs "
+ "for display %" PRId64,
+ display);
+ return {std::move(configs.first), vtsDisplays};
+ }
+ for (int config : configs.second) {
+ auto status = updateDisplayProperties(&vtsDisplay, config);
+ if (!status.isOk()) {
+ ALOGE("Unable to get the displays for test, failed to update the properties "
+ "for display %" PRId64,
+ display);
+ return {std::move(status), vtsDisplays};
+ }
+ }
+ vtsDisplays.emplace_back(vtsDisplay);
+ addDisplayToDisplayResources(display, /*isVirtual*/ false);
+ }
+
+ return {ScopedAStatus::ok(), vtsDisplays};
+ }
+}
+
+ScopedAStatus VtsComposerClient::updateDisplayProperties(VtsDisplay* vtsDisplay, int32_t config) {
+ const auto width =
+ getDisplayAttribute(vtsDisplay->getDisplayId(), config, DisplayAttribute::WIDTH);
+ const auto height =
+ getDisplayAttribute(vtsDisplay->getDisplayId(), config, DisplayAttribute::HEIGHT);
+ const auto vsyncPeriod =
+ getDisplayAttribute(vtsDisplay->getDisplayId(), config, DisplayAttribute::VSYNC_PERIOD);
+ const auto configGroup =
+ getDisplayAttribute(vtsDisplay->getDisplayId(), config, DisplayAttribute::CONFIG_GROUP);
+ if (width.first.isOk() && height.first.isOk() && vsyncPeriod.first.isOk() &&
+ configGroup.first.isOk()) {
+ vtsDisplay->setDimensions(width.second, height.second);
+ vtsDisplay->addDisplayConfig(config, {vsyncPeriod.second, configGroup.second});
+ return ScopedAStatus::ok();
+ }
+
+ LOG(ERROR) << "Failed to update display property for width: " << width.first.isOk()
+ << ", height: " << height.first.isOk() << ", vsync: " << vsyncPeriod.first.isOk()
+ << ", config: " << configGroup.first.isOk();
+ return ScopedAStatus::fromServiceSpecificError(IComposerClient::EX_BAD_CONFIG);
+}
+
+ScopedAStatus VtsComposerClient::addDisplayToDisplayResources(int64_t display, bool isVirtual) {
+ if (mDisplayResources.insert({display, DisplayResource(isVirtual)}).second) {
+ return ScopedAStatus::ok();
+ }
+
+ ALOGE("Duplicate display id %" PRId64, display);
+ return ScopedAStatus::fromServiceSpecificError(IComposerClient::EX_BAD_DISPLAY);
+}
+
+ScopedAStatus VtsComposerClient::addLayerToDisplayResources(int64_t display, int64_t layer) {
+ auto resource = mDisplayResources.find(display);
+ if (resource == mDisplayResources.end()) {
+ resource = mDisplayResources.insert({display, DisplayResource(false)}).first;
+ }
+
+ if (!resource->second.layers.insert(layer).second) {
+ ALOGE("Duplicate layer id %" PRId64, layer);
+ return ScopedAStatus::fromServiceSpecificError(IComposerClient::EX_BAD_LAYER);
+ }
+ return ScopedAStatus::ok();
+}
+
+void VtsComposerClient::removeLayerFromDisplayResources(int64_t display, int64_t layer) {
+ auto resource = mDisplayResources.find(display);
+ if (resource != mDisplayResources.end()) {
+ resource->second.layers.erase(layer);
+ }
+}
+
+bool VtsComposerClient::verifyComposerCallbackParams() {
+ bool isValid = true;
+ if (mComposerCallback != nullptr) {
+ if (mComposerCallback->getInvalidHotplugCount() != 0) {
+ ALOGE("Invalid hotplug count");
+ isValid = false;
+ }
+ if (mComposerCallback->getInvalidRefreshCount() != 0) {
+ ALOGE("Invalid refresh count");
+ isValid = false;
+ }
+ if (mComposerCallback->getInvalidVsyncCount() != 0) {
+ ALOGE("Invalid vsync count");
+ isValid = false;
+ }
+ if (mComposerCallback->getInvalidVsyncPeriodChangeCount() != 0) {
+ ALOGE("Invalid vsync period change count");
+ isValid = false;
+ }
+ if (mComposerCallback->getInvalidSeamlessPossibleCount() != 0) {
+ ALOGE("Invalid seamless possible count");
+ isValid = false;
+ }
+ }
+ return isValid;
+}
+
+bool VtsComposerClient::destroyAllLayers() {
+ for (const auto& it : mDisplayResources) {
+ const auto& [display, resource] = it;
+
+ for (auto layer : resource.layers) {
+ const auto status = destroyLayer(display, layer);
+ if (!status.isOk()) {
+ ALOGE("Unable to destroy all the layers, failed at layer %" PRId64 " with error %s",
+ layer, status.getDescription().c_str());
+ return false;
+ }
+ }
+
+ if (resource.isVirtual) {
+ const auto status = destroyVirtualDisplay(display);
+ if (!status.isOk()) {
+ ALOGE("Unable to destroy the display %" PRId64 " failed with error %s", display,
+ status.getDescription().c_str());
+ return false;
+ }
+ }
+ }
+ mDisplayResources.clear();
+ return true;
+}
+} // namespace aidl::android::hardware::graphics::composer3::vts
\ No newline at end of file
diff --git a/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/composer-vts/include/GraphicsComposerCallback.h b/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/composer-vts/include/GraphicsComposerCallback.h
index f25f36d..ced1020 100644
--- a/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/composer-vts/include/GraphicsComposerCallback.h
+++ b/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/composer-vts/include/GraphicsComposerCallback.h
@@ -15,18 +15,11 @@
*/
#pragma once
-// TODO(b/129481165): remove the #pragma below and fix conversion issues
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wconversion"
-
#include <aidl/android/hardware/graphics/composer3/BnComposerCallback.h>
#include <android-base/thread_annotations.h>
#include <mutex>
#include <unordered_set>
-// TODO(b/129481165): remove the #pragma below and fix conversion issues
-#pragma clang diagnostic pop // ignored "-Wconversion
-
namespace aidl::android::hardware::graphics::composer3::vts {
class GraphicsComposerCallback : public BnComposerCallback {
diff --git a/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/composer-vts/include/ReadbackVts.h b/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/composer-vts/include/ReadbackVts.h
index a3ce795..7135dca 100644
--- a/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/composer-vts/include/ReadbackVts.h
+++ b/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/composer-vts/include/ReadbackVts.h
@@ -16,11 +16,6 @@
#pragma once
-// TODO(b/129481165): remove the #pragma below and fix conversion issues
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wconversion"
-
-#include <GraphicsComposerCallback.h>
#include <aidl/android/hardware/graphics/composer3/IComposerClient.h>
#include <android-base/unique_fd.h>
#include <android/hardware/graphics/composer3/ComposerClientReader.h>
@@ -28,11 +23,9 @@
#include <mapper-vts/2.1/MapperVts.h>
#include <renderengine/RenderEngine.h>
#include <ui/GraphicBuffer.h>
-
#include <memory>
-
-// TODO(b/129481165): remove the #pragma below and fix conversion issues
-#pragma clang diagnostic pop // ignored "-Wconversion
+#include "GraphicsComposerCallback.h"
+#include "VtsComposerClient.h"
namespace aidl::android::hardware::graphics::composer3::vts {
@@ -56,9 +49,11 @@
class TestLayer {
public:
- TestLayer(const std::shared_ptr<IComposerClient>& client, int64_t display)
- : mDisplay(display), mComposerClient(client) {
- client->createLayer(display, kBufferSlotCount, &mLayer);
+ TestLayer(const std::shared_ptr<VtsComposerClient>& client, int64_t display)
+ : mDisplay(display) {
+ const auto& [status, layer] = client->createLayer(display, kBufferSlotCount);
+ EXPECT_TRUE(status.isOk());
+ mLayer = layer;
}
// ComposerClient will take care of destroying layers, no need to explicitly
@@ -103,14 +98,11 @@
float mAlpha = 1.0;
BlendMode mBlendMode = BlendMode::NONE;
uint32_t mZOrder = 0;
-
- private:
- std::shared_ptr<IComposerClient> const mComposerClient;
};
class TestColorLayer : public TestLayer {
public:
- TestColorLayer(const std::shared_ptr<IComposerClient>& client, int64_t display)
+ TestColorLayer(const std::shared_ptr<VtsComposerClient>& client, int64_t display)
: TestLayer{client, display} {}
void write(ComposerClientWriter& writer) override;
@@ -125,7 +117,7 @@
class TestBufferLayer : public TestLayer {
public:
- TestBufferLayer(const std::shared_ptr<IComposerClient>& client,
+ TestBufferLayer(const std::shared_ptr<VtsComposerClient>& client,
const ::android::sp<::android::GraphicBuffer>& graphicBuffer,
TestRenderEngine& renderEngine, int64_t display, uint32_t width,
uint32_t height, common::PixelFormat format,
@@ -195,12 +187,12 @@
class ReadbackBuffer {
public:
- ReadbackBuffer(int64_t display, const std::shared_ptr<IComposerClient>& client, int32_t width,
+ ReadbackBuffer(int64_t display, const std::shared_ptr<VtsComposerClient>& client, int32_t width,
int32_t height, common::PixelFormat pixelFormat, common::Dataspace dataspace);
void setReadbackBuffer();
- void checkReadbackBuffer(std::vector<Color> expectedColors);
+ void checkReadbackBuffer(const std::vector<Color>& expectedColors);
::android::sp<::android::GraphicBuffer> allocate();
@@ -213,7 +205,7 @@
Dataspace mDataspace;
int64_t mDisplay;
::android::sp<::android::GraphicBuffer> mGraphicBuffer;
- std::shared_ptr<IComposerClient> mComposerClient;
+ std::shared_ptr<VtsComposerClient> mComposerClient;
::android::Rect mAccessRegion;
native_handle_t mBufferHandle;
};
diff --git a/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/composer-vts/include/RenderEngineVts.h b/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/composer-vts/include/RenderEngineVts.h
index a776a27..43d3a42 100644
--- a/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/composer-vts/include/RenderEngineVts.h
+++ b/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/composer-vts/include/RenderEngineVts.h
@@ -15,11 +15,6 @@
*/
#pragma once
-// TODO(b/129481165): remove the #pragma below and fix conversion issues
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wconversion"
-
-#include <ReadbackVts.h>
#include <mapper-vts/2.1/MapperVts.h>
#include <math/half.h>
#include <math/vec3.h>
@@ -30,9 +25,7 @@
#include <ui/PixelFormat.h>
#include <ui/Rect.h>
#include <ui/Region.h>
-
-// TODO(b/129481165): remove the #pragma below and fix conversion issues
-#pragma clang diagnostic pop // ignored "-Wconversion
+#include "ReadbackVts.h"
namespace aidl::android::hardware::graphics::composer3::vts {
diff --git a/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/composer-vts/include/VtsComposerClient.h b/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/composer-vts/include/VtsComposerClient.h
new file mode 100644
index 0000000..b53edf8
--- /dev/null
+++ b/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/composer-vts/include/VtsComposerClient.h
@@ -0,0 +1,240 @@
+/**
+ * Copyright (c) 2022, 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.
+ */
+#pragma once
+
+#include <aidl/android/hardware/graphics/common/BlendMode.h>
+#include <aidl/android/hardware/graphics/common/BufferUsage.h>
+#include <aidl/android/hardware/graphics/common/FRect.h>
+#include <aidl/android/hardware/graphics/common/Rect.h>
+#include <aidl/android/hardware/graphics/composer3/Composition.h>
+#include <aidl/android/hardware/graphics/composer3/IComposer.h>
+#include <android-base/properties.h>
+#include <android/binder_manager.h>
+#include <android/binder_process.h>
+#include <android/hardware/graphics/composer3/ComposerClientReader.h>
+#include <binder/ProcessState.h>
+#include <gtest/gtest.h>
+#include <ui/Fence.h>
+#include <ui/GraphicBuffer.h>
+#include <ui/PixelFormat.h>
+#include <algorithm>
+#include <numeric>
+#include <string>
+#include <thread>
+#include <unordered_map>
+#include "GraphicsComposerCallback.h"
+
+using aidl::android::hardware::graphics::common::Dataspace;
+using aidl::android::hardware::graphics::common::FRect;
+using aidl::android::hardware::graphics::common::PixelFormat;
+using aidl::android::hardware::graphics::common::Rect;
+using namespace ::ndk;
+
+namespace aidl::android::hardware::graphics::composer3::vts {
+
+class VtsDisplay;
+/**
+ * A wrapper to IComposerClient.
+ * This wrapper manages the IComposerClient instance and manages the resources for
+ * the tests with respect to the IComposerClient calls.
+ */
+class VtsComposerClient {
+ public:
+ VtsComposerClient(const std::string& name);
+
+ ScopedAStatus createClient();
+
+ bool tearDown();
+
+ std::pair<ScopedAStatus, VirtualDisplay> createVirtualDisplay(int32_t width, int32_t height,
+ PixelFormat pixelFormat,
+ int32_t bufferSlotCount);
+
+ ScopedAStatus destroyVirtualDisplay(int64_t display);
+
+ std::pair<ScopedAStatus, int64_t> createLayer(int64_t display, int32_t bufferSlotCount);
+
+ ScopedAStatus destroyLayer(int64_t display, int64_t layer);
+
+ std::pair<ScopedAStatus, int32_t> getActiveConfig(int64_t display);
+
+ ScopedAStatus setActiveConfig(VtsDisplay* vtsDisplay, int32_t config);
+
+ std::pair<ScopedAStatus, int32_t> getDisplayAttribute(int64_t display, int32_t config,
+ DisplayAttribute displayAttribute);
+
+ ScopedAStatus setPowerMode(int64_t display, PowerMode powerMode);
+
+ ScopedAStatus setVsync(int64_t display, bool enable);
+
+ void setVsyncAllowed(bool isAllowed);
+
+ std::pair<ScopedAStatus, std::vector<float>> getDataspaceSaturationMatrix(Dataspace dataspace);
+
+ std::pair<ScopedAStatus, std::vector<CommandResultPayload>> executeCommands(
+ const std::vector<DisplayCommand>& commands);
+
+ std::optional<VsyncPeriodChangeTimeline> takeLastVsyncPeriodChangeTimeline();
+
+ ScopedAStatus setContentType(int64_t display, ContentType contentType);
+
+ std::pair<ScopedAStatus, VsyncPeriodChangeTimeline> setActiveConfigWithConstraints(
+ VtsDisplay* vtsDisplay, int32_t config,
+ const VsyncPeriodChangeConstraints& constraints);
+
+ std::pair<ScopedAStatus, std::vector<DisplayCapability>> getDisplayCapabilities(
+ int64_t display);
+
+ ScopedAStatus dumpDebugInfo();
+
+ std::pair<ScopedAStatus, DisplayIdentification> getDisplayIdentificationData(int64_t display);
+
+ std::pair<ScopedAStatus, HdrCapabilities> getHdrCapabilities(int64_t display);
+
+ std::pair<ScopedAStatus, std::vector<PerFrameMetadataKey>> getPerFrameMetadataKeys(
+ int64_t display);
+
+ std::pair<ScopedAStatus, ReadbackBufferAttributes> getReadbackBufferAttributes(int64_t display);
+
+ ScopedAStatus setReadbackBuffer(int64_t display, const native_handle_t* buffer,
+ const ScopedFileDescriptor& releaseFence);
+
+ std::pair<ScopedAStatus, ScopedFileDescriptor> getReadbackBufferFence(int64_t display);
+
+ std::pair<ScopedAStatus, std::vector<ColorMode>> getColorModes(int64_t display);
+
+ std::pair<ScopedAStatus, std::vector<RenderIntent>> getRenderIntents(int64_t display,
+ ColorMode colorMode);
+
+ ScopedAStatus setColorMode(int64_t display, ColorMode colorMode, RenderIntent renderIntent);
+
+ std::pair<ScopedAStatus, DisplayContentSamplingAttributes>
+ getDisplayedContentSamplingAttributes(int64_t display);
+
+ ScopedAStatus setDisplayedContentSamplingEnabled(int64_t display, bool isEnabled,
+ FormatColorComponent formatColorComponent,
+ int64_t maxFrames);
+
+ std::pair<ScopedAStatus, DisplayContentSample> getDisplayedContentSample(int64_t display,
+ int64_t maxFrames,
+ int64_t timestamp);
+
+ std::pair<ScopedAStatus, DisplayConnectionType> getDisplayConnectionType(int64_t display);
+
+ std::pair<ScopedAStatus, std::vector<int32_t>> getDisplayConfigs(int64_t display);
+
+ std::pair<ScopedAStatus, int32_t> getDisplayVsyncPeriod(int64_t display);
+
+ ScopedAStatus setAutoLowLatencyMode(int64_t display, bool isEnabled);
+
+ std::pair<ScopedAStatus, std::vector<ContentType>> getSupportedContentTypes(int64_t display);
+
+ std::pair<ScopedAStatus, int32_t> getMaxVirtualDisplayCount();
+
+ std::pair<ScopedAStatus, std::string> getDisplayName(int64_t display);
+
+ ScopedAStatus setClientTargetSlotCount(int64_t display, int32_t bufferSlotCount);
+
+ std::pair<ScopedAStatus, std::vector<Capability>> getCapabilities();
+
+ ScopedAStatus setBootDisplayConfig(int64_t display, int32_t config);
+
+ ScopedAStatus clearBootDisplayConfig(int64_t display);
+
+ std::pair<ScopedAStatus, int32_t> getPreferredBootDisplayConfig(int64_t display);
+
+ std::pair<ScopedAStatus, common::Transform> getDisplayPhysicalOrientation(int64_t display);
+
+ ScopedAStatus setIdleTimerEnabled(int64_t display, int32_t timeoutMs);
+
+ int32_t getVsyncIdleCount();
+
+ int64_t getVsyncIdleTime();
+
+ int64_t getInvalidDisplayId();
+
+ std::pair<ScopedAStatus, std::vector<VtsDisplay>> getDisplays();
+
+ private:
+ ScopedAStatus updateDisplayProperties(VtsDisplay* vtsDisplay, int32_t config);
+
+ ScopedAStatus addDisplayToDisplayResources(int64_t display, bool isVirtual);
+
+ ScopedAStatus addLayerToDisplayResources(int64_t display, int64_t layer);
+
+ void removeLayerFromDisplayResources(int64_t display, int64_t layer);
+
+ bool destroyAllLayers();
+
+ bool verifyComposerCallbackParams();
+
+ // Keep track of displays and layers. When a test fails/ends,
+ // the VtsComposerClient::tearDown should be called from the
+ // test tearDown to clean up the resources for the test.
+ struct DisplayResource {
+ DisplayResource(bool isVirtual_) : isVirtual(isVirtual_) {}
+
+ bool isVirtual;
+ std::unordered_set<int64_t> layers;
+ };
+
+ std::shared_ptr<IComposer> mComposer;
+ std::shared_ptr<IComposerClient> mComposerClient;
+ std::shared_ptr<GraphicsComposerCallback> mComposerCallback;
+ std::unordered_map<int64_t, DisplayResource> mDisplayResources;
+};
+
+class VtsDisplay {
+ public:
+ VtsDisplay(int64_t displayId) : mDisplayId(displayId) {}
+
+ int64_t getDisplayId() const { return mDisplayId; }
+
+ FRect getCrop() const {
+ return {0, 0, static_cast<float>(mDisplayWidth), static_cast<float>(mDisplayHeight)};
+ }
+
+ Rect getFrameRect() const { return {0, 0, mDisplayWidth, mDisplayHeight}; }
+
+ void setDimensions(int32_t displayWidth, int32_t displayHeight) {
+ mDisplayWidth = displayWidth;
+ mDisplayHeight = displayHeight;
+ }
+
+ int32_t getDisplayWidth() const { return mDisplayWidth; }
+
+ int32_t getDisplayHeight() const { return mDisplayHeight; }
+
+ struct DisplayConfig {
+ DisplayConfig(int32_t vsyncPeriod_, int32_t configGroup_)
+ : vsyncPeriod(vsyncPeriod_), configGroup(configGroup_) {}
+ int32_t vsyncPeriod;
+ int32_t configGroup;
+ };
+
+ void addDisplayConfig(int32_t config, DisplayConfig displayConfig) {
+ displayConfigs.insert({config, displayConfig});
+ }
+
+ DisplayConfig getDisplayConfig(int32_t config) { return displayConfigs.find(config)->second; }
+
+ private:
+ int64_t mDisplayId;
+ int32_t mDisplayWidth;
+ int32_t mDisplayHeight;
+ std::unordered_map<int32_t, DisplayConfig> displayConfigs;
+};
+} // namespace aidl::android::hardware::graphics::composer3::vts
\ No newline at end of file
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 d429b76..02405ba 100644
--- a/graphics/composer/aidl/include/android/hardware/graphics/composer3/ComposerClientWriter.h
+++ b/graphics/composer/aidl/include/android/hardware/graphics/composer3/ComposerClientWriter.h
@@ -194,7 +194,7 @@
void setLayerZOrder(int64_t display, int64_t layer, uint32_t z) {
ZOrder zorder;
- zorder.z = z;
+ zorder.z = static_cast<int32_t>(z);
getLayerCommand(display, layer).z.emplace(std::move(zorder));
}
@@ -233,9 +233,9 @@
std::optional<LayerCommand> mLayerCommand;
std::vector<DisplayCommand> mCommands;
- Buffer getBuffer(int slot, const native_handle_t* bufferHandle, int fence) {
+ Buffer getBuffer(uint32_t slot, const native_handle_t* bufferHandle, int fence) {
Buffer bufferCommand;
- bufferCommand.slot = slot;
+ bufferCommand.slot = static_cast<int32_t>(slot);
if (bufferHandle) bufferCommand.handle.emplace(::android::dupToAidl(bufferHandle));
if (fence > 0) bufferCommand.fence = ::ndk::ScopedFileDescriptor(fence);
return bufferCommand;
diff --git a/security/keymint/aidl/android/hardware/security/keymint/DeviceInfo.aidl b/security/keymint/aidl/android/hardware/security/keymint/DeviceInfo.aidl
index 153a04f..abb2a7b 100644
--- a/security/keymint/aidl/android/hardware/security/keymint/DeviceInfo.aidl
+++ b/security/keymint/aidl/android/hardware/security/keymint/DeviceInfo.aidl
@@ -40,7 +40,9 @@
* "vb_state" : "green" / "yellow" / "orange", // Taken from the AVB values
* "bootloader_state" : "locked" / "unlocked", // Taken from the AVB values
* "vbmeta_digest": bstr, // Taken from the AVB values
- * "os_version" : tstr, // Same as android.os.Build.VERSION.release
+ * ? "os_version" : tstr, // Same as
+ * // android.os.Build.VERSION.release
+ * // Not optional for TEE.
* "system_patch_level" : uint, // YYYYMMDD
* "boot_patch_level" : uint, // YYYYMMDD
* "vendor_patch_level" : uint, // YYYYMMDD
diff --git a/security/keymint/aidl/vts/functional/VtsRemotelyProvisionedComponentTests.cpp b/security/keymint/aidl/vts/functional/VtsRemotelyProvisionedComponentTests.cpp
index 927d7d7..e2d75ce 100644
--- a/security/keymint/aidl/vts/functional/VtsRemotelyProvisionedComponentTests.cpp
+++ b/security/keymint/aidl/vts/functional/VtsRemotelyProvisionedComponentTests.cpp
@@ -492,7 +492,6 @@
ASSERT_NE(allowList.find(deviceInfo->get("bootloader_state")->asTstr()->value()),
allowList.end());
checkType(deviceInfo, cppbor::BSTR, "vbmeta_digest");
- checkType(deviceInfo, cppbor::TSTR, "os_version");
checkType(deviceInfo, cppbor::UINT, "system_patch_level");
checkType(deviceInfo, cppbor::UINT, "boot_patch_level");
checkType(deviceInfo, cppbor::UINT, "vendor_patch_level");
@@ -502,6 +501,9 @@
allowList = getAllowedSecurityLevels();
ASSERT_NE(allowList.find(deviceInfo->get("security_level")->asTstr()->value()),
allowList.end());
+ if (deviceInfo->get("security_level")->asTstr()->value() == "tee") {
+ checkType(deviceInfo, cppbor::TSTR, "os_version");
+ }
break;
case 1:
checkType(deviceInfo, cppbor::TSTR, "security_level");
diff --git a/uwb/aidl/aidl_api/android.hardware.uwb.fira_android/current/android/hardware/uwb/fira_android/UwbVendorCapabilityTlvTypes.aidl b/uwb/aidl/aidl_api/android.hardware.uwb.fira_android/current/android/hardware/uwb/fira_android/UwbVendorCapabilityTlvTypes.aidl
index fec044e..cbe2068 100644
--- a/uwb/aidl/aidl_api/android.hardware.uwb.fira_android/current/android/hardware/uwb/fira_android/UwbVendorCapabilityTlvTypes.aidl
+++ b/uwb/aidl/aidl_api/android.hardware.uwb.fira_android/current/android/hardware/uwb/fira_android/UwbVendorCapabilityTlvTypes.aidl
@@ -35,14 +35,13 @@
@Backing(type="int") @VintfStability
enum UwbVendorCapabilityTlvTypes {
SUPPORTED_POWER_STATS_QUERY = 192,
- CCC_SUPPORTED_VERSIONS = 160,
- CCC_SUPPORTED_UWB_CONFIGS = 161,
- CCC_SUPPORTED_PULSE_SHAPE_COMBOS = 162,
- CCC_SUPPORTED_RAN_MULTIPLIER = 163,
- CCC_SUPPORTED_CHAPS_PER_SLOT = 164,
- CCC_SUPPORTED_SYNC_CODES = 165,
- CCC_SUPPORTED_CHANNELS = 166,
- CCC_SUPPORTED_HOPPING_SEQUENCES = 167,
- CCC_SUPPORTED_HOPPING_CONFIG_MODES = 168,
+ CCC_SUPPORTED_CHAPS_PER_SLOT = 160,
+ CCC_SUPPORTED_SYNC_CODES = 161,
+ CCC_SUPPORTED_HOPPING_CONFIG_MODES_AND_SEQUENCES = 162,
+ CCC_SUPPORTED_CHANNELS = 163,
+ CCC_SUPPORTED_VERSIONS = 164,
+ CCC_SUPPORTED_UWB_CONFIGS = 165,
+ CCC_SUPPORTED_PULSE_SHAPE_COMBOS = 166,
+ CCC_SUPPORTED_RAN_MULTIPLIER = 167,
SUPPORTED_AOA_RESULT_REQ_ANTENNA_INTERLEAVING = 227,
}
diff --git a/uwb/aidl/aidl_api/android.hardware.uwb.fira_android/current/android/hardware/uwb/fira_android/UwbVendorCapabilityTlvValues.aidl b/uwb/aidl/aidl_api/android.hardware.uwb.fira_android/current/android/hardware/uwb/fira_android/UwbVendorCapabilityTlvValues.aidl
index ee47a13..0e33f70 100644
--- a/uwb/aidl/aidl_api/android.hardware.uwb.fira_android/current/android/hardware/uwb/fira_android/UwbVendorCapabilityTlvValues.aidl
+++ b/uwb/aidl/aidl_api/android.hardware.uwb.fira_android/current/android/hardware/uwb/fira_android/UwbVendorCapabilityTlvValues.aidl
@@ -36,19 +36,21 @@
enum UwbVendorCapabilityTlvValues {
UWB_CONFIG_0 = 0,
UWB_CONFIG_1 = 1,
- PULSE_SHAPE_SYMMETRICAL_ROOT_RAISED_COSINE = 1,
- PULSE_SHAPE_PRECURSOR_FREE = 2,
- PULSE_SHAPE_PRECURSOR_FREE_SPECIAL = 3,
- CHAPS_PER_SLOT_3 = 3,
- CHAPS_PER_SLOT_4 = 4,
- CHAPS_PER_SLOT_6 = 6,
+ PULSE_SHAPE_SYMMETRICAL_ROOT_RAISED_COSINE = 0,
+ PULSE_SHAPE_PRECURSOR_FREE = 1,
+ PULSE_SHAPE_PRECURSOR_FREE_SPECIAL = 2,
+ CHAPS_PER_SLOT_3 = 1,
+ CHAPS_PER_SLOT_4 = 2,
+ CHAPS_PER_SLOT_6 = 4,
CHAPS_PER_SLOT_8 = 8,
- CHAPS_PER_SLOT_9 = 9,
- CHAPS_PER_SLOT_12 = 12,
- CHAPS_PER_SLOT_24 = 24,
- HOPPING_SEQUENCE_DEFAULT = 0,
- HOPPING_SEQUENCE_AES = 1,
- HOPPING_CONFIG_MODE_NONE = 0,
- HOPPING_CONFIG_MODE_CONTINUOUS = 1,
- HOPPING_CONFIG_MODE_ADAPTIVE = 2,
+ CHAPS_PER_SLOT_9 = 16,
+ CHAPS_PER_SLOT_12 = 32,
+ CHAPS_PER_SLOT_24 = 64,
+ HOPPING_SEQUENCE_DEFAULT = 16,
+ HOPPING_SEQUENCE_AES = 8,
+ HOPPING_CONFIG_MODE_NONE = 128,
+ HOPPING_CONFIG_MODE_CONTINUOUS = 64,
+ HOPPING_CONFIG_MODE_ADAPTIVE = 32,
+ CCC_CHANNEL_5 = 1,
+ CCC_CHANNEL_9 = 2,
}
diff --git a/uwb/aidl/android/hardware/uwb/fira_android/UwbVendorCapabilityTlvTypes.aidl b/uwb/aidl/android/hardware/uwb/fira_android/UwbVendorCapabilityTlvTypes.aidl
index 4591dda..97f8010 100644
--- a/uwb/aidl/android/hardware/uwb/fira_android/UwbVendorCapabilityTlvTypes.aidl
+++ b/uwb/aidl/android/hardware/uwb/fira_android/UwbVendorCapabilityTlvTypes.aidl
@@ -46,17 +46,85 @@
********************************************/
/**
+ * 1 byte bitmask with a list of supported chaps per slot
+ * Bitmap of supported values of Slot durations as a multiple of TChap,
+ * NChap_per_Slot as defined in CCC Specification.
+ * Each “1” in this bit map corresponds to a specific
+ * value of NChap_per_Slot where:
+ * 0x01 = “3”,
+ * 0x02 = “4”,
+ * 0x04= “6”,
+ * 0x08 =“8”,
+ * 0x10 =“9”,
+ * 0x20 = “12”,
+ * 0x40 = “24”,
+ * 0x80 is reserved.
+ */
+ CCC_SUPPORTED_CHAPS_PER_SLOT = 0xA0,
+
+ /**
+ * 4 byte bitmask with a list of supported sync codes
+ * Bitmap of SYNC code indices that can be used.
+ * The position of each “1” in this bit pattern
+ * corresponds to the index of a SYNC code that
+ * can be used, where:
+ * 0x00000001 = “1”,
+ * 0x00000002 = “2”,
+ * 0x00000004 = “3”,
+ * 0x00000008 = “4”,
+ * ….
+ * 0x40000000 = “31”,
+ * 0x80000000 = “32”
+ * Refer to IEEE 802.15.4-2015 and CCC
+ * Specification for SYNC code index definition
+ */
+ CCC_SUPPORTED_SYNC_CODES = 0xA1,
+
+ /**
+ * 1 byte bitmask with a list of supported hopping config modes and sequences.
+ * [b7 b6 b5] : bitmask of hopping modes the
+ * device offers to use in the ranging session
+ * 100 - No Hopping
+ * 010 - Continuous Hopping
+ * 001 - Adaptive Hopping
+ * [b4 b3 b2 b1 b0] : bit mask of hopping
+ * sequences the device offers to use in the
+ * ranging session
+ * b4=1 is always set because of the default
+ * hopping sequence. Support for it is mandatory.
+ * b3=1 is set when the optional AES based
+ * hopping sequence is supported.
+ */
+ CCC_SUPPORTED_HOPPING_CONFIG_MODES_AND_SEQUENCES = 0xA2,
+
+ /**
+ * 1 byte bitmask with list of supported channels
+ * Bitmap of supported UWB channels. Each “1” in
+ * this bit map corresponds to a specific value of
+ * UWB channel where:
+ * 0x01 = "Channel 5"
+ * 0x02 = "Channel 9"
+ */
+ CCC_SUPPORTED_CHANNELS = 0xA3,
+
+ /**
* 2 byte tuple {major_version (1 byte), minor_version (1 byte)} array with list of supported
* CCC versions
*/
- CCC_SUPPORTED_VERSIONS = 0xA0,
+ CCC_SUPPORTED_VERSIONS = 0xA4,
+
/**
* byte array with a list of supported UWB configs
- * Values:
- * UWB_CONFIG_0 = 0
- * UWB_CONFIG_1 = 1
+ *
+ * UWB configurations are define in chapter
+ * "21.4 UWB Frame Elements" of the CCC
+ * specification. Configuration 0x0000 is
+ * mandatory for device and vehicle, configuration
+ * 0x0001 is mandatory for the device, optional for
+ * the vehicle.
*/
- CCC_SUPPORTED_UWB_CONFIGS = 0xA1,
+ CCC_SUPPORTED_UWB_CONFIGS = 0xA5,
+
/**
* 1 byte tuple {initiator_tx (4 bits), responder_tx (4 bits)} array with list of supported
* pulse shape combos
@@ -66,43 +134,10 @@
* PULSE_SHAPE_PRECURSOR_FREE_SPECIAL = 3
*/
/** */
- CCC_SUPPORTED_PULSE_SHAPE_COMBOS = 0xA2,
+ CCC_SUPPORTED_PULSE_SHAPE_COMBOS = 0xA6,
+
/** Int value for indicating supported ran multiplier */
- CCC_SUPPORTED_RAN_MULTIPLIER = 0xA3,
- /**
- * byte array with a list of supported chaps per slot
- * Values:
- * CHAPS_PER_SLOT_3 = 3
- * CHAPS_PER_SLOT_4 = 4
- * CHAPS_PER_SLOT_6 = 6
- * CHAPS_PER_SLOT_8 = 8
- * CHAPS_PER_SLOT_9 = 9
- * CHAPS_PER_SLOT_12 = 12
- * CHAPS_PER_SLOT_24 = 24
- */
- CCC_SUPPORTED_CHAPS_PER_SLOT = 0xA4,
- /**
- * byte array with a list of supported sync codes
- * Values: 1 - 32
- */
- CCC_SUPPORTED_SYNC_CODES = 0xA5,
- /** byte array with list of supported channels */
- CCC_SUPPORTED_CHANNELS = 0xA6,
- /**
- * byte array with a list of supported hopping sequences
- * Values:
- HOPPING_SEQUENCE_DEFAULT = 0
- HOPPING_SEQUENCE_AES = 1
- */
- CCC_SUPPORTED_HOPPING_SEQUENCES = 0xA7,
- /**
- * byte array with a list of supported hopping config modes
- * Values:
- * HOPPING_CONFIG_MODE_NONE = 0
- * HOPPING_CONFIG_MODE_CONTINUOUS = 1
- * HOPPING_CONFIG_MODE_ADAPTIVE = 2
- */
- CCC_SUPPORTED_HOPPING_CONFIG_MODES = 0xA8,
+ CCC_SUPPORTED_RAN_MULTIPLIER = 0xA7,
/*********************************************
* FIRA specific
diff --git a/uwb/aidl/android/hardware/uwb/fira_android/UwbVendorCapabilityTlvValues.aidl b/uwb/aidl/android/hardware/uwb/fira_android/UwbVendorCapabilityTlvValues.aidl
index 380089f..7c86b79 100644
--- a/uwb/aidl/android/hardware/uwb/fira_android/UwbVendorCapabilityTlvValues.aidl
+++ b/uwb/aidl/android/hardware/uwb/fira_android/UwbVendorCapabilityTlvValues.aidl
@@ -30,22 +30,25 @@
UWB_CONFIG_0 = 0,
UWB_CONFIG_1 = 1,
- PULSE_SHAPE_SYMMETRICAL_ROOT_RAISED_COSINE = 1,
- PULSE_SHAPE_PRECURSOR_FREE = 2,
- PULSE_SHAPE_PRECURSOR_FREE_SPECIAL = 3,
+ PULSE_SHAPE_SYMMETRICAL_ROOT_RAISED_COSINE = 0,
+ PULSE_SHAPE_PRECURSOR_FREE = 1,
+ PULSE_SHAPE_PRECURSOR_FREE_SPECIAL = 2,
- CHAPS_PER_SLOT_3 = 3,
- CHAPS_PER_SLOT_4 = 4,
- CHAPS_PER_SLOT_6 = 6,
- CHAPS_PER_SLOT_8 = 8,
- CHAPS_PER_SLOT_9 = 9,
- CHAPS_PER_SLOT_12 = 12,
- CHAPS_PER_SLOT_24 = 24,
+ CHAPS_PER_SLOT_3 = 1,
+ CHAPS_PER_SLOT_4 = 1 << 1,
+ CHAPS_PER_SLOT_6 = 1 << 2,
+ CHAPS_PER_SLOT_8 = 1 << 3,
+ CHAPS_PER_SLOT_9 = 1 << 4,
+ CHAPS_PER_SLOT_12 = 1 << 5,
+ CHAPS_PER_SLOT_24 = 1 << 6,
- HOPPING_SEQUENCE_DEFAULT = 0,
- HOPPING_SEQUENCE_AES = 1,
+ HOPPING_SEQUENCE_DEFAULT = 1 << 4,
+ HOPPING_SEQUENCE_AES = 1 << 3,
- HOPPING_CONFIG_MODE_NONE = 0,
- HOPPING_CONFIG_MODE_CONTINUOUS = 1,
- HOPPING_CONFIG_MODE_ADAPTIVE = 2,
+ HOPPING_CONFIG_MODE_NONE = 1 << 7,
+ HOPPING_CONFIG_MODE_CONTINUOUS = 1 << 6,
+ HOPPING_CONFIG_MODE_ADAPTIVE = 1 << 5,
+
+ CCC_CHANNEL_5 = 1,
+ CCC_CHANNEL_9 = 1 << 1,
}
diff --git a/wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/ApInfo.aidl b/wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/ApInfo.aidl
index bdbaadd..ca20f37 100644
--- a/wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/ApInfo.aidl
+++ b/wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/ApInfo.aidl
@@ -37,7 +37,7 @@
String ifaceName;
String apIfaceInstance;
int freqMhz;
- android.hardware.wifi.hostapd.Bandwidth bandwidth;
+ android.hardware.wifi.hostapd.ChannelBandwidth channelBandwidth;
android.hardware.wifi.hostapd.Generation generation;
byte[] apIfaceInstanceMacAddress;
}
diff --git a/wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/Bandwidth.aidl b/wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/ChannelBandwidth.aidl
similarity index 86%
rename from wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/Bandwidth.aidl
rename to wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/ChannelBandwidth.aidl
index 4d78640..6c1fd22 100644
--- a/wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/Bandwidth.aidl
+++ b/wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/ChannelBandwidth.aidl
@@ -33,17 +33,18 @@
package android.hardware.wifi.hostapd;
@Backing(type="int") @VintfStability
-enum Bandwidth {
+enum ChannelBandwidth {
BANDWIDTH_INVALID = 0,
- BANDWIDTH_20_NOHT = 1,
- BANDWIDTH_20 = 2,
- BANDWIDTH_40 = 3,
- BANDWIDTH_80 = 4,
- BANDWIDTH_80P80 = 5,
- BANDWIDTH_160 = 6,
- BANDWIDTH_320 = 7,
- BANDWIDTH_2160 = 8,
- BANDWIDTH_4320 = 9,
- BANDWIDTH_6480 = 10,
- BANDWIDTH_8640 = 11,
+ BANDWIDTH_AUTO = 1,
+ BANDWIDTH_20_NOHT = 2,
+ BANDWIDTH_20 = 3,
+ BANDWIDTH_40 = 4,
+ BANDWIDTH_80 = 5,
+ BANDWIDTH_80P80 = 6,
+ BANDWIDTH_160 = 7,
+ BANDWIDTH_320 = 8,
+ BANDWIDTH_2160 = 9,
+ BANDWIDTH_4320 = 10,
+ BANDWIDTH_6480 = 11,
+ BANDWIDTH_8640 = 12,
}
diff --git a/wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/HwModeParams.aidl b/wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/HwModeParams.aidl
index 8d8d7bb..d732bcb 100644
--- a/wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/HwModeParams.aidl
+++ b/wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/HwModeParams.aidl
@@ -44,4 +44,5 @@
boolean enableHeTargetWakeTime;
boolean enableEdmg;
boolean enable80211BE;
+ android.hardware.wifi.hostapd.ChannelBandwidth maximumChannelBandwidth;
}
diff --git a/wifi/hostapd/aidl/android/hardware/wifi/hostapd/ApInfo.aidl b/wifi/hostapd/aidl/android/hardware/wifi/hostapd/ApInfo.aidl
index bf506b2..a6fe63b 100644
--- a/wifi/hostapd/aidl/android/hardware/wifi/hostapd/ApInfo.aidl
+++ b/wifi/hostapd/aidl/android/hardware/wifi/hostapd/ApInfo.aidl
@@ -16,7 +16,7 @@
package android.hardware.wifi.hostapd;
-import android.hardware.wifi.hostapd.Bandwidth;
+import android.hardware.wifi.hostapd.ChannelBandwidth;
import android.hardware.wifi.hostapd.Generation;
/**
@@ -44,9 +44,9 @@
int freqMhz;
/**
- * The operational bandwidth of the AP.
+ * The operational channel bandwidth of the AP.
*/
- Bandwidth bandwidth;
+ ChannelBandwidth channelBandwidth;
/**
* The operational mode of the AP (e.g. 11ac, 11ax).
diff --git a/wifi/hostapd/aidl/android/hardware/wifi/hostapd/Bandwidth.aidl b/wifi/hostapd/aidl/android/hardware/wifi/hostapd/Bandwidth.aidl
deleted file mode 100644
index e605153..0000000
--- a/wifi/hostapd/aidl/android/hardware/wifi/hostapd/Bandwidth.aidl
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright (C) 2021 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package android.hardware.wifi.hostapd;
-
-/**
- * The channel bandwidth of the AP.
- */
-@VintfStability
-@Backing(type="int")
-enum Bandwidth {
- BANDWIDTH_INVALID = 0,
- BANDWIDTH_20_NOHT = 1,
- BANDWIDTH_20 = 2,
- BANDWIDTH_40 = 3,
- BANDWIDTH_80 = 4,
- BANDWIDTH_80P80 = 5,
- BANDWIDTH_160 = 6,
- BANDWIDTH_320 = 7,
- BANDWIDTH_2160 = 8,
- BANDWIDTH_4320 = 9,
- BANDWIDTH_6480 = 10,
- BANDWIDTH_8640 = 11,
-}
diff --git a/wifi/hostapd/aidl/android/hardware/wifi/hostapd/ChannelBandwidth.aidl b/wifi/hostapd/aidl/android/hardware/wifi/hostapd/ChannelBandwidth.aidl
new file mode 100644
index 0000000..8ea3952
--- /dev/null
+++ b/wifi/hostapd/aidl/android/hardware/wifi/hostapd/ChannelBandwidth.aidl
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.hardware.wifi.hostapd;
+
+/**
+ * The channel bandwidth of the AP.
+ */
+@VintfStability
+@Backing(type="int")
+enum ChannelBandwidth {
+ /**
+ * Invalid bandwidth value for AP
+ */
+ BANDWIDTH_INVALID = 0,
+ /**
+ * Channel bandwidth is auto-selected by the chip
+ */
+ BANDWIDTH_AUTO = 1,
+ /**
+ * AP channel bandwidth is 20 MHz but not HT
+ */
+ BANDWIDTH_20_NOHT = 2,
+ /**
+ * AP channel bandwidth is 20 MHz
+ */
+ BANDWIDTH_20 = 3,
+ /**
+ * AP channel bandwidth is 40 MHz
+ */
+ BANDWIDTH_40 = 4,
+ /**
+ * AP channel bandwidth is 80 MHz
+ */
+ BANDWIDTH_80 = 5,
+ /**
+ * AP channel bandwidth is 80+80 MHz
+ */
+ BANDWIDTH_80P80 = 6,
+ /**
+ * AP channel bandwidth is 160 MHz
+ */
+ BANDWIDTH_160 = 7,
+ /**
+ * AP channel bandwidth is 320 MHz
+ */
+ BANDWIDTH_320 = 8,
+ /**
+ * AP channel bandwidth is 2160 MHz
+ */
+ BANDWIDTH_2160 = 9,
+ /**
+ * AP channel bandwidth is 4320 MHz
+ */
+ BANDWIDTH_4320 = 10,
+ /**
+ * AP channel bandwidth is 6480 MHz
+ */
+ BANDWIDTH_6480 = 11,
+ /**
+ * AP channel bandwidth is 8640 MHz
+ */
+ BANDWIDTH_8640 = 12,
+}
diff --git a/wifi/hostapd/aidl/android/hardware/wifi/hostapd/HwModeParams.aidl b/wifi/hostapd/aidl/android/hardware/wifi/hostapd/HwModeParams.aidl
index e66a24a..320db9c 100644
--- a/wifi/hostapd/aidl/android/hardware/wifi/hostapd/HwModeParams.aidl
+++ b/wifi/hostapd/aidl/android/hardware/wifi/hostapd/HwModeParams.aidl
@@ -16,6 +16,8 @@
package android.hardware.wifi.hostapd;
+import android.hardware.wifi.hostapd.ChannelBandwidth;
+
/**
* Parameters to control the HW mode for the interface.
*/
@@ -74,4 +76,9 @@
* used with Extreme High Throughput.
*/
boolean enable80211BE;
+ /**
+ * Limit on maximum channel bandwidth for the softAp.
+ * For automatic selection with no limit use BANDWIDTH_AUTO
+ */
+ ChannelBandwidth maximumChannelBandwidth;
}
diff --git a/wifi/supplicant/aidl/aidl_api/android.hardware.wifi.supplicant/current/android/hardware/wifi/supplicant/ISupplicantP2pIface.aidl b/wifi/supplicant/aidl/aidl_api/android.hardware.wifi.supplicant/current/android/hardware/wifi/supplicant/ISupplicantP2pIface.aidl
index f709aef..d7eff76 100644
--- a/wifi/supplicant/aidl/aidl_api/android.hardware.wifi.supplicant/current/android/hardware/wifi/supplicant/ISupplicantP2pIface.aidl
+++ b/wifi/supplicant/aidl/aidl_api/android.hardware.wifi.supplicant/current/android/hardware/wifi/supplicant/ISupplicantP2pIface.aidl
@@ -95,4 +95,5 @@
void stopFind();
void findOnSocialChannels(in int timeoutInSec);
void findOnSpecificFrequency(in int freqInHz, in int timeoutInSec);
+ void setVendorElements(in android.hardware.wifi.supplicant.P2pFrameTypeMask frameTypeMask, in byte[] vendorElemBytes);
}
diff --git a/wifi/supplicant/aidl/aidl_api/android.hardware.wifi.supplicant/current/android/hardware/wifi/supplicant/ISupplicantP2pIfaceCallback.aidl b/wifi/supplicant/aidl/aidl_api/android.hardware.wifi.supplicant/current/android/hardware/wifi/supplicant/ISupplicantP2pIfaceCallback.aidl
index 826d916..8d9f498 100644
--- a/wifi/supplicant/aidl/aidl_api/android.hardware.wifi.supplicant/current/android/hardware/wifi/supplicant/ISupplicantP2pIfaceCallback.aidl
+++ b/wifi/supplicant/aidl/aidl_api/android.hardware.wifi.supplicant/current/android/hardware/wifi/supplicant/ISupplicantP2pIfaceCallback.aidl
@@ -51,4 +51,5 @@
oneway void onStaAuthorized(in byte[] srcAddress, in byte[] p2pDeviceAddress);
oneway void onStaDeauthorized(in byte[] srcAddress, in byte[] p2pDeviceAddress);
oneway void onGroupFrequencyChanged(in String groupIfname, in int frequency);
+ oneway void onDeviceFoundWithVendorElements(in byte[] srcAddress, in byte[] p2pDeviceAddress, in byte[] primaryDeviceType, in String deviceName, in android.hardware.wifi.supplicant.WpsConfigMethods configMethods, in byte deviceCapabilities, in android.hardware.wifi.supplicant.P2pGroupCapabilityMask groupCapabilities, in byte[] wfdDeviceInfo, in byte[] wfdR2DeviceInfo, in byte[] vendorElemBytes);
}
diff --git a/wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/Bandwidth.aidl b/wifi/supplicant/aidl/aidl_api/android.hardware.wifi.supplicant/current/android/hardware/wifi/supplicant/P2pFrameTypeMask.aidl
similarity index 75%
copy from wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/Bandwidth.aidl
copy to wifi/supplicant/aidl/aidl_api/android.hardware.wifi.supplicant/current/android/hardware/wifi/supplicant/P2pFrameTypeMask.aidl
index 4d78640..6e1b957 100644
--- a/wifi/hostapd/aidl/aidl_api/android.hardware.wifi.hostapd/current/android/hardware/wifi/hostapd/Bandwidth.aidl
+++ b/wifi/supplicant/aidl/aidl_api/android.hardware.wifi.supplicant/current/android/hardware/wifi/supplicant/P2pFrameTypeMask.aidl
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2021 The Android Open Source Project
+ * Copyright (C) 2022 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.
@@ -31,19 +31,20 @@
// 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.wifi.hostapd;
+package android.hardware.wifi.supplicant;
@Backing(type="int") @VintfStability
-enum Bandwidth {
- BANDWIDTH_INVALID = 0,
- BANDWIDTH_20_NOHT = 1,
- BANDWIDTH_20 = 2,
- BANDWIDTH_40 = 3,
- BANDWIDTH_80 = 4,
- BANDWIDTH_80P80 = 5,
- BANDWIDTH_160 = 6,
- BANDWIDTH_320 = 7,
- BANDWIDTH_2160 = 8,
- BANDWIDTH_4320 = 9,
- BANDWIDTH_6480 = 10,
- BANDWIDTH_8640 = 11,
+enum P2pFrameTypeMask {
+ P2P_FRAME_PROBE_REQ_P2P = 1,
+ P2P_FRAME_PROBE_RESP_P2P = 2,
+ P2P_FRAME_PROBE_RESP_P2P_GO = 4,
+ P2P_FRAME_BEACON_P2P_GO = 8,
+ P2P_FRAME_P2P_PD_REQ = 16,
+ P2P_FRAME_P2P_PD_RESP = 32,
+ P2P_FRAME_P2P_GO_NEG_REQ = 64,
+ P2P_FRAME_P2P_GO_NEG_RESP = 128,
+ P2P_FRAME_P2P_GO_NEG_CONF = 256,
+ P2P_FRAME_P2P_INV_REQ = 512,
+ P2P_FRAME_P2P_INV_RESP = 1024,
+ P2P_FRAME_P2P_ASSOC_REQ = 2048,
+ P2P_FRAME_P2P_ASSOC_RESP = 4096,
}
diff --git a/wifi/supplicant/aidl/android/hardware/wifi/supplicant/ISupplicantP2pIface.aidl b/wifi/supplicant/aidl/android/hardware/wifi/supplicant/ISupplicantP2pIface.aidl
index 7588c74..9021bf5 100644
--- a/wifi/supplicant/aidl/android/hardware/wifi/supplicant/ISupplicantP2pIface.aidl
+++ b/wifi/supplicant/aidl/android/hardware/wifi/supplicant/ISupplicantP2pIface.aidl
@@ -21,6 +21,7 @@
import android.hardware.wifi.supplicant.ISupplicantP2pNetwork;
import android.hardware.wifi.supplicant.IfaceType;
import android.hardware.wifi.supplicant.MiracastMode;
+import android.hardware.wifi.supplicant.P2pFrameTypeMask;
import android.hardware.wifi.supplicant.P2pGroupCapabilityMask;
import android.hardware.wifi.supplicant.WpsConfigMethods;
import android.hardware.wifi.supplicant.WpsProvisionMethod;
@@ -810,4 +811,20 @@
* |SupplicantStatusCode.FAILURE_IFACE_DISABLED|
*/
void findOnSpecificFrequency(in int freqInHz, in int timeoutInSec);
+
+ /**
+ * Set vendor-specific information elements to P2P frames.
+ *
+ * @param frameTypeMask The bit mask of P2P frame type represented by
+ * P2pFrameTypeMask.
+ * @param vendorElemBytes Vendor-specific information element bytes. The format of an
+ * information element is EID (1 byte) + Length (1 Byte) + Payload which is
+ * defined in Section 9.4.4 TLV encodings of 802.11-2016 IEEE Standard for
+ * Information technology. The length indicates the size of the payload.
+ * Multiple information elements may be appended within the byte array.
+ * @throws ServiceSpecificException with one of the following values:
+ * |SupplicantStatusCode.FAILURE_UNKNOWN|,
+ * |SupplicantStatusCode.FAILURE_IFACE_INVALID|
+ */
+ void setVendorElements(in P2pFrameTypeMask frameTypeMask, in byte[] vendorElemBytes);
}
diff --git a/wifi/supplicant/aidl/android/hardware/wifi/supplicant/ISupplicantP2pIfaceCallback.aidl b/wifi/supplicant/aidl/android/hardware/wifi/supplicant/ISupplicantP2pIfaceCallback.aidl
index 2b58cc2..da17c7b 100644
--- a/wifi/supplicant/aidl/android/hardware/wifi/supplicant/ISupplicantP2pIfaceCallback.aidl
+++ b/wifi/supplicant/aidl/android/hardware/wifi/supplicant/ISupplicantP2pIfaceCallback.aidl
@@ -213,4 +213,35 @@
* @param frequency New operating frequency in MHz.
*/
oneway void onGroupFrequencyChanged(in String groupIfname, in int frequency);
+
+ /**
+ * Used to indicate that a P2P device has been found.
+ *
+ * @param srcAddress MAC address of the device found. This must either
+ * be the P2P device address for a peer which is not in a group,
+ * or the P2P interface address for a peer which is a Group Owner.
+ * @param p2pDeviceAddress P2P device address.
+ * @param primaryDeviceType Type of device. Refer to section B.1 of Wifi P2P
+ * Technical specification v1.2.
+ * @param deviceName Name of the device.
+ * @param configMethods Mask of WPS configuration methods supported by the
+ * device.
+ * @param deviceCapabilities Refer to section 4.1.4 of Wifi P2P Technical
+ * specification v1.2.
+ * @param groupCapabilites Refer to section 4.1.4 of Wifi P2P Technical
+ * specification v1.2.
+ * @param wfdDeviceInfo WFD device info as described in section 5.1.2 of WFD
+ * technical specification v1.0.0.
+ * @param wfdR2DeviceInfo WFD R2 device info as described in section 5.1.12 of WFD
+ * technical specification v2.1.
+ * @param vendorElemBytes Vendor-specific information element bytes. The format of an
+ * information element is EID (1 byte) + Length (1 Byte) + Payload which is
+ * defined in Section 9.4.4 TLV encodings of 802.11-2016 IEEE Standard for
+ * Information technology. The length indicates the size of the payload.
+ * Multiple information elements may be appended within the byte array.
+ */
+ oneway void onDeviceFoundWithVendorElements(in byte[] srcAddress, in byte[] p2pDeviceAddress,
+ in byte[] primaryDeviceType, in String deviceName, in WpsConfigMethods configMethods,
+ in byte deviceCapabilities, in P2pGroupCapabilityMask groupCapabilities,
+ in byte[] wfdDeviceInfo, in byte[] wfdR2DeviceInfo, in byte[] vendorElemBytes);
}
diff --git a/wifi/supplicant/aidl/android/hardware/wifi/supplicant/P2pFrameTypeMask.aidl b/wifi/supplicant/aidl/android/hardware/wifi/supplicant/P2pFrameTypeMask.aidl
new file mode 100644
index 0000000..06e834b
--- /dev/null
+++ b/wifi/supplicant/aidl/android/hardware/wifi/supplicant/P2pFrameTypeMask.aidl
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.hardware.wifi.supplicant;
+
+/**
+ * Bitmask of P2P frame types.
+ */
+@VintfStability
+@Backing(type="int")
+enum P2pFrameTypeMask {
+ /** P2P probe request frame */
+ P2P_FRAME_PROBE_REQ_P2P = 1 << 0,
+ /** P2P probe response frame */
+ P2P_FRAME_PROBE_RESP_P2P = 1 << 1,
+ /** P2P probe response frame from the group owner */
+ P2P_FRAME_PROBE_RESP_P2P_GO = 1 << 2,
+ /** Beacon frame from the group owner */
+ P2P_FRAME_BEACON_P2P_GO = 1 << 3,
+ /** Provision discovery request frame */
+ P2P_FRAME_P2P_PD_REQ = 1 << 4,
+ /** Provision discovery response frame */
+ P2P_FRAME_P2P_PD_RESP = 1 << 5,
+ /** Group negotiation request frame */
+ P2P_FRAME_P2P_GO_NEG_REQ = 1 << 6,
+ /** Group negotiation response frame */
+ P2P_FRAME_P2P_GO_NEG_RESP = 1 << 7,
+ /** Group negotiation confirm frame */
+ P2P_FRAME_P2P_GO_NEG_CONF = 1 << 8,
+ /** Invitation request frame */
+ P2P_FRAME_P2P_INV_REQ = 1 << 9,
+ /** Invitation response frame */
+ P2P_FRAME_P2P_INV_RESP = 1 << 10,
+ /** P2P Association request frame */
+ P2P_FRAME_P2P_ASSOC_REQ = 1 << 11,
+ /** P2P Association response frame */
+ P2P_FRAME_P2P_ASSOC_RESP = 1 << 12,
+}
diff --git a/wifi/supplicant/aidl/vts/functional/supplicant_p2p_iface_aidl_test.cpp b/wifi/supplicant/aidl/vts/functional/supplicant_p2p_iface_aidl_test.cpp
index 90ca215..d95bd03 100644
--- a/wifi/supplicant/aidl/vts/functional/supplicant_p2p_iface_aidl_test.cpp
+++ b/wifi/supplicant/aidl/vts/functional/supplicant_p2p_iface_aidl_test.cpp
@@ -34,6 +34,7 @@
using aidl::android::hardware::wifi::supplicant::ISupplicant;
using aidl::android::hardware::wifi::supplicant::ISupplicantP2pIface;
using aidl::android::hardware::wifi::supplicant::MiracastMode;
+using aidl::android::hardware::wifi::supplicant::P2pFrameTypeMask;
using aidl::android::hardware::wifi::supplicant::P2pGroupCapabilityMask;
using aidl::android::hardware::wifi::supplicant::P2pProvDiscStatusCode;
using aidl::android::hardware::wifi::supplicant::P2pStatusCode;
@@ -163,6 +164,17 @@
int32_t /* frequency */) override {
return ndk::ScopedAStatus::ok();
}
+ ::ndk::ScopedAStatus onDeviceFoundWithVendorElements(
+ const std::vector<uint8_t>& /* srcAddress */,
+ const std::vector<uint8_t>& /* p2pDeviceAddress */,
+ const std::vector<uint8_t>& /* primaryDeviceType */,
+ const std::string& /* deviceName */, WpsConfigMethods /* configMethods */,
+ int8_t /* deviceCapabilities */, P2pGroupCapabilityMask /* groupCapabilities */,
+ const std::vector<uint8_t>& /* wfdDeviceInfo */,
+ const std::vector<uint8_t>& /* wfdR2DeviceInfo */,
+ const std::vector<uint8_t>& /* vendorElemBytes */) override {
+ return ndk::ScopedAStatus::ok();
+ }
};
class SupplicantP2pIfaceAidlTest : public testing::TestWithParam<std::string> {
@@ -637,6 +649,21 @@
p2p_iface_->removeUpnpService(0 /* version */, upnpServiceName).isOk());
}
+/*
+ * SetVendorElements
+ */
+TEST_P(SupplicantP2pIfaceAidlTest, SetVendorElements) {
+ LOG(INFO) << "SupplicantP2pIfaceAidlTest::SetVendorElements start";
+
+ std::vector<uint8_t> vendorElemBytes;
+ EXPECT_TRUE(
+ p2p_iface_
+ ->setVendorElements(P2pFrameTypeMask::P2P_FRAME_PROBE_RESP_P2P, vendorElemBytes)
+ .isOk());
+
+ LOG(INFO) << "SupplicantP2pIfaceAidlTest::SetVendorElements end";
+}
+
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(SupplicantP2pIfaceAidlTest);
INSTANTIATE_TEST_SUITE_P(Supplicant, SupplicantP2pIfaceAidlTest,
testing::ValuesIn(android::getAidlHalInstanceNames(