Merge "Revert "Disable mouse acceleration and scaling when Pointer Capture is enabled"" into tm-dev
diff --git a/cmds/installd/TEST_MAPPING b/cmds/installd/TEST_MAPPING
index 8ccab4c..fc4cfc9 100644
--- a/cmds/installd/TEST_MAPPING
+++ b/cmds/installd/TEST_MAPPING
@@ -32,7 +32,12 @@
"name": "CtsCompilationTestCases"
},
{
- "name": "SdkSandboxStorageHostTest"
+ "name": "SdkSandboxStorageHostTest",
+ "options": [
+ {
+ "exclude-annotation": "android.platform.test.annotations.LargeTest"
+ }
+ ]
}
]
}
diff --git a/data/etc/Android.bp b/data/etc/Android.bp
index 5003151..bdd5172 100644
--- a/data/etc/Android.bp
+++ b/data/etc/Android.bp
@@ -227,6 +227,12 @@
}
prebuilt_etc {
+ name: "android.software.opengles.deqp.level-2022-03-01.prebuilt.xml",
+ src: "android.software.opengles.deqp.level-2022-03-01.xml",
+ defaults: ["frameworks_native_data_etc_defaults"],
+}
+
+prebuilt_etc {
name: "android.software.sip.voip.prebuilt.xml",
src: "android.software.sip.voip.xml",
defaults: ["frameworks_native_data_etc_defaults"],
@@ -245,6 +251,12 @@
}
prebuilt_etc {
+ name: "android.software.vulkan.deqp.level-2022-03-01.prebuilt.xml",
+ src: "android.software.vulkan.deqp.level-2022-03-01.xml",
+ defaults: ["frameworks_native_data_etc_defaults"],
+}
+
+prebuilt_etc {
name: "aosp_excluded_hardware.prebuilt.xml",
src: "aosp_excluded_hardware.xml",
defaults: ["frameworks_native_data_etc_defaults"],
diff --git a/libs/binder/include/binder/RpcServer.h b/libs/binder/include/binder/RpcServer.h
index aaa812b..6b31812 100644
--- a/libs/binder/include/binder/RpcServer.h
+++ b/libs/binder/include/binder/RpcServer.h
@@ -77,7 +77,7 @@
* have
*/
[[nodiscard]] status_t setupInetServer(const char* address, unsigned int port,
- unsigned int* assignedPort);
+ unsigned int* assignedPort = nullptr);
/**
* If setup*Server has been successful, return true. Otherwise return false.
diff --git a/libs/binder/ndk/include_cpp/android/binder_interface_utils.h b/libs/binder/ndk/include_cpp/android/binder_interface_utils.h
index b3bc7f4..c8e78fc 100644
--- a/libs/binder/ndk/include_cpp/android/binder_interface_utils.h
+++ b/libs/binder/ndk/include_cpp/android/binder_interface_utils.h
@@ -324,4 +324,42 @@
} // namespace ndk
+// Once minSdkVersion is 30, we are guaranteed to be building with the
+// Android 11 AIDL compiler which supports the SharedRefBase::make API.
+#if !defined(__ANDROID_API__) || __ANDROID_API__ >= 30 || defined(__ANDROID_APEX__)
+namespace ndk::internal {
+template <typename T, typename = void>
+struct is_complete_type : std::false_type {};
+
+template <typename T>
+struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};
+} // namespace ndk::internal
+
+namespace std {
+
+// Define `SharedRefBase` specific versions of `std::make_shared` and
+// `std::make_unique` to block people from using them. Using them to allocate
+// `ndk::SharedRefBase` objects results in double ownership. Use
+// `ndk::SharedRefBase::make<T>(...)` instead.
+//
+// Note: We exclude incomplete types because `std::is_base_of` is undefined in
+// that case.
+
+template <typename T, typename... Args,
+ std::enable_if_t<ndk::internal::is_complete_type<T>::value, bool> = true,
+ std::enable_if_t<std::is_base_of<ndk::SharedRefBase, T>::value, bool> = true>
+shared_ptr<T> make_shared(Args...) { // SEE COMMENT ABOVE.
+ static_assert(!std::is_base_of<ndk::SharedRefBase, T>::value);
+}
+
+template <typename T, typename... Args,
+ std::enable_if_t<ndk::internal::is_complete_type<T>::value, bool> = true,
+ std::enable_if_t<std::is_base_of<ndk::SharedRefBase, T>::value, bool> = true>
+unique_ptr<T> make_unique(Args...) { // SEE COMMENT ABOVE.
+ static_assert(!std::is_base_of<ndk::SharedRefBase, T>::value);
+}
+
+} // namespace std
+#endif
+
/** @} */
diff --git a/libs/binder/ndk/tests/libbinder_ndk_unit_test.cpp b/libs/binder/ndk/tests/libbinder_ndk_unit_test.cpp
index 357b454..1b136dc 100644
--- a/libs/binder/ndk/tests/libbinder_ndk_unit_test.cpp
+++ b/libs/binder/ndk/tests/libbinder_ndk_unit_test.cpp
@@ -231,8 +231,7 @@
}
TEST(NdkBinder, DetectNoSharedRefBaseCreated) {
- EXPECT_DEATH(std::make_shared<MyBinderNdkUnitTest>(),
- "SharedRefBase: no ref created during lifetime");
+ EXPECT_DEATH(MyBinderNdkUnitTest(), "SharedRefBase: no ref created during lifetime");
}
TEST(NdkBinder, GetServiceThatDoesntExist) {
diff --git a/libs/binder/tests/parcel_fuzzer/Android.bp b/libs/binder/tests/parcel_fuzzer/Android.bp
index 57d496d..e5d32da 100644
--- a/libs/binder/tests/parcel_fuzzer/Android.bp
+++ b/libs/binder/tests/parcel_fuzzer/Android.bp
@@ -29,7 +29,6 @@
"libcutils",
"libhidlbase",
"liblog",
- "libutils",
],
target: {
@@ -37,12 +36,14 @@
shared_libs: [
"libbinder_ndk",
"libbinder",
+ "libutils",
],
},
host: {
static_libs: [
"libbinder_ndk",
"libbinder",
+ "libutils",
],
},
darwin: {
diff --git a/libs/renderengine/include/renderengine/DisplaySettings.h b/libs/renderengine/include/renderengine/DisplaySettings.h
index bf50644..a5e0879 100644
--- a/libs/renderengine/include/renderengine/DisplaySettings.h
+++ b/libs/renderengine/include/renderengine/DisplaySettings.h
@@ -17,6 +17,7 @@
#pragma once
#include <aidl/android/hardware/graphics/composer3/DimmingStage.h>
+#include <aidl/android/hardware/graphics/composer3/RenderIntent.h>
#include <iosfwd>
#include <math/mat4.h>
@@ -73,6 +74,10 @@
// Configures when dimming should be applied for each layer.
aidl::android::hardware::graphics::composer3::DimmingStage dimmingStage =
aidl::android::hardware::graphics::composer3::DimmingStage::NONE;
+
+ // Configures the rendering intent of the output display. This is used for tonemapping.
+ aidl::android::hardware::graphics::composer3::RenderIntent renderIntent =
+ aidl::android::hardware::graphics::composer3::RenderIntent::TONE_MAP_COLORIMETRIC;
};
static inline bool operator==(const DisplaySettings& lhs, const DisplaySettings& rhs) {
diff --git a/libs/renderengine/skia/SkiaGLRenderEngine.cpp b/libs/renderengine/skia/SkiaGLRenderEngine.cpp
index a77a798..76ae2fc 100644
--- a/libs/renderengine/skia/SkiaGLRenderEngine.cpp
+++ b/libs/renderengine/skia/SkiaGLRenderEngine.cpp
@@ -662,7 +662,7 @@
parameters.display.maxLuminance,
parameters.display.currentLuminanceNits,
parameters.layer.source.buffer.maxLuminanceNits,
- hardwareBuffer);
+ hardwareBuffer, parameters.display.renderIntent);
}
return parameters.shader;
}
diff --git a/libs/renderengine/skia/filters/LinearEffect.cpp b/libs/renderengine/skia/filters/LinearEffect.cpp
index d479606..f7dcd3a 100644
--- a/libs/renderengine/skia/filters/LinearEffect.cpp
+++ b/libs/renderengine/skia/filters/LinearEffect.cpp
@@ -40,12 +40,11 @@
return shader;
}
-sk_sp<SkShader> createLinearEffectShader(sk_sp<SkShader> shader,
- const shaders::LinearEffect& linearEffect,
- sk_sp<SkRuntimeEffect> runtimeEffect,
- const mat4& colorTransform, float maxDisplayLuminance,
- float currentDisplayLuminanceNits, float maxLuminance,
- AHardwareBuffer* buffer) {
+sk_sp<SkShader> createLinearEffectShader(
+ sk_sp<SkShader> shader, const shaders::LinearEffect& linearEffect,
+ sk_sp<SkRuntimeEffect> runtimeEffect, const mat4& colorTransform, float maxDisplayLuminance,
+ float currentDisplayLuminanceNits, float maxLuminance, AHardwareBuffer* buffer,
+ aidl::android::hardware::graphics::composer3::RenderIntent renderIntent) {
ATRACE_CALL();
SkRuntimeShaderBuilder effectBuilder(runtimeEffect);
@@ -53,7 +52,8 @@
const auto uniforms =
shaders::buildLinearEffectUniforms(linearEffect, colorTransform, maxDisplayLuminance,
- currentDisplayLuminanceNits, maxLuminance, buffer);
+ currentDisplayLuminanceNits, maxLuminance, buffer,
+ renderIntent);
for (const auto& uniform : uniforms) {
effectBuilder.uniform(uniform.name.c_str()).set(uniform.value.data(), uniform.value.size());
diff --git a/libs/renderengine/skia/filters/LinearEffect.h b/libs/renderengine/skia/filters/LinearEffect.h
index 26bae3b..3c66c51 100644
--- a/libs/renderengine/skia/filters/LinearEffect.h
+++ b/libs/renderengine/skia/filters/LinearEffect.h
@@ -42,12 +42,13 @@
// or as the max light level from the CTA 861.3 standard.
// * An AHardwareBuffer for implementations that support gralloc4 metadata for
// communicating any HDR metadata.
-sk_sp<SkShader> createLinearEffectShader(sk_sp<SkShader> inputShader,
- const shaders::LinearEffect& linearEffect,
- sk_sp<SkRuntimeEffect> runtimeEffect,
- const mat4& colorTransform, float maxDisplayLuminance,
- float currentDisplayLuminanceNits, float maxLuminance,
- AHardwareBuffer* buffer);
+// * A RenderIntent that communicates the downstream renderintent for a physical display, for image
+// quality compensation.
+sk_sp<SkShader> createLinearEffectShader(
+ sk_sp<SkShader> inputShader, const shaders::LinearEffect& linearEffect,
+ sk_sp<SkRuntimeEffect> runtimeEffect, const mat4& colorTransform, float maxDisplayLuminance,
+ float currentDisplayLuminanceNits, float maxLuminance, AHardwareBuffer* buffer,
+ aidl::android::hardware::graphics::composer3::RenderIntent renderIntent);
} // namespace skia
} // namespace renderengine
} // namespace android
diff --git a/libs/shaders/Android.bp b/libs/shaders/Android.bp
index 2f8bf49..6b936de 100644
--- a/libs/shaders/Android.bp
+++ b/libs/shaders/Android.bp
@@ -29,6 +29,7 @@
shared_libs: [
"android.hardware.graphics.common-V3-ndk",
+ "android.hardware.graphics.composer3-V1-ndk",
"android.hardware.graphics.common@1.2",
"libnativewindow",
],
diff --git a/libs/shaders/include/shaders/shaders.h b/libs/shaders/include/shaders/shaders.h
index 4ec7594..2a4a370 100644
--- a/libs/shaders/include/shaders/shaders.h
+++ b/libs/shaders/include/shaders/shaders.h
@@ -97,11 +97,10 @@
std::string buildLinearEffectSkSL(const LinearEffect& linearEffect);
// Generates a list of uniforms to set on the LinearEffect shader above.
-std::vector<tonemap::ShaderUniform> buildLinearEffectUniforms(const LinearEffect& linearEffect,
- const mat4& colorTransform,
- float maxDisplayLuminance,
- float currentDisplayLuminanceNits,
- float maxLuminance,
- AHardwareBuffer* buffer = nullptr);
+std::vector<tonemap::ShaderUniform> buildLinearEffectUniforms(
+ const LinearEffect& linearEffect, const mat4& colorTransform, float maxDisplayLuminance,
+ float currentDisplayLuminanceNits, float maxLuminance, AHardwareBuffer* buffer = nullptr,
+ aidl::android::hardware::graphics::composer3::RenderIntent renderIntent =
+ aidl::android::hardware::graphics::composer3::RenderIntent::TONE_MAP_COLORIMETRIC);
} // namespace android::shaders
diff --git a/libs/shaders/shaders.cpp b/libs/shaders/shaders.cpp
index 5935589..f0d45c2 100644
--- a/libs/shaders/shaders.cpp
+++ b/libs/shaders/shaders.cpp
@@ -464,12 +464,10 @@
}
// Generates a list of uniforms to set on the LinearEffect shader above.
-std::vector<tonemap::ShaderUniform> buildLinearEffectUniforms(const LinearEffect& linearEffect,
- const mat4& colorTransform,
- float maxDisplayLuminance,
- float currentDisplayLuminanceNits,
- float maxLuminance,
- AHardwareBuffer* buffer) {
+std::vector<tonemap::ShaderUniform> buildLinearEffectUniforms(
+ const LinearEffect& linearEffect, const mat4& colorTransform, float maxDisplayLuminance,
+ float currentDisplayLuminanceNits, float maxLuminance, AHardwareBuffer* buffer,
+ aidl::android::hardware::graphics::composer3::RenderIntent renderIntent) {
std::vector<tonemap::ShaderUniform> uniforms;
if (linearEffect.inputDataspace == linearEffect.outputDataspace) {
uniforms.push_back({.name = "in_rgbToXyz", .value = buildUniformValue<mat4>(mat4())});
@@ -495,7 +493,8 @@
.currentDisplayLuminance = currentDisplayLuminanceNits > 0
? currentDisplayLuminanceNits
: maxDisplayLuminance,
- .buffer = buffer};
+ .buffer = buffer,
+ .renderIntent = renderIntent};
for (const auto uniform : tonemap::getToneMapper()->generateShaderSkSLUniforms(metadata)) {
uniforms.push_back(uniform);
diff --git a/libs/tonemap/Android.bp b/libs/tonemap/Android.bp
index dc55586..37c9824 100644
--- a/libs/tonemap/Android.bp
+++ b/libs/tonemap/Android.bp
@@ -29,6 +29,7 @@
shared_libs: [
"android.hardware.graphics.common-V3-ndk",
+ "android.hardware.graphics.composer3-V1-ndk",
"liblog",
"libnativewindow",
],
diff --git a/libs/tonemap/include/tonemap/tonemap.h b/libs/tonemap/include/tonemap/tonemap.h
index c51016d..852fc87 100644
--- a/libs/tonemap/include/tonemap/tonemap.h
+++ b/libs/tonemap/include/tonemap/tonemap.h
@@ -17,6 +17,7 @@
#pragma once
#include <aidl/android/hardware/graphics/common/Dataspace.h>
+#include <aidl/android/hardware/graphics/composer3/RenderIntent.h>
#include <android/hardware_buffer.h>
#include <math/vec3.h>
@@ -41,7 +42,7 @@
// Describes metadata which may be used for constructing the shader uniforms.
// This metadata should not be used for manipulating the source code of the shader program directly,
-// as otherwise caching by other system of these shaders may break.
+// as otherwise caching by other parts of the system using these shaders may break.
struct Metadata {
// The maximum luminance of the display in nits
float displayMaxLuminance = 0.0;
@@ -61,6 +62,17 @@
// texture that does not have associated metadata. As such, implementations
// must support nullptr.
AHardwareBuffer* buffer = nullptr;
+
+ // RenderIntent of the destination display.
+ // Non-colorimetric render-intents may be defined in order to take advantage of the full display
+ // gamut. Various contrast-enhancement mechanisms may be employed on SDR content as a result,
+ // which means that HDR content may need to be compensated in order to achieve correct blending
+ // behavior. This default is effectively optional - the display render intent may not be
+ // available to clients such as HWUI which are display-agnostic. For those clients, tone-map
+ // colorimetric may be assumed so that the luminance range may be converted to the correct range
+ // based on the output dataspace.
+ aidl::android::hardware::graphics::composer3::RenderIntent renderIntent =
+ aidl::android::hardware::graphics::composer3::RenderIntent::TONE_MAP_COLORIMETRIC;
};
// Utility class containing pre-processed conversions for a particular color
diff --git a/libs/tonemap/tests/Android.bp b/libs/tonemap/tests/Android.bp
index 26a1d79..58851b4 100644
--- a/libs/tonemap/tests/Android.bp
+++ b/libs/tonemap/tests/Android.bp
@@ -32,6 +32,7 @@
],
shared_libs: [
"android.hardware.graphics.common-V3-ndk",
+ "android.hardware.graphics.composer3-V1-ndk",
"libnativewindow",
],
static_libs: [
diff --git a/libs/ui/Gralloc4.cpp b/libs/ui/Gralloc4.cpp
index 1fce31d..4f950b8 100644
--- a/libs/ui/Gralloc4.cpp
+++ b/libs/ui/Gralloc4.cpp
@@ -1193,10 +1193,6 @@
Gralloc4Allocator::Gralloc4Allocator(const Gralloc4Mapper& mapper) : mMapper(mapper) {
mAllocator = IAllocator::getService();
- if (mAllocator == nullptr) {
- ALOGW("allocator 4.x is not supported");
- return;
- }
if (__builtin_available(android 31, *)) {
if (hasIAllocatorAidl()) {
mAidlAllocator = AidlIAllocator::fromBinder(ndk::SpAIBinder(
@@ -1204,10 +1200,14 @@
ALOGE_IF(!mAidlAllocator, "AIDL IAllocator declared but failed to get service");
}
}
+ if (mAllocator == nullptr && mAidlAllocator == nullptr) {
+ ALOGW("allocator 4.x is not supported");
+ return;
+ }
}
bool Gralloc4Allocator::isLoaded() const {
- return mAllocator != nullptr;
+ return mAllocator != nullptr || mAidlAllocator != nullptr;
}
std::string Gralloc4Allocator::dumpDebugInfo(bool less) const {
diff --git a/libs/ui/include/ui/Size.h b/libs/ui/include/ui/Size.h
index ecc192d..bdcbd56 100644
--- a/libs/ui/include/ui/Size.h
+++ b/libs/ui/include/ui/Size.h
@@ -23,6 +23,8 @@
#include <type_traits>
#include <utility>
+#include <ui/Rotation.h>
+
namespace android::ui {
// A simple value type representing a two-dimensional size.
@@ -61,6 +63,16 @@
set(Size(w, h));
}
+ // Applies a rotation onto the size
+ void rotate(Rotation rotation) {
+ if (rotation == ROTATION_90 || rotation == ROTATION_270) {
+ transpose();
+ }
+ }
+
+ // Swaps the width and height, emulating a 90 degree rotation.
+ void transpose() { std::swap(width, height); }
+
// Sets the value to kInvalidSize
void makeInvalid();
diff --git a/libs/ui/tests/Size_test.cpp b/libs/ui/tests/Size_test.cpp
index acef47f..0a236e6 100644
--- a/libs/ui/tests/Size_test.cpp
+++ b/libs/ui/tests/Size_test.cpp
@@ -61,6 +61,38 @@
EXPECT_FALSE(Size(1, 1) < Size(1, 1));
}
+TEST(SizeTest, Transpose) {
+ Size s(123, 456);
+ s.transpose();
+ EXPECT_EQ(s, Size(456, 123));
+}
+
+TEST(SizeTest, Rotate) {
+ {
+ Size s(123, 456);
+ s.rotate(Rotation::Rotation0);
+ EXPECT_EQ(s, Size(123, 456));
+ }
+
+ {
+ Size s(123, 456);
+ s.rotate(Rotation::Rotation90);
+ EXPECT_EQ(s, Size(456, 123));
+ }
+
+ {
+ Size s(123, 456);
+ s.rotate(Rotation::Rotation180);
+ EXPECT_EQ(s, Size(123, 456));
+ }
+
+ {
+ Size s(123, 456);
+ s.rotate(Rotation::Rotation270);
+ EXPECT_EQ(s, Size(456, 123));
+ }
+}
+
TEST(SizeTest, ValidAndEmpty) {
{
Size s;
diff --git a/services/inputflinger/reader/mapper/KeyboardInputMapper.cpp b/services/inputflinger/reader/mapper/KeyboardInputMapper.cpp
index 1d63c0e..2ac8178 100644
--- a/services/inputflinger/reader/mapper/KeyboardInputMapper.cpp
+++ b/services/inputflinger/reader/mapper/KeyboardInputMapper.cpp
@@ -428,6 +428,8 @@
}
void KeyboardInputMapper::updateLedState(bool reset) {
+ // Clear the local led state then union the global led state.
+ mMetaState &= ~(AMETA_CAPS_LOCK_ON | AMETA_NUM_LOCK_ON | AMETA_SCROLL_LOCK_ON);
mMetaState |= getContext()->getLedMetaState();
constexpr int32_t META_NUM = 3;
diff --git a/services/inputflinger/tests/InputReader_test.cpp b/services/inputflinger/tests/InputReader_test.cpp
index 8ba501c..bda7755 100644
--- a/services/inputflinger/tests/InputReader_test.cpp
+++ b/services/inputflinger/tests/InputReader_test.cpp
@@ -3999,6 +3999,78 @@
ASSERT_EQ(AMETA_CAPS_LOCK_ON, mapper.getMetaState());
}
+TEST_F(KeyboardInputMapperTest, Process_LockedKeysShouldToggleInMultiDevices) {
+ // keyboard 1.
+ mFakeEventHub->addLed(EVENTHUB_ID, LED_CAPSL, true /*initially on*/);
+ mFakeEventHub->addLed(EVENTHUB_ID, LED_NUML, false /*initially off*/);
+ mFakeEventHub->addLed(EVENTHUB_ID, LED_SCROLLL, false /*initially off*/);
+ mFakeEventHub->addKey(EVENTHUB_ID, KEY_CAPSLOCK, 0, AKEYCODE_CAPS_LOCK, 0);
+ mFakeEventHub->addKey(EVENTHUB_ID, KEY_NUMLOCK, 0, AKEYCODE_NUM_LOCK, 0);
+ mFakeEventHub->addKey(EVENTHUB_ID, KEY_SCROLLLOCK, 0, AKEYCODE_SCROLL_LOCK, 0);
+
+ KeyboardInputMapper& mapper1 =
+ addMapperAndConfigure<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD,
+ AINPUT_KEYBOARD_TYPE_ALPHABETIC);
+
+ // keyboard 2.
+ const std::string USB2 = "USB2";
+ const std::string DEVICE_NAME2 = "KEYBOARD2";
+ constexpr int32_t SECOND_DEVICE_ID = DEVICE_ID + 1;
+ constexpr int32_t SECOND_EVENTHUB_ID = EVENTHUB_ID + 1;
+ std::shared_ptr<InputDevice> device2 =
+ newDevice(SECOND_DEVICE_ID, DEVICE_NAME2, USB2, SECOND_EVENTHUB_ID,
+ ftl::Flags<InputDeviceClass>(0));
+ mFakeEventHub->addLed(SECOND_EVENTHUB_ID, LED_CAPSL, true /*initially on*/);
+ mFakeEventHub->addLed(SECOND_EVENTHUB_ID, LED_NUML, false /*initially off*/);
+ mFakeEventHub->addLed(SECOND_EVENTHUB_ID, LED_SCROLLL, false /*initially off*/);
+ mFakeEventHub->addKey(SECOND_EVENTHUB_ID, KEY_CAPSLOCK, 0, AKEYCODE_CAPS_LOCK, 0);
+ mFakeEventHub->addKey(SECOND_EVENTHUB_ID, KEY_NUMLOCK, 0, AKEYCODE_NUM_LOCK, 0);
+ mFakeEventHub->addKey(SECOND_EVENTHUB_ID, KEY_SCROLLLOCK, 0, AKEYCODE_SCROLL_LOCK, 0);
+
+ KeyboardInputMapper& mapper2 =
+ device2->addMapper<KeyboardInputMapper>(SECOND_EVENTHUB_ID, AINPUT_SOURCE_KEYBOARD,
+ AINPUT_KEYBOARD_TYPE_ALPHABETIC);
+ device2->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), 0 /*changes*/);
+ device2->reset(ARBITRARY_TIME);
+
+ // Initial metastate is AMETA_NUM_LOCK_ON, turn it off.
+ ASSERT_TRUE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_NUML));
+ ASSERT_EQ(AMETA_NUM_LOCK_ON, mapper1.getMetaState());
+ ASSERT_EQ(AMETA_NUM_LOCK_ON, mapper2.getMetaState());
+
+ process(mapper1, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_NUMLOCK, 1);
+ process(mapper1, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_NUMLOCK, 0);
+ ASSERT_FALSE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_NUML));
+ ASSERT_EQ(AMETA_NONE, mapper1.getMetaState());
+ ASSERT_EQ(AMETA_NONE, mapper2.getMetaState());
+
+ // Toggle caps lock on and off.
+ process(mapper1, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_CAPSLOCK, 1);
+ process(mapper1, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_CAPSLOCK, 0);
+ ASSERT_TRUE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_CAPSL));
+ ASSERT_EQ(AMETA_CAPS_LOCK_ON, mapper1.getMetaState());
+ ASSERT_EQ(AMETA_CAPS_LOCK_ON, mapper2.getMetaState());
+
+ process(mapper1, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_CAPSLOCK, 1);
+ process(mapper1, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_CAPSLOCK, 0);
+ ASSERT_FALSE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_CAPSL));
+ ASSERT_EQ(AMETA_NONE, mapper1.getMetaState());
+ ASSERT_EQ(AMETA_NONE, mapper2.getMetaState());
+
+ // Toggle scroll lock on and off.
+ process(mapper1, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_SCROLLLOCK, 1);
+ process(mapper1, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_SCROLLLOCK, 0);
+ ASSERT_TRUE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_SCROLLL));
+ ASSERT_EQ(AMETA_SCROLL_LOCK_ON, mapper1.getMetaState());
+ ASSERT_EQ(AMETA_SCROLL_LOCK_ON, mapper2.getMetaState());
+
+ process(mapper1, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_SCROLLLOCK, 1);
+ process(mapper1, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_SCROLLLOCK, 0);
+ ASSERT_FALSE(mFakeEventHub->getLedState(EVENTHUB_ID, LED_SCROLLL));
+ ASSERT_EQ(AMETA_NONE, mapper1.getMetaState());
+ ASSERT_EQ(AMETA_NONE, mapper2.getMetaState());
+}
+
// --- KeyboardInputMapperTest_ExternalDevice ---
class KeyboardInputMapperTest_ExternalDevice : public InputMapperTest {
diff --git a/services/sensorservice/HidlSensorHalWrapper.cpp b/services/sensorservice/HidlSensorHalWrapper.cpp
index 4c64e59..c55c9b4 100644
--- a/services/sensorservice/HidlSensorHalWrapper.cpp
+++ b/services/sensorservice/HidlSensorHalWrapper.cpp
@@ -281,7 +281,7 @@
}
status_t HidlSensorHalWrapper::registerDirectChannel(const sensors_direct_mem_t* memory,
- int32_t* /*channelHandle*/) {
+ int32_t* outChannelHandle) {
if (mSensors == nullptr) return NO_INIT;
SharedMemType type;
@@ -309,14 +309,16 @@
.memoryHandle = memory->handle,
};
- status_t ret;
- checkReturn(mSensors->registerDirectChannel(mem, [&ret](auto result, auto channelHandle) {
- if (result == Result::OK) {
- ret = channelHandle;
- } else {
- ret = statusFromResult(result);
- }
- }));
+ status_t ret = OK;
+ checkReturn(mSensors->registerDirectChannel(mem,
+ [&ret, &outChannelHandle](auto result,
+ auto channelHandle) {
+ if (result == Result::OK) {
+ *outChannelHandle = channelHandle;
+ } else {
+ ret = statusFromResult(result);
+ }
+ }));
return ret;
}
diff --git a/services/sensorservice/HidlSensorHalWrapper.h b/services/sensorservice/HidlSensorHalWrapper.h
index 71c3512..d6ed178 100644
--- a/services/sensorservice/HidlSensorHalWrapper.h
+++ b/services/sensorservice/HidlSensorHalWrapper.h
@@ -112,7 +112,7 @@
virtual status_t injectSensorData(const sensors_event_t* event) override;
virtual status_t registerDirectChannel(const sensors_direct_mem_t* memory,
- int32_t* channelHandle) override;
+ int32_t* outChannelHandle) override;
virtual status_t unregisterDirectChannel(int32_t channelHandle) override;
diff --git a/services/sensorservice/SensorDevice.cpp b/services/sensorservice/SensorDevice.cpp
index a0e30ac..53a3025 100644
--- a/services/sensorservice/SensorDevice.cpp
+++ b/services/sensorservice/SensorDevice.cpp
@@ -766,7 +766,13 @@
if (mHalWrapper == nullptr) return NO_INIT;
Mutex::Autolock _l(mLock);
- return mHalWrapper->registerDirectChannel(memory, nullptr);
+ int32_t channelHandle;
+ status_t status = mHalWrapper->registerDirectChannel(memory, &channelHandle);
+ if (status != OK) {
+ channelHandle = -1;
+ }
+
+ return channelHandle;
}
void SensorDevice::unregisterDirectChannel(int32_t channelHandle) {
diff --git a/services/surfaceflinger/CompositionEngine/src/Output.cpp b/services/surfaceflinger/CompositionEngine/src/Output.cpp
index e99b70f..004e071 100644
--- a/services/surfaceflinger/CompositionEngine/src/Output.cpp
+++ b/services/surfaceflinger/CompositionEngine/src/Output.cpp
@@ -1177,6 +1177,9 @@
clientCompositionDisplay.targetLuminanceNits =
outputState.clientTargetBrightness * outputState.displayBrightnessNits;
clientCompositionDisplay.dimmingStage = outputState.clientTargetDimmingStage;
+ clientCompositionDisplay.renderIntent =
+ static_cast<aidl::android::hardware::graphics::composer3::RenderIntent>(
+ outputState.renderIntent);
// Compute the global color transform matrix.
clientCompositionDisplay.colorTransform = outputState.colorTransformMatrix;
diff --git a/services/surfaceflinger/CompositionEngine/tests/OutputTest.cpp b/services/surfaceflinger/CompositionEngine/tests/OutputTest.cpp
index 31a89af..42c8b37 100644
--- a/services/surfaceflinger/CompositionEngine/tests/OutputTest.cpp
+++ b/services/surfaceflinger/CompositionEngine/tests/OutputTest.cpp
@@ -3711,6 +3711,16 @@
auto withDimmingStage(
aidl::android::hardware::graphics::composer3::DimmingStage dimmingStage) {
getInstance()->mOutput.mState.clientTargetDimmingStage = dimmingStage;
+ return nextState<OutputWithRenderIntent>();
+ }
+ };
+
+ struct OutputWithRenderIntent
+ : public CallOrderStateMachineHelper<TestType, OutputWithRenderIntent> {
+ auto withRenderIntent(
+ aidl::android::hardware::graphics::composer3::RenderIntent renderIntent) {
+ getInstance()->mOutput.mState.renderIntent =
+ static_cast<ui::RenderIntent>(renderIntent);
return nextState<SkipColorTransformState>();
}
};
@@ -3744,6 +3754,8 @@
.andIfUsesHdr(true)
.withDisplayBrightnessNits(kUnknownLuminance)
.withDimmingStage(aidl::android::hardware::graphics::composer3::DimmingStage::LINEAR)
+ .withRenderIntent(
+ aidl::android::hardware::graphics::composer3::RenderIntent::COLORIMETRIC)
.andIfSkipColorTransform(false)
.thenExpectDisplaySettingsUsed(
{.physicalDisplay = kDefaultOutputDestinationClip,
@@ -3756,7 +3768,9 @@
.orientation = kDefaultOutputOrientationFlags,
.targetLuminanceNits = kClientTargetLuminanceNits,
.dimmingStage =
- aidl::android::hardware::graphics::composer3::DimmingStage::LINEAR})
+ aidl::android::hardware::graphics::composer3::DimmingStage::LINEAR,
+ .renderIntent = aidl::android::hardware::graphics::composer3::RenderIntent::
+ COLORIMETRIC})
.execute()
.expectAFenceWasReturned();
}
@@ -3767,7 +3781,8 @@
.andIfUsesHdr(true)
.withDisplayBrightnessNits(kDisplayLuminance)
.withDimmingStage(aidl::android::hardware::graphics::composer3::DimmingStage::LINEAR)
-
+ .withRenderIntent(
+ aidl::android::hardware::graphics::composer3::RenderIntent::COLORIMETRIC)
.andIfSkipColorTransform(false)
.thenExpectDisplaySettingsUsed(
{.physicalDisplay = kDefaultOutputDestinationClip,
@@ -3780,7 +3795,9 @@
.orientation = kDefaultOutputOrientationFlags,
.targetLuminanceNits = kClientTargetLuminanceNits,
.dimmingStage =
- aidl::android::hardware::graphics::composer3::DimmingStage::LINEAR})
+ aidl::android::hardware::graphics::composer3::DimmingStage::LINEAR,
+ .renderIntent = aidl::android::hardware::graphics::composer3::RenderIntent::
+ COLORIMETRIC})
.execute()
.expectAFenceWasReturned();
}
@@ -3792,29 +3809,8 @@
.withDisplayBrightnessNits(kUnknownLuminance)
.withDimmingStage(
aidl::android::hardware::graphics::composer3::DimmingStage::GAMMA_OETF)
-
- .andIfSkipColorTransform(false)
- .thenExpectDisplaySettingsUsed({.physicalDisplay = kDefaultOutputDestinationClip,
- .clip = kDefaultOutputViewport,
- .maxLuminance = kDefaultMaxLuminance,
- .currentLuminanceNits = kDefaultMaxLuminance,
- .outputDataspace = kDefaultOutputDataspace,
- .colorTransform = kDefaultColorTransformMat,
- .deviceHandlesColorTransform = true,
- .orientation = kDefaultOutputOrientationFlags,
- .targetLuminanceNits = kClientTargetLuminanceNits,
- .dimmingStage = aidl::android::hardware::graphics::
- composer3::DimmingStage::GAMMA_OETF})
- .execute()
- .expectAFenceWasReturned();
-}
-
-TEST_F(OutputComposeSurfacesTest_UsesExpectedDisplaySettings, forNonHdrMixedComposition) {
- verify().ifMixedCompositionIs(true)
- .andIfUsesHdr(false)
- .withDisplayBrightnessNits(kUnknownLuminance)
- .withDimmingStage(aidl::android::hardware::graphics::composer3::DimmingStage::LINEAR)
-
+ .withRenderIntent(
+ aidl::android::hardware::graphics::composer3::RenderIntent::COLORIMETRIC)
.andIfSkipColorTransform(false)
.thenExpectDisplaySettingsUsed(
{.physicalDisplay = kDefaultOutputDestinationClip,
@@ -3827,7 +3823,61 @@
.orientation = kDefaultOutputOrientationFlags,
.targetLuminanceNits = kClientTargetLuminanceNits,
.dimmingStage =
- aidl::android::hardware::graphics::composer3::DimmingStage::LINEAR})
+ aidl::android::hardware::graphics::composer3::DimmingStage::GAMMA_OETF,
+ .renderIntent = aidl::android::hardware::graphics::composer3::RenderIntent::
+ COLORIMETRIC})
+ .execute()
+ .expectAFenceWasReturned();
+}
+
+TEST_F(OutputComposeSurfacesTest_UsesExpectedDisplaySettings,
+ forHdrMixedCompositionWithRenderIntent) {
+ verify().ifMixedCompositionIs(true)
+ .andIfUsesHdr(true)
+ .withDisplayBrightnessNits(kUnknownLuminance)
+ .withDimmingStage(aidl::android::hardware::graphics::composer3::DimmingStage::LINEAR)
+ .withRenderIntent(aidl::android::hardware::graphics::composer3::RenderIntent::ENHANCE)
+ .andIfSkipColorTransform(false)
+ .thenExpectDisplaySettingsUsed(
+ {.physicalDisplay = kDefaultOutputDestinationClip,
+ .clip = kDefaultOutputViewport,
+ .maxLuminance = kDefaultMaxLuminance,
+ .currentLuminanceNits = kDefaultMaxLuminance,
+ .outputDataspace = kDefaultOutputDataspace,
+ .colorTransform = kDefaultColorTransformMat,
+ .deviceHandlesColorTransform = true,
+ .orientation = kDefaultOutputOrientationFlags,
+ .targetLuminanceNits = kClientTargetLuminanceNits,
+ .dimmingStage =
+ aidl::android::hardware::graphics::composer3::DimmingStage::LINEAR,
+ .renderIntent =
+ aidl::android::hardware::graphics::composer3::RenderIntent::ENHANCE})
+ .execute()
+ .expectAFenceWasReturned();
+}
+
+TEST_F(OutputComposeSurfacesTest_UsesExpectedDisplaySettings, forNonHdrMixedComposition) {
+ verify().ifMixedCompositionIs(true)
+ .andIfUsesHdr(false)
+ .withDisplayBrightnessNits(kUnknownLuminance)
+ .withDimmingStage(aidl::android::hardware::graphics::composer3::DimmingStage::LINEAR)
+ .withRenderIntent(
+ aidl::android::hardware::graphics::composer3::RenderIntent::COLORIMETRIC)
+ .andIfSkipColorTransform(false)
+ .thenExpectDisplaySettingsUsed(
+ {.physicalDisplay = kDefaultOutputDestinationClip,
+ .clip = kDefaultOutputViewport,
+ .maxLuminance = kDefaultMaxLuminance,
+ .currentLuminanceNits = kDefaultMaxLuminance,
+ .outputDataspace = kDefaultOutputDataspace,
+ .colorTransform = kDefaultColorTransformMat,
+ .deviceHandlesColorTransform = true,
+ .orientation = kDefaultOutputOrientationFlags,
+ .targetLuminanceNits = kClientTargetLuminanceNits,
+ .dimmingStage =
+ aidl::android::hardware::graphics::composer3::DimmingStage::LINEAR,
+ .renderIntent = aidl::android::hardware::graphics::composer3::RenderIntent::
+ COLORIMETRIC})
.execute()
.expectAFenceWasReturned();
}
@@ -3837,7 +3887,8 @@
.andIfUsesHdr(true)
.withDisplayBrightnessNits(kUnknownLuminance)
.withDimmingStage(aidl::android::hardware::graphics::composer3::DimmingStage::LINEAR)
-
+ .withRenderIntent(
+ aidl::android::hardware::graphics::composer3::RenderIntent::COLORIMETRIC)
.andIfSkipColorTransform(false)
.thenExpectDisplaySettingsUsed(
{.physicalDisplay = kDefaultOutputDestinationClip,
@@ -3850,7 +3901,9 @@
.orientation = kDefaultOutputOrientationFlags,
.targetLuminanceNits = kClientTargetLuminanceNits,
.dimmingStage =
- aidl::android::hardware::graphics::composer3::DimmingStage::LINEAR})
+ aidl::android::hardware::graphics::composer3::DimmingStage::LINEAR,
+ .renderIntent = aidl::android::hardware::graphics::composer3::RenderIntent::
+ COLORIMETRIC})
.execute()
.expectAFenceWasReturned();
}
@@ -3860,7 +3913,8 @@
.andIfUsesHdr(false)
.withDisplayBrightnessNits(kUnknownLuminance)
.withDimmingStage(aidl::android::hardware::graphics::composer3::DimmingStage::LINEAR)
-
+ .withRenderIntent(
+ aidl::android::hardware::graphics::composer3::RenderIntent::COLORIMETRIC)
.andIfSkipColorTransform(false)
.thenExpectDisplaySettingsUsed(
{.physicalDisplay = kDefaultOutputDestinationClip,
@@ -3873,7 +3927,9 @@
.orientation = kDefaultOutputOrientationFlags,
.targetLuminanceNits = kClientTargetLuminanceNits,
.dimmingStage =
- aidl::android::hardware::graphics::composer3::DimmingStage::LINEAR})
+ aidl::android::hardware::graphics::composer3::DimmingStage::LINEAR,
+ .renderIntent = aidl::android::hardware::graphics::composer3::RenderIntent::
+ COLORIMETRIC})
.execute()
.expectAFenceWasReturned();
}
@@ -3884,7 +3940,8 @@
.andIfUsesHdr(true)
.withDisplayBrightnessNits(kUnknownLuminance)
.withDimmingStage(aidl::android::hardware::graphics::composer3::DimmingStage::LINEAR)
-
+ .withRenderIntent(
+ aidl::android::hardware::graphics::composer3::RenderIntent::COLORIMETRIC)
.andIfSkipColorTransform(true)
.thenExpectDisplaySettingsUsed(
{.physicalDisplay = kDefaultOutputDestinationClip,
@@ -3897,7 +3954,9 @@
.orientation = kDefaultOutputOrientationFlags,
.targetLuminanceNits = kClientTargetLuminanceNits,
.dimmingStage =
- aidl::android::hardware::graphics::composer3::DimmingStage::LINEAR})
+ aidl::android::hardware::graphics::composer3::DimmingStage::LINEAR,
+ .renderIntent = aidl::android::hardware::graphics::composer3::RenderIntent::
+ COLORIMETRIC})
.execute()
.expectAFenceWasReturned();
}
diff --git a/services/surfaceflinger/DisplayDevice.cpp b/services/surfaceflinger/DisplayDevice.cpp
index 3651c8b..65e7a7f 100644
--- a/services/surfaceflinger/DisplayDevice.cpp
+++ b/services/surfaceflinger/DisplayDevice.cpp
@@ -299,26 +299,24 @@
sPrimaryDisplayRotationFlags = ui::Transform::toRotationFlags(orientation);
}
- if (!orientedDisplaySpaceRect.isValid()) {
- // The destination frame can be invalid if it has never been set,
- // in that case we assume the whole display size.
- orientedDisplaySpaceRect =
- getCompositionDisplay()->getState().displaySpace.getBoundsAsRect();
- }
-
- if (layerStackSpaceRect.isEmpty()) {
- // The layerStackSpaceRect can be invalid if it has never been set, in that case
- // we assume the whole framebuffer size.
- layerStackSpaceRect =
- getCompositionDisplay()->getState().framebufferSpace.getBoundsAsRect();
- if (orientation == ui::ROTATION_90 || orientation == ui::ROTATION_270) {
- std::swap(layerStackSpaceRect.right, layerStackSpaceRect.bottom);
- }
- }
-
// We need to take care of display rotation for globalTransform for case if the panel is not
// installed aligned with device orientation.
const auto transformOrientation = orientation + mPhysicalOrientation;
+
+ const auto& state = getCompositionDisplay()->getState();
+
+ // If the layer stack and destination frames have never been set, then configure them to be the
+ // same as the physical device, taking into account the total transform.
+ if (!orientedDisplaySpaceRect.isValid()) {
+ ui::Size bounds = state.displaySpace.getBounds();
+ bounds.rotate(transformOrientation);
+ orientedDisplaySpaceRect = Rect(bounds);
+ }
+ if (layerStackSpaceRect.isEmpty()) {
+ ui::Size bounds = state.framebufferSpace.getBounds();
+ bounds.rotate(transformOrientation);
+ layerStackSpaceRect = Rect(bounds);
+ }
getCompositionDisplay()->setProjection(transformOrientation, layerStackSpaceRect,
orientedDisplaySpaceRect);
}
diff --git a/services/surfaceflinger/DisplayHardware/PowerAdvisor.cpp b/services/surfaceflinger/DisplayHardware/PowerAdvisor.cpp
index 05f488b..cbafdd3 100644
--- a/services/surfaceflinger/DisplayHardware/PowerAdvisor.cpp
+++ b/services/surfaceflinger/DisplayHardware/PowerAdvisor.cpp
@@ -463,29 +463,41 @@
ALOGV("Failed to send actual work duration, skipping");
return;
}
-
- WorkDuration duration;
- duration.durationNanos = actualDurationNanos;
- mActualDuration = actualDurationNanos;
+ nsecs_t reportedDuration = actualDurationNanos;
// normalize the sent values to a pre-set target
if (sNormalizeTarget) {
- duration.durationNanos += mLastTargetDurationSent - mTargetDuration;
+ reportedDuration += mLastTargetDurationSent - mTargetDuration;
+ } else {
+ // when target duration change is within deviation and not updated, adjust the actual
+ // duration proportionally based on the difference, e.g. if new target is 5ms longer than
+ // last reported but actual duration is the same as last target, we want to report a smaller
+ // actual work duration now to indicate that we are overshooting
+ if (mLastTargetDurationSent != kDefaultTarget.count() && mTargetDuration != 0) {
+ reportedDuration =
+ static_cast<int64_t>(static_cast<long double>(mLastTargetDurationSent) /
+ mTargetDuration * actualDurationNanos);
+ mActualDuration = reportedDuration;
+ }
}
+ mActualDuration = reportedDuration;
+ WorkDuration duration;
+ duration.durationNanos = reportedDuration;
duration.timeStampNanos = timeStampNanos;
mPowerHintQueue.push_back(duration);
- nsecs_t targetNsec = mTargetDuration;
- nsecs_t durationNsec = actualDurationNanos;
-
if (sTraceHintSessionData) {
- ATRACE_INT64("Measured duration", durationNsec);
- ATRACE_INT64("Target error term", targetNsec - durationNsec);
+ ATRACE_INT64("Measured duration", actualDurationNanos);
+ ATRACE_INT64("Target error term", mTargetDuration - actualDurationNanos);
+
+ ATRACE_INT64("Reported duration", reportedDuration);
+ ATRACE_INT64("Reported target", mLastTargetDurationSent);
+ ATRACE_INT64("Reported target error term", mLastTargetDurationSent - reportedDuration);
}
- ALOGV("Sending actual work duration of: %" PRId64 " on target: %" PRId64
+ ALOGV("Sending actual work duration of: %" PRId64 " on reported target: %" PRId64
" with error: %" PRId64,
- durationNsec, targetNsec, targetNsec - durationNsec);
+ reportedDuration, mLastTargetDurationSent, mLastTargetDurationSent - reportedDuration);
// This rate limiter queues similar duration reports to the powerhal into
// batches to avoid excessive binder calls. The criteria to send a given batch
@@ -501,7 +513,7 @@
}
mPowerHintQueue.clear();
// we save the non-normalized value here to detect % changes
- mLastActualDurationSent = actualDurationNanos;
+ mLastActualDurationSent = reportedDuration;
}
}
diff --git a/services/surfaceflinger/DisplayHardware/PowerAdvisor.h b/services/surfaceflinger/DisplayHardware/PowerAdvisor.h
index 3f47ffd..61bb32b 100644
--- a/services/surfaceflinger/DisplayHardware/PowerAdvisor.h
+++ b/services/surfaceflinger/DisplayHardware/PowerAdvisor.h
@@ -173,8 +173,8 @@
// Max percent the actual duration can vary without causing a report (eg: 0.1 = 10%)
static constexpr double kAllowedActualDeviationPercent = 0.1;
- // Max percent the target duration can vary without causing a report (eg: 0.05 = 5%)
- static constexpr double kAllowedTargetDeviationPercent = 0.05;
+ // Max percent the target duration can vary without causing a report (eg: 0.1 = 10%)
+ static constexpr double kAllowedTargetDeviationPercent = 0.1;
// Target used for init and normalization, the actual value does not really matter
static constexpr const std::chrono::nanoseconds kDefaultTarget = 50ms;
// Amount of time after the last message was sent before the session goes stale
diff --git a/services/surfaceflinger/SurfaceFlinger.cpp b/services/surfaceflinger/SurfaceFlinger.cpp
index fb5d738..ccd218d 100644
--- a/services/surfaceflinger/SurfaceFlinger.cpp
+++ b/services/surfaceflinger/SurfaceFlinger.cpp
@@ -148,6 +148,7 @@
#include <aidl/android/hardware/graphics/common/DisplayDecorationSupport.h>
#include <aidl/android/hardware/graphics/composer3/DisplayCapability.h>
+#include <aidl/android/hardware/graphics/composer3/RenderIntent.h>
#undef NO_THREAD_SAFETY_ANALYSIS
#define NO_THREAD_SAFETY_ANALYSIS \
@@ -2346,7 +2347,12 @@
}
bool SurfaceFlinger::isHdrLayer(Layer* layer) const {
- if (!isHdrDataspace(layer->getDataSpace())) {
+ // Treat all layers as non-HDR if:
+ // 1. They do not have a valid HDR dataspace. Currently we treat those as PQ or HLG. and
+ // 2. The layer is allowed to be dimmed. WindowManager may disable dimming in order to
+ // keep animations invoking SDR screenshots of HDR layers seamless. Treat such tagged
+ // layers as HDR so that DisplayManagerService does not try to change the screen brightness
+ if (!isHdrDataspace(layer->getDataSpace()) && layer->isDimmingEnabled()) {
return false;
}
if (mIgnoreHdrCameraLayers) {
@@ -2730,12 +2736,12 @@
}
const auto displayId = info->id;
- const auto it = mPhysicalDisplayTokens.find(displayId);
+ const auto token = mPhysicalDisplayTokens.get(displayId);
if (event.connection == hal::Connection::CONNECTED) {
auto [supportedModes, activeMode] = loadDisplayModes(displayId);
- if (it == mPhysicalDisplayTokens.end()) {
+ if (!token) {
ALOGV("Creating display %s", to_string(displayId).c_str());
DisplayDeviceState state;
@@ -2750,14 +2756,13 @@
sp<IBinder> token = new BBinder();
mCurrentState.displays.add(token, state);
- mPhysicalDisplayTokens.emplace(displayId, std::move(token));
+ mPhysicalDisplayTokens.try_emplace(displayId, std::move(token));
mInterceptor->saveDisplayCreation(state);
} else {
ALOGV("Recreating display %s", to_string(displayId).c_str());
- const auto token = it->second;
- auto& state = mCurrentState.displays.editValueFor(token);
- state.sequenceId = DisplayDeviceState{}.sequenceId; // Generate new sequenceId
+ auto& state = mCurrentState.displays.editValueFor(token->get());
+ state.sequenceId = DisplayDeviceState{}.sequenceId; // Generate new sequenceId.
state.physical->supportedModes = std::move(supportedModes);
state.physical->activeMode = std::move(activeMode);
if (getHwComposer().updatesDeviceProductInfoOnHotplugReconnect()) {
@@ -2767,13 +2772,13 @@
} else {
ALOGV("Removing display %s", to_string(displayId).c_str());
- const ssize_t index = mCurrentState.displays.indexOfKey(it->second);
- if (index >= 0) {
+ if (const ssize_t index = mCurrentState.displays.indexOfKey(token->get()); index >= 0) {
const DisplayDeviceState& state = mCurrentState.displays.valueAt(index);
mInterceptor->saveDisplayDeletion(state.sequenceId);
mCurrentState.displays.removeItemsAt(index);
}
- mPhysicalDisplayTokens.erase(it);
+
+ mPhysicalDisplayTokens.erase(displayId);
}
processDisplayChangesLocked();
@@ -2954,15 +2959,16 @@
}
LOG_FATAL_IF(!displaySurface);
- const auto display = setupNewDisplayDeviceInternal(displayToken, std::move(compositionDisplay),
- state, displaySurface, producer);
- mDisplays.emplace(displayToken, display);
+ auto display = setupNewDisplayDeviceInternal(displayToken, std::move(compositionDisplay), state,
+ displaySurface, producer);
if (display->isPrimary()) {
initScheduler(display);
}
if (!state.isVirtual()) {
dispatchDisplayHotplugEvent(display->getPhysicalId(), true);
}
+
+ mDisplays.try_emplace(displayToken, std::move(display));
}
void SurfaceFlinger::processDisplayRemoved(const wp<IBinder>& displayToken) {
@@ -3603,6 +3609,23 @@
if (mNumLayers >= ISurfaceComposer::MAX_LAYERS) {
ALOGE("AddClientLayer failed, mNumLayers (%zu) >= MAX_LAYERS (%zu)", mNumLayers.load(),
ISurfaceComposer::MAX_LAYERS);
+ static_cast<void>(mScheduler->schedule([=] {
+ ALOGE("Dumping random sampling of on-screen layers: ");
+ mDrawingState.traverse([&](Layer *layer) {
+ // Aim to dump about 200 layers to avoid totally trashing
+ // logcat. On the other hand, if there really are 4096 layers
+ // something has gone totally wrong its probably the most
+ // useful information in logcat.
+ if (rand() % 20 == 13) {
+ ALOGE("Layer: %s", layer->getName().c_str());
+ }
+ });
+ for (Layer* offscreenLayer : mOffscreenLayers) {
+ if (rand() % 20 == 13) {
+ ALOGE("Offscreen-layer: %s", offscreenLayer->getName().c_str());
+ }
+ }
+ }));
return NO_MEMORY;
}
@@ -6672,6 +6695,7 @@
captureResults.buffer = buffer->getBuffer();
auto dataspace = renderArea.getReqDataSpace();
auto parent = renderArea.getParentLayer();
+ auto renderIntent = RenderIntent::TONE_MAP_COLORIMETRIC;
if ((dataspace == ui::Dataspace::UNKNOWN) && (parent != nullptr)) {
Mutex::Autolock lock(mStateLock);
auto display = findDisplay([layerStack = parent->getLayerStack()](const auto& display) {
@@ -6684,6 +6708,7 @@
const ui::ColorMode colorMode = display->getCompositionDisplay()->getState().colorMode;
dataspace = pickDataspaceFromColorMode(colorMode);
+ renderIntent = display->getCompositionDisplay()->getState().renderIntent;
}
captureResults.capturedDataspace = dataspace;
@@ -6705,6 +6730,8 @@
clientCompositionDisplay.outputDataspace = dataspace;
clientCompositionDisplay.maxLuminance = DisplayDevice::sDefaultMaxLumiance;
+ clientCompositionDisplay.renderIntent =
+ static_cast<aidl::android::hardware::graphics::composer3::RenderIntent>(renderIntent);
const float colorSaturation = grayscale ? 0 : 1;
clientCompositionDisplay.colorTransform = calculateColorMatrix(colorSaturation);
diff --git a/services/surfaceflinger/SurfaceFlinger.h b/services/surfaceflinger/SurfaceFlinger.h
index 07da731..011aaef 100644
--- a/services/surfaceflinger/SurfaceFlinger.h
+++ b/services/surfaceflinger/SurfaceFlinger.h
@@ -27,6 +27,7 @@
#include <android/gui/DisplayState.h>
#include <cutils/atomic.h>
#include <cutils/compiler.h>
+#include <ftl/small_map.h>
#include <gui/BufferQueue.h>
#include <gui/FrameTimestamps.h>
#include <gui/ISurfaceComposer.h>
@@ -905,8 +906,8 @@
}
sp<DisplayDevice> getDisplayDeviceLocked(const wp<IBinder>& displayToken) REQUIRES(mStateLock) {
- const auto it = mDisplays.find(displayToken);
- return it == mDisplays.end() ? nullptr : it->second;
+ const sp<DisplayDevice> nullDisplay;
+ return mDisplays.get(displayToken).value_or(std::cref(nullDisplay));
}
sp<const DisplayDevice> getDisplayDeviceLocked(PhysicalDisplayId id) const
@@ -1051,8 +1052,8 @@
*/
sp<IBinder> getPhysicalDisplayTokenLocked(PhysicalDisplayId displayId) const
REQUIRES(mStateLock) {
- const auto it = mPhysicalDisplayTokens.find(displayId);
- return it != mPhysicalDisplayTokens.end() ? it->second : nullptr;
+ const sp<IBinder> nullToken;
+ return mPhysicalDisplayTokens.get(displayId).value_or(std::cref(nullToken));
}
std::optional<PhysicalDisplayId> getPhysicalDisplayIdLocked(
@@ -1247,10 +1248,14 @@
std::vector<HotplugEvent> mPendingHotplugEvents GUARDED_BY(mStateLock);
- // this may only be written from the main thread with mStateLock held
- // it may be read from other threads with mStateLock held
- std::map<wp<IBinder>, sp<DisplayDevice>> mDisplays GUARDED_BY(mStateLock);
- std::unordered_map<PhysicalDisplayId, sp<IBinder>> mPhysicalDisplayTokens
+ // Displays are composited in `mDisplays` order. Internal displays are inserted at boot and
+ // never removed, so take precedence over external and virtual displays.
+ //
+ // The static capacities were chosen to exceed a typical number of physical/virtual displays.
+ //
+ // May be read from any thread, but must only be written from the main thread.
+ ftl::SmallMap<wp<IBinder>, const sp<DisplayDevice>, 5> mDisplays GUARDED_BY(mStateLock);
+ ftl::SmallMap<PhysicalDisplayId, const sp<IBinder>, 3> mPhysicalDisplayTokens
GUARDED_BY(mStateLock);
struct {
@@ -1423,10 +1428,8 @@
std::atomic<ui::Transform::RotationFlags> mActiveDisplayTransformHint;
bool isRefreshRateOverlayEnabled() const REQUIRES(mStateLock) {
- return std::any_of(mDisplays.begin(), mDisplays.end(),
- [](std::pair<wp<IBinder>, sp<DisplayDevice>> display) {
- return display.second->isRefreshRateOverlayEnabled();
- });
+ return hasDisplay(
+ [](const auto& display) { return display.isRefreshRateOverlayEnabled(); });
}
wp<IBinder> mActiveDisplayToken GUARDED_BY(mStateLock);
diff --git a/services/surfaceflinger/tests/unittests/AidlPowerHalWrapperTest.cpp b/services/surfaceflinger/tests/unittests/AidlPowerHalWrapperTest.cpp
index e25a0ae..9ab35d7 100644
--- a/services/surfaceflinger/tests/unittests/AidlPowerHalWrapperTest.cpp
+++ b/services/surfaceflinger/tests/unittests/AidlPowerHalWrapperTest.cpp
@@ -17,6 +17,7 @@
#undef LOG_TAG
#define LOG_TAG "AidlPowerHalWrapperTest"
+#include <android-base/stringprintf.h>
#include <android/hardware/power/IPower.h>
#include <android/hardware/power/IPowerHintSession.h>
#include <gmock/gmock.h>
@@ -82,6 +83,15 @@
return duration;
}
+std::string printWorkDurations(const ::std::vector<WorkDuration>& durations) {
+ std::ostringstream os;
+ for (auto duration : durations) {
+ os << duration.toString();
+ os << "\n";
+ }
+ return os.str();
+}
+
namespace {
TEST_F(AidlPowerHalWrapperTest, supportsPowerHintSession) {
ASSERT_TRUE(mWrapper->supportsPowerHintSession());
@@ -143,8 +153,8 @@
{-1ms, false},
{200ms, true},
{2ms, true},
- {96ms, false},
- {104ms, false}};
+ {91ms, false},
+ {109ms, false}};
for (const auto& test : testCases) {
// reset to 100ms baseline
@@ -212,6 +222,40 @@
}
}
+TEST_F(AidlPowerHalWrapperTest, sendAdjustedActualWorkDuration) {
+ ASSERT_TRUE(mWrapper->supportsPowerHintSession());
+
+ std::vector<int32_t> threadIds = {1, 2};
+ mWrapper->setPowerHintSessionThreadIds(threadIds);
+ EXPECT_CALL(*mMockHal.get(), createHintSession(_, _, threadIds, _, _))
+ .WillOnce(DoAll(SetArgPointee<4>(mMockSession), Return(Status::ok())));
+ ASSERT_TRUE(mWrapper->startPowerHintSession());
+ verifyAndClearExpectations();
+
+ std::chrono::nanoseconds lastTarget = 100ms;
+ EXPECT_CALL(*mMockSession.get(), updateTargetWorkDuration(lastTarget.count())).Times(1);
+ mWrapper->setTargetWorkDuration(lastTarget.count());
+ std::chrono::nanoseconds newTarget = 105ms;
+ mWrapper->setTargetWorkDuration(newTarget.count());
+ EXPECT_CALL(*mMockSession.get(), updateTargetWorkDuration(newTarget.count())).Times(0);
+ std::chrono::nanoseconds actual = 21ms;
+ // 100 / 105 * 21ms = 20ms
+ std::chrono::nanoseconds expectedActualSent = 20ms;
+ std::vector<WorkDuration> expectedDurations = {toWorkDuration(expectedActualSent, 1)};
+
+ EXPECT_CALL(*mMockSession.get(), reportActualWorkDuration(_))
+ .WillOnce(DoAll(
+ [expectedDurations](const ::std::vector<WorkDuration>& durationsSent) {
+ EXPECT_EQ(expectedDurations, durationsSent)
+ << base::StringPrintf("actual sent: %s vs expected: %s",
+ printWorkDurations(durationsSent).c_str(),
+ printWorkDurations(expectedDurations)
+ .c_str());
+ },
+ Return(Status::ok())));
+ mWrapper->sendActualWorkDuration(actual.count(), 1);
+}
+
TEST_F(AidlPowerHalWrapperTest, sendActualWorkDuration_exceedsStaleTime) {
ASSERT_TRUE(mWrapper->supportsPowerHintSession());
diff --git a/services/surfaceflinger/tests/unittests/DisplayDevice_SetProjectionTest.cpp b/services/surfaceflinger/tests/unittests/DisplayDevice_SetProjectionTest.cpp
index 3d24ecb..5734d34 100644
--- a/services/surfaceflinger/tests/unittests/DisplayDevice_SetProjectionTest.cpp
+++ b/services/surfaceflinger/tests/unittests/DisplayDevice_SetProjectionTest.cpp
@@ -21,6 +21,7 @@
#include <gmock/gmock.h>
#include <gtest/gtest.h>
+#include <ui/Rotation.h>
namespace android {
namespace {
@@ -53,6 +54,11 @@
ui::Size swapWH(const ui::Size size) const { return ui::Size(size.height, size.width); }
+ void setDefaultProjection() {
+ // INVALID_RECT pulls from the physical display dimensions.
+ mDisplayDevice->setProjection(ui::ROTATION_0, Rect::INVALID_RECT, Rect::INVALID_RECT);
+ }
+
void setProjectionForRotation0() {
// A logical rotation of 0 uses the SurfaceFlinger display size
mDisplayDevice->setProjection(ui::ROTATION_0, Rect(mFlingerDisplaySize),
@@ -79,6 +85,30 @@
Rect(swapWH(mFlingerDisplaySize)));
}
+ void expectDefaultState() {
+ const auto& compositionState = mDisplayDevice->getCompositionDisplay()->getState();
+ EXPECT_EQ(ui::Transform(ui::Transform::toRotationFlags(mPhysicalOrientation),
+ mHardwareDisplaySize.width, mHardwareDisplaySize.height),
+ compositionState.transform);
+ EXPECT_EQ(mPhysicalOrientation, compositionState.displaySpace.getOrientation());
+ EXPECT_EQ(Rect(mHardwareDisplaySize), compositionState.displaySpace.getContent());
+ EXPECT_EQ(mHardwareDisplaySize, compositionState.displaySpace.getBounds());
+ EXPECT_EQ(Rect(mHardwareDisplaySize), compositionState.framebufferSpace.getContent());
+ EXPECT_EQ(mHardwareDisplaySize, compositionState.framebufferSpace.getBounds());
+
+ const ui::Size expectedLogicalSize = (mPhysicalOrientation == ui::ROTATION_270 ||
+ mPhysicalOrientation == ui::ROTATION_90)
+ ? swapWH(mHardwareDisplaySize)
+ : mHardwareDisplaySize;
+
+ EXPECT_EQ(Rect(expectedLogicalSize), compositionState.orientedDisplaySpace.getContent());
+ EXPECT_EQ(expectedLogicalSize, compositionState.orientedDisplaySpace.getBounds());
+ EXPECT_EQ(Rect(expectedLogicalSize), compositionState.layerStackSpace.getContent());
+ EXPECT_EQ(expectedLogicalSize, compositionState.layerStackSpace.getBounds());
+
+ EXPECT_EQ(false, compositionState.needsFiltering);
+ }
+
void expectStateForHardwareTransform0() {
const auto& compositionState = mDisplayDevice->getCompositionDisplay()->getState();
EXPECT_EQ(ui::Transform(TRANSFORM_FLAGS_ROT_0, mHardwareDisplaySize.width,
@@ -147,6 +177,11 @@
ui::ROTATION_0) {}
};
+TEST_F(DisplayDeviceSetProjectionTest_Installed0, checkDefaultProjection) {
+ setDefaultProjection();
+ expectDefaultState();
+}
+
TEST_F(DisplayDeviceSetProjectionTest_Installed0, checkWith0OutputRotation) {
setProjectionForRotation0();
expectStateForHardwareTransform0();
@@ -174,6 +209,11 @@
ui::ROTATION_90) {}
};
+TEST_F(DisplayDeviceSetProjectionTest_Installed90, checkDefaultProjection) {
+ setDefaultProjection();
+ expectDefaultState();
+}
+
TEST_F(DisplayDeviceSetProjectionTest_Installed90, checkWith0OutputRotation) {
setProjectionForRotation0();
expectStateForHardwareTransform90();
@@ -201,6 +241,11 @@
ui::ROTATION_180) {}
};
+TEST_F(DisplayDeviceSetProjectionTest_Installed180, checkDefaultProjection) {
+ setDefaultProjection();
+ expectDefaultState();
+}
+
TEST_F(DisplayDeviceSetProjectionTest_Installed180, checkWith0OutputRotation) {
setProjectionForRotation0();
expectStateForHardwareTransform180();
@@ -228,6 +273,11 @@
ui::ROTATION_270) {}
};
+TEST_F(DisplayDeviceSetProjectionTest_Installed270, checkDefaultProjection) {
+ setDefaultProjection();
+ expectDefaultState();
+}
+
TEST_F(DisplayDeviceSetProjectionTest_Installed270, checkWith0OutputRotation) {
setProjectionForRotation0();
expectStateForHardwareTransform270();
diff --git a/services/surfaceflinger/tests/unittests/DisplayTransactionTest.cpp b/services/surfaceflinger/tests/unittests/DisplayTransactionTest.cpp
index 2425862..f04221c 100644
--- a/services/surfaceflinger/tests/unittests/DisplayTransactionTest.cpp
+++ b/services/surfaceflinger/tests/unittests/DisplayTransactionTest.cpp
@@ -165,36 +165,39 @@
return displayDevice;
}
-bool DisplayTransactionTest::hasPhysicalHwcDisplay(HWDisplayId hwcDisplayId) {
- return mFlinger.mutableHwcPhysicalDisplayIdMap().count(hwcDisplayId) == 1;
+bool DisplayTransactionTest::hasPhysicalHwcDisplay(HWDisplayId hwcDisplayId) const {
+ return mFlinger.hwcPhysicalDisplayIdMap().count(hwcDisplayId) == 1;
}
-bool DisplayTransactionTest::hasTransactionFlagSet(int flag) {
- return mFlinger.mutableTransactionFlags() & flag;
+bool DisplayTransactionTest::hasTransactionFlagSet(int32_t flag) const {
+ return mFlinger.transactionFlags() & flag;
}
-bool DisplayTransactionTest::hasDisplayDevice(sp<IBinder> displayToken) {
- return mFlinger.mutableDisplays().count(displayToken) == 1;
+bool DisplayTransactionTest::hasDisplayDevice(const sp<IBinder>& displayToken) const {
+ return mFlinger.displays().contains(displayToken);
}
-sp<DisplayDevice> DisplayTransactionTest::getDisplayDevice(sp<IBinder> displayToken) {
- return mFlinger.mutableDisplays()[displayToken];
+const DisplayDevice& DisplayTransactionTest::getDisplayDevice(
+ const sp<IBinder>& displayToken) const {
+ return *mFlinger.displays().get(displayToken)->get();
}
-bool DisplayTransactionTest::hasCurrentDisplayState(sp<IBinder> displayToken) {
- return mFlinger.mutableCurrentState().displays.indexOfKey(displayToken) >= 0;
+bool DisplayTransactionTest::hasCurrentDisplayState(const sp<IBinder>& displayToken) const {
+ return mFlinger.currentState().displays.indexOfKey(displayToken) >= 0;
}
-const DisplayDeviceState& DisplayTransactionTest::getCurrentDisplayState(sp<IBinder> displayToken) {
- return mFlinger.mutableCurrentState().displays.valueFor(displayToken);
+const DisplayDeviceState& DisplayTransactionTest::getCurrentDisplayState(
+ const sp<IBinder>& displayToken) const {
+ return mFlinger.currentState().displays.valueFor(displayToken);
}
-bool DisplayTransactionTest::hasDrawingDisplayState(sp<IBinder> displayToken) {
- return mFlinger.mutableDrawingState().displays.indexOfKey(displayToken) >= 0;
+bool DisplayTransactionTest::hasDrawingDisplayState(const sp<IBinder>& displayToken) const {
+ return mFlinger.drawingState().displays.indexOfKey(displayToken) >= 0;
}
-const DisplayDeviceState& DisplayTransactionTest::getDrawingDisplayState(sp<IBinder> displayToken) {
- return mFlinger.mutableDrawingState().displays.valueFor(displayToken);
+const DisplayDeviceState& DisplayTransactionTest::getDrawingDisplayState(
+ const sp<IBinder>& displayToken) const {
+ return mFlinger.drawingState().displays.valueFor(displayToken);
}
} // namespace android
diff --git a/services/surfaceflinger/tests/unittests/DisplayTransactionTestHelpers.h b/services/surfaceflinger/tests/unittests/DisplayTransactionTestHelpers.h
index 565c244..f5235ce 100644
--- a/services/surfaceflinger/tests/unittests/DisplayTransactionTestHelpers.h
+++ b/services/surfaceflinger/tests/unittests/DisplayTransactionTestHelpers.h
@@ -95,14 +95,17 @@
// --------------------------------------------------------------------
// Postcondition helpers
- bool hasPhysicalHwcDisplay(hal::HWDisplayId hwcDisplayId);
- bool hasTransactionFlagSet(int flag);
- bool hasDisplayDevice(sp<IBinder> displayToken);
- sp<DisplayDevice> getDisplayDevice(sp<IBinder> displayToken);
- bool hasCurrentDisplayState(sp<IBinder> displayToken);
- const DisplayDeviceState& getCurrentDisplayState(sp<IBinder> displayToken);
- bool hasDrawingDisplayState(sp<IBinder> displayToken);
- const DisplayDeviceState& getDrawingDisplayState(sp<IBinder> displayToken);
+ bool hasPhysicalHwcDisplay(hal::HWDisplayId) const;
+ bool hasTransactionFlagSet(int32_t flag) const;
+
+ bool hasDisplayDevice(const sp<IBinder>& displayToken) const;
+ const DisplayDevice& getDisplayDevice(const sp<IBinder>& displayToken) const;
+
+ bool hasCurrentDisplayState(const sp<IBinder>& displayToken) const;
+ const DisplayDeviceState& getCurrentDisplayState(const sp<IBinder>& displayToken) const;
+
+ bool hasDrawingDisplayState(const sp<IBinder>& displayToken) const;
+ const DisplayDeviceState& getDrawingDisplayState(const sp<IBinder>& displayToken) const;
// --------------------------------------------------------------------
// Test instances
diff --git a/services/surfaceflinger/tests/unittests/SurfaceFlinger_DisplayModeSwitching.cpp b/services/surfaceflinger/tests/unittests/SurfaceFlinger_DisplayModeSwitching.cpp
index 32d57b5..5872a47 100644
--- a/services/surfaceflinger/tests/unittests/SurfaceFlinger_DisplayModeSwitching.cpp
+++ b/services/surfaceflinger/tests/unittests/SurfaceFlinger_DisplayModeSwitching.cpp
@@ -61,7 +61,6 @@
protected:
void setupScheduler(std::shared_ptr<scheduler::RefreshRateConfigs>);
- void testChangeRefreshRate(bool isDisplayActive, bool isRefreshRequired);
sp<DisplayDevice> mDisplay;
mock::EventThread* mAppEventThread;
diff --git a/services/surfaceflinger/tests/unittests/SurfaceFlinger_DisplayTransactionCommitTest.cpp b/services/surfaceflinger/tests/unittests/SurfaceFlinger_DisplayTransactionCommitTest.cpp
index 6959ee3..9ac2907 100644
--- a/services/surfaceflinger/tests/unittests/SurfaceFlinger_DisplayTransactionCommitTest.cpp
+++ b/services/surfaceflinger/tests/unittests/SurfaceFlinger_DisplayTransactionCommitTest.cpp
@@ -107,9 +107,10 @@
void DisplayTransactionCommitTest::verifyDisplayIsConnected(const sp<IBinder>& displayToken) {
// The display device should have been set up in the list of displays.
ASSERT_TRUE(hasDisplayDevice(displayToken));
- const auto& device = getDisplayDevice(displayToken);
- EXPECT_EQ(static_cast<bool>(Case::Display::SECURE), device->isSecure());
- EXPECT_EQ(static_cast<bool>(Case::Display::PRIMARY), device->isPrimary());
+ const auto& display = getDisplayDevice(displayToken);
+
+ EXPECT_EQ(static_cast<bool>(Case::Display::SECURE), display.isSecure());
+ EXPECT_EQ(static_cast<bool>(Case::Display::PRIMARY), display.isPrimary());
std::optional<DisplayDeviceState::Physical> expectedPhysical;
if (const auto connectionType = Case::Display::CONNECTION_TYPE::value) {
@@ -143,10 +144,11 @@
// SF should have a display token.
const auto displayId = Case::Display::DISPLAY_ID::get();
ASSERT_TRUE(PhysicalDisplayId::tryCast(displayId));
- ASSERT_EQ(mFlinger.mutablePhysicalDisplayTokens().count(displayId), 1);
- auto& displayToken = mFlinger.mutablePhysicalDisplayTokens()[displayId];
- verifyDisplayIsConnected<Case>(displayToken);
+ const auto displayTokenOpt = mFlinger.mutablePhysicalDisplayTokens().get(displayId);
+ ASSERT_TRUE(displayTokenOpt);
+
+ verifyDisplayIsConnected<Case>(displayTokenOpt->get());
}
void DisplayTransactionCommitTest::verifyDisplayIsNotConnected(const sp<IBinder>& displayToken) {
@@ -248,9 +250,9 @@
// SF should not have a display token.
const auto displayId = Case::Display::DISPLAY_ID::get();
ASSERT_TRUE(PhysicalDisplayId::tryCast(displayId));
- ASSERT_TRUE(mFlinger.mutablePhysicalDisplayTokens().count(displayId) == 0);
+ ASSERT_FALSE(mFlinger.mutablePhysicalDisplayTokens().contains(displayId));
- // The existing token should have been removed
+ // The existing token should have been removed.
verifyDisplayIsNotConnected(existing.token());
}
@@ -330,7 +332,7 @@
// SF should not have a display token.
const auto displayId = Case::Display::DISPLAY_ID::get();
ASSERT_TRUE(PhysicalDisplayId::tryCast(displayId));
- ASSERT_TRUE(mFlinger.mutablePhysicalDisplayTokens().count(displayId) == 0);
+ ASSERT_FALSE(mFlinger.mutablePhysicalDisplayTokens().contains(displayId));
}(),
testing::KilledBySignal(SIGABRT), "Primary display cannot be disconnected.");
}
@@ -369,15 +371,16 @@
// --------------------------------------------------------------------
// Postconditions
- // The existing token should have been removed
+ // The existing token should have been removed.
verifyDisplayIsNotConnected(existing.token());
const auto displayId = Case::Display::DISPLAY_ID::get();
ASSERT_TRUE(PhysicalDisplayId::tryCast(displayId));
- ASSERT_TRUE(mFlinger.mutablePhysicalDisplayTokens().count(displayId) == 1);
- EXPECT_NE(existing.token(), mFlinger.mutablePhysicalDisplayTokens()[displayId]);
- // A new display should be connected in its place
+ const auto displayTokenOpt = mFlinger.mutablePhysicalDisplayTokens().get(displayId);
+ ASSERT_TRUE(displayTokenOpt);
+ EXPECT_NE(existing.token(), displayTokenOpt->get());
+ // A new display should be connected in its place.
verifyPhysicalDisplayIsConnected<Case>();
// --------------------------------------------------------------------
diff --git a/services/surfaceflinger/tests/unittests/SurfaceFlinger_SetPowerModeInternalTest.cpp b/services/surfaceflinger/tests/unittests/SurfaceFlinger_SetPowerModeInternalTest.cpp
index 7948e60..583cf5f 100644
--- a/services/surfaceflinger/tests/unittests/SurfaceFlinger_SetPowerModeInternalTest.cpp
+++ b/services/surfaceflinger/tests/unittests/SurfaceFlinger_SetPowerModeInternalTest.cpp
@@ -406,7 +406,7 @@
display.inject();
// The display is set to PowerMode::ON
- getDisplayDevice(display.token())->setPowerMode(PowerMode::ON);
+ display.mutableDisplayDevice()->setPowerMode(PowerMode::ON);
// --------------------------------------------------------------------
// Invocation
diff --git a/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h b/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h
index 866d9eb..f1a69fb 100644
--- a/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h
+++ b/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h
@@ -517,6 +517,12 @@
* post-conditions.
*/
+ const auto& displays() const { return mFlinger->mDisplays; }
+ const auto& currentState() const { return mFlinger->mCurrentState; }
+ const auto& drawingState() const { return mFlinger->mDrawingState; }
+ const auto& transactionFlags() const { return mFlinger->mTransactionFlags; }
+ const auto& hwcPhysicalDisplayIdMap() const { return getHwComposer().mPhysicalDisplayIdMap; }
+
auto& mutableHasWideColorDisplay() { return SurfaceFlinger::hasWideColorDisplay; }
auto& mutableCurrentState() { return mFlinger->mCurrentState; }
@@ -755,7 +761,9 @@
return mFlinger.mutableCurrentState().displays.valueFor(mDisplayToken);
}
- auto& mutableDisplayDevice() { return mFlinger.mutableDisplays()[mDisplayToken]; }
+ const sp<DisplayDevice>& mutableDisplayDevice() {
+ return mFlinger.mutableDisplays().get(mDisplayToken)->get();
+ }
// If `configs` is nullptr, the injector creates RefreshRateConfigs from the `modes`.
// Otherwise, it uses `configs`, which the caller must create using the same `modes`.
@@ -862,12 +870,14 @@
if (!display->isVirtual()) {
display->setActiveMode(activeModeId);
}
- mFlinger.mutableDisplays().emplace(mDisplayToken, display);
+ mFlinger.mutableDisplays().emplace_or_replace(mDisplayToken, display);
+
mFlinger.mutableCurrentState().displays.add(mDisplayToken, state);
mFlinger.mutableDrawingState().displays.add(mDisplayToken, state);
if (const auto& physical = state.physical) {
- mFlinger.mutablePhysicalDisplayTokens()[physical->id] = mDisplayToken;
+ mFlinger.mutablePhysicalDisplayTokens().emplace_or_replace(physical->id,
+ mDisplayToken);
}
return display;
diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp
index 45bc4c9..c4b1487 100644
--- a/vulkan/libvulkan/swapchain.cpp
+++ b/vulkan/libvulkan/swapchain.cpp
@@ -299,6 +299,7 @@
}
void ReleaseSwapchainImage(VkDevice device,
+ bool shared_present,
ANativeWindow* window,
int release_fence,
Swapchain::Image& image,
@@ -330,7 +331,8 @@
}
image.dequeue_fence = -1;
- if (window) {
+ // It's invalid to call cancelBuffer on a shared buffer
+ if (window && !shared_present) {
window->cancelBuffer(window, image.buffer.get(), release_fence);
} else {
if (release_fence >= 0) {
@@ -364,9 +366,10 @@
if (swapchain->surface.swapchain_handle != HandleFromSwapchain(swapchain))
return;
for (uint32_t i = 0; i < swapchain->num_images; i++) {
- if (!swapchain->images[i].dequeued)
- ReleaseSwapchainImage(device, nullptr, -1, swapchain->images[i],
- true);
+ if (!swapchain->images[i].dequeued) {
+ ReleaseSwapchainImage(device, swapchain->shared, nullptr, -1,
+ swapchain->images[i], true);
+ }
}
swapchain->surface.swapchain_handle = VK_NULL_HANDLE;
swapchain->timing.clear();
@@ -1084,7 +1087,8 @@
}
for (uint32_t i = 0; i < swapchain->num_images; i++) {
- ReleaseSwapchainImage(device, window, -1, swapchain->images[i], false);
+ ReleaseSwapchainImage(device, swapchain->shared, window, -1,
+ swapchain->images[i], false);
}
if (active) {
@@ -1854,7 +1858,8 @@
WorstPresentResult(swapchain_result, VK_SUBOPTIMAL_KHR);
}
} else {
- ReleaseSwapchainImage(device, nullptr, fence, img, true);
+ ReleaseSwapchainImage(device, swapchain.shared, nullptr, fence,
+ img, true);
swapchain_result = VK_ERROR_OUT_OF_DATE_KHR;
}