diff options
11 files changed, 278 insertions, 33 deletions
diff --git a/libs/vr/libvrflinger/hardware_composer.cpp b/libs/vr/libvrflinger/hardware_composer.cpp index 67607af6c4..188ac6b127 100644 --- a/libs/vr/libvrflinger/hardware_composer.cpp +++ b/libs/vr/libvrflinger/hardware_composer.cpp @@ -1201,6 +1201,20 @@ Return<void> HardwareComposer::ComposerCallback::onVsync(Hwc2::Display display, return Void(); } +Return<void> HardwareComposer::ComposerCallback::onVsync_2_4( + Hwc2::Display /*display*/, int64_t /*timestamp*/, + Hwc2::VsyncPeriodNanos /*vsyncPeriodNanos*/) { + LOG_ALWAYS_FATAL("Unexpected onVsync_2_4 callback"); + return Void(); +} + +Return<void> HardwareComposer::ComposerCallback::onVsyncPeriodTimingChanged( + Hwc2::Display /*display*/, + const Hwc2::VsyncPeriodChangeTimeline& /*updatedTimeline*/) { + LOG_ALWAYS_FATAL("Unexpected onVsyncPeriodTimingChanged callback"); + return Void(); +} + void HardwareComposer::ComposerCallback::SetVsyncService( const sp<VsyncService>& vsync_service) { std::lock_guard<std::mutex> lock(mutex_); diff --git a/libs/vr/libvrflinger/hardware_composer.h b/libs/vr/libvrflinger/hardware_composer.h index 989ce3588d..8698814a33 100644 --- a/libs/vr/libvrflinger/hardware_composer.h +++ b/libs/vr/libvrflinger/hardware_composer.h @@ -375,6 +375,12 @@ class HardwareComposer { hardware::Return<void> onRefresh(Hwc2::Display display) override; hardware::Return<void> onVsync(Hwc2::Display display, int64_t timestamp) override; + hardware::Return<void> onVsync_2_4( + Hwc2::Display display, int64_t timestamp, + Hwc2::VsyncPeriodNanos vsyncPeriodNanos) override; + hardware::Return<void> onVsyncPeriodTimingChanged( + Hwc2::Display display, + const Hwc2::VsyncPeriodChangeTimeline& updatedTimeline) override; bool GotFirstHotplug() { return got_first_hotplug_; } void SetVsyncService(const sp<VsyncService>& vsync_service); diff --git a/services/surfaceflinger/CompositionEngine/tests/MockHWComposer.h b/services/surfaceflinger/CompositionEngine/tests/MockHWComposer.h index 5cfec778a4..364661bed5 100644 --- a/services/surfaceflinger/CompositionEngine/tests/MockHWComposer.h +++ b/services/surfaceflinger/CompositionEngine/tests/MockHWComposer.h @@ -81,6 +81,11 @@ public: MOCK_CONST_METHOD1(getColorModes, std::vector<ui::ColorMode>(DisplayId)); MOCK_METHOD3(setActiveColorMode, status_t(DisplayId, ui::ColorMode, ui::RenderIntent)); MOCK_CONST_METHOD0(isUsingVrComposer, bool()); + MOCK_CONST_METHOD1(isVsyncPeriodSwitchSupported, bool(DisplayId)); + MOCK_CONST_METHOD1(getDisplayVsyncPeriod, nsecs_t(DisplayId)); + MOCK_METHOD4(setActiveConfigWithConstraints, + status_t(DisplayId, size_t, const HWC2::VsyncPeriodChangeConstraints&, + HWC2::VsyncPeriodChangeTimeline*)); MOCK_CONST_METHOD1(dump, void(std::string&)); MOCK_CONST_METHOD0(getComposer, android::Hwc2::Composer*()); diff --git a/services/surfaceflinger/DisplayHardware/ComposerHal.cpp b/services/surfaceflinger/DisplayHardware/ComposerHal.cpp index aef1c7576f..dc71128a3c 100644 --- a/services/surfaceflinger/DisplayHardware/ComposerHal.cpp +++ b/services/surfaceflinger/DisplayHardware/ComposerHal.cpp @@ -95,7 +95,7 @@ private: // assume NO_RESOURCES when Status::isOk returns false constexpr Error kDefaultError = Error::NO_RESOURCES; -constexpr V2_4::Error kDefaultError_2_4 = V2_4::Error::NO_RESOURCES; +constexpr V2_4::Error kDefaultError_2_4 = static_cast<V2_4::Error>(kDefaultError); template<typename T, typename U> T unwrapRet(Return<T>& ret, const U& default_val) @@ -247,7 +247,12 @@ std::string Composer::dumpDebugInfo() void Composer::registerCallback(const sp<IComposerCallback>& callback) { android::hardware::setMinSchedulerPolicy(callback, SCHED_FIFO, 2); - auto ret = mClient->registerCallback(callback); + auto ret = [&]() { + if (mClient_2_4) { + return mClient_2_4->registerCallback_2_4(callback); + } + return mClient->registerCallback(callback); + }(); if (!ret.isOk()) { ALOGE("failed to register IComposerCallback"); } @@ -413,15 +418,28 @@ Error Composer::getDisplayAttribute(Display display, Config config, IComposerClient::Attribute attribute, int32_t* outValue) { Error error = kDefaultError; - mClient->getDisplayAttribute(display, config, attribute, - [&](const auto& tmpError, const auto& tmpValue) { - error = tmpError; - if (error != Error::NONE) { - return; - } + if (mClient_2_4) { + mClient_2_4->getDisplayAttribute_2_4(display, config, attribute, + [&](const auto& tmpError, const auto& tmpValue) { + error = static_cast<Error>(tmpError); + if (error != Error::NONE) { + return; + } + + *outValue = tmpValue; + }); + } else { + mClient->getDisplayAttribute(display, config, + static_cast<V2_1::IComposerClient::Attribute>(attribute), + [&](const auto& tmpError, const auto& tmpValue) { + error = tmpError; + if (error != Error::NONE) { + return; + } - *outValue = tmpValue; - }); + *outValue = tmpValue; + }); + } return error; } @@ -1200,13 +1218,14 @@ Error Composer::getDisplayCapabilities(Display display, return static_cast<Error>(error); } -Error Composer::getDisplayConnectionType(Display display, - IComposerClient::DisplayConnectionType* outType) { +V2_4::Error Composer::getDisplayConnectionType(Display display, + IComposerClient::DisplayConnectionType* outType) { + using Error = V2_4::Error; if (!mClient_2_4) { return Error::UNSUPPORTED; } - V2_4::Error error = kDefaultError_2_4; + Error error = kDefaultError_2_4; mClient_2_4->getDisplayConnectionType(display, [&](const auto& tmpError, const auto& tmpType) { error = tmpError; if (error != V2_4::Error::NONE) { @@ -1216,7 +1235,50 @@ Error Composer::getDisplayConnectionType(Display display, *outType = tmpType; }); - return static_cast<V2_1::Error>(error); + return error; +} + +V2_4::Error Composer::getDisplayVsyncPeriod(Display display, VsyncPeriodNanos* outVsyncPeriod) { + using Error = V2_4::Error; + if (!mClient_2_4) { + return Error::UNSUPPORTED; + } + + Error error = kDefaultError_2_4; + mClient_2_4->getDisplayVsyncPeriod(display, + [&](const auto& tmpError, const auto& tmpVsyncPeriod) { + error = tmpError; + if (error != Error::NONE) { + return; + } + + *outVsyncPeriod = tmpVsyncPeriod; + }); + + return error; +} + +V2_4::Error Composer::setActiveConfigWithConstraints( + Display display, Config config, + const IComposerClient::VsyncPeriodChangeConstraints& vsyncPeriodChangeConstraints, + VsyncPeriodChangeTimeline* outTimeline) { + using Error = V2_4::Error; + if (!mClient_2_4) { + return Error::UNSUPPORTED; + } + + Error error = kDefaultError_2_4; + mClient_2_4->setActiveConfigWithConstraints(display, config, vsyncPeriodChangeConstraints, + [&](const auto& tmpError, const auto& tmpTimeline) { + error = tmpError; + if (error != Error::NONE) { + return; + } + + *outTimeline = tmpTimeline; + }); + + return error; } CommandReader::~CommandReader() diff --git a/services/surfaceflinger/DisplayHardware/ComposerHal.h b/services/surfaceflinger/DisplayHardware/ComposerHal.h index e743e59bb6..336fdd887d 100644 --- a/services/surfaceflinger/DisplayHardware/ComposerHal.h +++ b/services/surfaceflinger/DisplayHardware/ComposerHal.h @@ -62,12 +62,14 @@ using types::V1_2::PixelFormat; using V2_1::Config; using V2_1::Display; using V2_1::Error; -using V2_1::IComposerCallback; using V2_1::Layer; using V2_3::CommandReaderBase; using V2_3::CommandWriterBase; using V2_4::IComposer; +using V2_4::IComposerCallback; using V2_4::IComposerClient; +using V2_4::VsyncPeriodChangeTimeline; +using V2_4::VsyncPeriodNanos; using DisplayCapability = IComposerClient::DisplayCapability; using PerFrameMetadata = IComposerClient::PerFrameMetadata; using PerFrameMetadataKey = IComposerClient::PerFrameMetadataKey; @@ -208,10 +210,17 @@ public: virtual Error setDisplayBrightness(Display display, float brightness) = 0; // Composer HAL 2.4 + virtual bool isVsyncPeriodSwitchSupported() = 0; virtual Error getDisplayCapabilities(Display display, std::vector<DisplayCapability>* outCapabilities) = 0; - virtual Error getDisplayConnectionType(Display display, - IComposerClient::DisplayConnectionType* outType) = 0; + virtual V2_4::Error getDisplayConnectionType( + Display display, IComposerClient::DisplayConnectionType* outType) = 0; + virtual V2_4::Error getDisplayVsyncPeriod(Display display, + VsyncPeriodNanos* outVsyncPeriod) = 0; + virtual V2_4::Error setActiveConfigWithConstraints( + Display display, Config config, + const IComposerClient::VsyncPeriodChangeConstraints& vsyncPeriodChangeConstraints, + VsyncPeriodChangeTimeline* outTimeline) = 0; }; namespace impl { @@ -423,10 +432,16 @@ public: Error setDisplayBrightness(Display display, float brightness) override; // Composer HAL 2.4 + bool isVsyncPeriodSwitchSupported() override { return mClient_2_4 != nullptr; } Error getDisplayCapabilities(Display display, std::vector<DisplayCapability>* outCapabilities) override; - Error getDisplayConnectionType(Display display, - IComposerClient::DisplayConnectionType* outType) override; + V2_4::Error getDisplayConnectionType(Display display, + IComposerClient::DisplayConnectionType* outType) override; + V2_4::Error getDisplayVsyncPeriod(Display display, VsyncPeriodNanos* outVsyncPeriod) override; + V2_4::Error setActiveConfigWithConstraints( + Display display, Config config, + const IComposerClient::VsyncPeriodChangeConstraints& vsyncPeriodChangeConstraints, + VsyncPeriodChangeTimeline* outTimeline) override; private: #if defined(USE_VR_COMPOSER) && USE_VR_COMPOSER diff --git a/services/surfaceflinger/DisplayHardware/HWC2.cpp b/services/surfaceflinger/DisplayHardware/HWC2.cpp index 6f7428a44a..34254e05a0 100644 --- a/services/surfaceflinger/DisplayHardware/HWC2.cpp +++ b/services/surfaceflinger/DisplayHardware/HWC2.cpp @@ -81,7 +81,26 @@ public: Return<void> onVsync(Hwc2::Display display, int64_t timestamp) override { - mCallback->onVsyncReceived(mSequenceId, display, timestamp); + mCallback->onVsyncReceived(mSequenceId, display, timestamp, std::nullopt); + return Void(); + } + + Return<void> onVsync_2_4(Hwc2::Display display, int64_t timestamp, + Hwc2::VsyncPeriodNanos vsyncPeriodNanos) override { + // TODO(b/140201379): use vsyncPeriodNanos in the new DispSync + mCallback->onVsyncReceived(mSequenceId, display, timestamp, + std::make_optional(vsyncPeriodNanos)); + return Void(); + } + + Return<void> onVsyncPeriodTimingChanged( + Hwc2::Display display, + const Hwc2::VsyncPeriodChangeTimeline& updatedTimeline) override { + hwc_vsync_period_change_timeline_t timeline; + timeline.newVsyncAppliedTimeNanos = updatedTimeline.newVsyncAppliedTimeNanos; + timeline.refreshRequired = updatedTimeline.refreshRequired; + timeline.refreshTimeNanos = updatedTimeline.refreshTimeNanos; + mCallback->onVsyncPeriodTimingChangedReceived(mSequenceId, display, timeline); return Void(); } @@ -330,6 +349,36 @@ Error Display::getActiveConfig( return Error::None; } +bool Display::isVsyncPeriodSwitchSupported() const { + ALOGV("[%" PRIu64 "] isVsyncPeriodSwitchSupported()", mId); + + return mComposer.isVsyncPeriodSwitchSupported(); +} + +Error Display::getDisplayVsyncPeriod(nsecs_t* outVsyncPeriod) const { + ALOGV("[%" PRIu64 "] getDisplayVsyncPeriod", mId); + + Error error; + + if (isVsyncPeriodSwitchSupported()) { + Hwc2::VsyncPeriodNanos vsyncPeriodNanos = 0; + auto intError = mComposer.getDisplayVsyncPeriod(mId, &vsyncPeriodNanos); + error = static_cast<Error>(intError); + *outVsyncPeriod = static_cast<nsecs_t>(vsyncPeriodNanos); + } else { + // Get the default vsync period + hwc2_config_t configId = 0; + auto intError_2_1 = mComposer.getActiveConfig(mId, &configId); + error = static_cast<Error>(intError_2_1); + if (error == Error::None) { + auto config = mConfigs.at(configId); + *outVsyncPeriod = config->getVsyncPeriod(); + } + } + + return error; +} + Error Display::getActiveConfigIndex(int* outIndex) const { ALOGV("[%" PRIu64 "] getActiveConfigIndex", mId); hwc2_config_t configId = 0; @@ -345,6 +394,7 @@ Error Display::getActiveConfigIndex(int* outIndex) const { auto pos = mConfigs.find(configId); if (pos != mConfigs.end()) { *outIndex = std::distance(mConfigs.begin(), pos); + ALOGV("[%" PRIu64 "] index = %d", mId, *outIndex); } else { ALOGE("[%" PRIu64 "] getActiveConfig returned unknown config %u", mId, configId); // Return no error, but the caller needs to check for a negative index @@ -582,6 +632,46 @@ Error Display::present(sp<Fence>* outPresentFence) return Error::None; } +Error Display::setActiveConfigWithConstraints( + const std::shared_ptr<const HWC2::Display::Config>& config, + const VsyncPeriodChangeConstraints& constraints, VsyncPeriodChangeTimeline* outTimeline) { + ALOGV("[%" PRIu64 "] setActiveConfigWithConstraints", mId); + if (config->getDisplayId() != mId) { + ALOGE("setActiveConfigWithConstraints received config %u for the wrong display %" PRIu64 + " (expected %" PRIu64 ")", + config->getId(), config->getDisplayId(), mId); + return Error::BadConfig; + } + + if (isVsyncPeriodSwitchSupported()) { + Hwc2::IComposerClient::VsyncPeriodChangeConstraints hwc2Constraints; + hwc2Constraints.desiredTimeNanos = constraints.desiredTimeNanos; + hwc2Constraints.seamlessRequired = constraints.seamlessRequired; + + Hwc2::VsyncPeriodChangeTimeline vsyncPeriodChangeTimeline = {}; + auto intError = + mComposer.setActiveConfigWithConstraints(mId, config->getId(), hwc2Constraints, + &vsyncPeriodChangeTimeline); + outTimeline->newVsyncAppliedTimeNanos = vsyncPeriodChangeTimeline.newVsyncAppliedTimeNanos; + outTimeline->refreshRequired = vsyncPeriodChangeTimeline.refreshRequired; + outTimeline->refreshTimeNanos = vsyncPeriodChangeTimeline.refreshTimeNanos; + return static_cast<Error>(intError); + } + + // Use legacy setActiveConfig instead + ALOGV("fallback to legacy setActiveConfig"); + const auto now = systemTime(); + if (constraints.desiredTimeNanos > now || constraints.seamlessRequired) { + ALOGE("setActiveConfigWithConstraints received constraints that can't be satisfied"); + } + + auto intError_2_4 = mComposer.setActiveConfig(mId, config->getId()); + outTimeline->newVsyncAppliedTimeNanos = std::max(now, constraints.desiredTimeNanos); + outTimeline->refreshRequired = true; + outTimeline->refreshTimeNanos = now; + return static_cast<Error>(intError_2_4); +} + Error Display::setActiveConfig(const std::shared_ptr<const Config>& config) { if (config->getDisplayId() != mId) { @@ -742,12 +832,13 @@ void Display::loadConfig(hwc2_config_t configId) ALOGV("[%" PRIu64 "] loadConfig(%u)", mId, configId); auto config = Config::Builder(*this, configId) - .setWidth(getAttribute(configId, Attribute::Width)) - .setHeight(getAttribute(configId, Attribute::Height)) - .setVsyncPeriod(getAttribute(configId, Attribute::VsyncPeriod)) - .setDpiX(getAttribute(configId, Attribute::DpiX)) - .setDpiY(getAttribute(configId, Attribute::DpiY)) - .build(); + .setWidth(getAttribute(configId, Attribute::Width)) + .setHeight(getAttribute(configId, Attribute::Height)) + .setVsyncPeriod(getAttribute(configId, Attribute::VsyncPeriod)) + .setDpiX(getAttribute(configId, Attribute::DpiX)) + .setDpiY(getAttribute(configId, Attribute::DpiY)) + .setConfigGroup(getAttribute(configId, Attribute::ConfigGroup)) + .build(); mConfigs.emplace(configId, std::move(config)); } diff --git a/services/surfaceflinger/DisplayHardware/HWC2.h b/services/surfaceflinger/DisplayHardware/HWC2.h index b7cdf7f6c4..81ae3b617b 100644 --- a/services/surfaceflinger/DisplayHardware/HWC2.h +++ b/services/surfaceflinger/DisplayHardware/HWC2.h @@ -38,6 +38,8 @@ #include <unordered_set> #include <vector> +#include "../Scheduler/StrongTyping.h" + namespace android { struct DisplayedFrameStats; class Fence; @@ -54,6 +56,8 @@ namespace HWC2 { class Display; class Layer; +using VsyncPeriodChangeConstraints = hwc_vsync_period_change_constraints_t; +using VsyncPeriodChangeTimeline = hwc_vsync_period_change_timeline_t; // Implement this interface to receive hardware composer events. // @@ -70,8 +74,12 @@ class ComposerCallback { Connection connection) = 0; virtual void onRefreshReceived(int32_t sequenceId, hwc2_display_t display) = 0; - virtual void onVsyncReceived(int32_t sequenceId, hwc2_display_t display, - int64_t timestamp) = 0; + virtual void onVsyncReceived(int32_t sequenceId, hwc2_display_t display, int64_t timestamp, + std::optional<hwc2_vsync_period_t> vsyncPeriod) = 0; + virtual void onVsyncPeriodTimingChangedReceived( + int32_t sequenceId, hwc2_display_t display, + const hwc_vsync_period_change_timeline_t& updatedTimeline) = 0; + virtual ~ComposerCallback() = default; }; @@ -170,6 +178,10 @@ public: } return *this; } + Builder& setConfigGroup(int32_t configGroup) { + mConfig->mConfigGroup = configGroup; + return *this; + } private: float getDefaultDensity(); @@ -184,6 +196,7 @@ public: nsecs_t getVsyncPeriod() const { return mVsyncPeriod; } float getDpiX() const { return mDpiX; } float getDpiY() const { return mDpiY; } + int32_t getConfigGroup() const { return mConfigGroup; } private: Config(Display& display, hwc2_config_t id); @@ -196,12 +209,14 @@ public: nsecs_t mVsyncPeriod; float mDpiX; float mDpiY; + int32_t mConfigGroup; }; virtual hwc2_display_t getId() const = 0; virtual bool isConnected() const = 0; virtual void setConnected(bool connected) = 0; // For use by Device only virtual const std::unordered_set<DisplayCapability>& getCapabilities() const = 0; + virtual bool isVsyncPeriodSwitchSupported() const = 0; [[clang::warn_unused_result]] virtual Error acceptChanges() = 0; [[clang::warn_unused_result]] virtual Error createLayer(Layer** outLayer) = 0; @@ -264,6 +279,12 @@ public: uint32_t* outNumTypes, uint32_t* outNumRequests, android::sp<android::Fence>* outPresentFence, uint32_t* state) = 0; [[clang::warn_unused_result]] virtual Error setDisplayBrightness(float brightness) const = 0; + [[clang::warn_unused_result]] virtual Error getDisplayVsyncPeriod( + nsecs_t* outVsyncPeriod) const = 0; + [[clang::warn_unused_result]] virtual Error setActiveConfigWithConstraints( + const std::shared_ptr<const HWC2::Display::Config>& config, + const VsyncPeriodChangeConstraints& constraints, + VsyncPeriodChangeTimeline* outTimeline) = 0; }; namespace impl { @@ -323,6 +344,10 @@ public: Error presentOrValidate(uint32_t* outNumTypes, uint32_t* outNumRequests, android::sp<android::Fence>* outPresentFence, uint32_t* state) override; Error setDisplayBrightness(float brightness) const override; + Error getDisplayVsyncPeriod(nsecs_t* outVsyncPeriod) const override; + Error setActiveConfigWithConstraints(const std::shared_ptr<const HWC2::Display::Config>& config, + const VsyncPeriodChangeConstraints& constraints, + VsyncPeriodChangeTimeline* outTimeline) override; // Other Display methods hwc2_display_t getId() const override { return mId; } @@ -331,6 +356,7 @@ public: const std::unordered_set<DisplayCapability>& getCapabilities() const override { return mDisplayCapabilities; }; + virtual bool isVsyncPeriodSwitchSupported() const override; private: int32_t getAttribute(hwc2_config_t configId, Attribute attribute); @@ -355,7 +381,9 @@ private: bool mIsConnected; DisplayType mType; std::unordered_map<hwc2_layer_t, std::unique_ptr<Layer>> mLayers; + std::unordered_map<hwc2_config_t, std::shared_ptr<const Config>> mConfigs; + std::once_flag mDisplayCapabilityQueryFlag; std::unordered_set<DisplayCapability> mDisplayCapabilities; }; diff --git a/services/surfaceflinger/SurfaceFlinger.cpp b/services/surfaceflinger/SurfaceFlinger.cpp index b4d748d50e..1e7ed07541 100644 --- a/services/surfaceflinger/SurfaceFlinger.cpp +++ b/services/surfaceflinger/SurfaceFlinger.cpp @@ -1363,9 +1363,12 @@ nsecs_t SurfaceFlinger::getVsyncPeriod() const { } void SurfaceFlinger::onVsyncReceived(int32_t sequenceId, hwc2_display_t hwcDisplayId, - int64_t timestamp) { + int64_t timestamp, + std::optional<hwc2_vsync_period_t> /*vsyncPeriod*/) { ATRACE_NAME("SF onVsync"); + // TODO(b/140201379): use vsyncPeriod in the new DispSync + Mutex::Autolock lock(mStateLock); // Ignore any vsyncs from a previous hardware composer. if (sequenceId != getBE().mComposerSequenceId) { @@ -1442,6 +1445,12 @@ void SurfaceFlinger::onHotplugReceived(int32_t sequenceId, hwc2_display_t hwcDis setTransactionFlags(eDisplayTransactionNeeded); } +void SurfaceFlinger::onVsyncPeriodTimingChangedReceived( + int32_t /*sequenceId*/, hwc2_display_t /*display*/, + const hwc_vsync_period_change_timeline_t& /*updatedTimeline*/) { + // TODO(b/142753004): use timeline when changing refresh rate +} + void SurfaceFlinger::onRefreshReceived(int sequenceId, hwc2_display_t /*hwcDisplayId*/) { Mutex::Autolock lock(mStateLock); if (sequenceId != getBE().mComposerSequenceId) { diff --git a/services/surfaceflinger/SurfaceFlinger.h b/services/surfaceflinger/SurfaceFlinger.h index 50b3ae4ecd..080c15334c 100644 --- a/services/surfaceflinger/SurfaceFlinger.h +++ b/services/surfaceflinger/SurfaceFlinger.h @@ -484,11 +484,14 @@ private: /* ------------------------------------------------------------------------ * HWC2::ComposerCallback / HWComposer::EventHandler interface */ - void onVsyncReceived(int32_t sequenceId, hwc2_display_t hwcDisplayId, - int64_t timestamp) override; + void onVsyncReceived(int32_t sequenceId, hwc2_display_t hwcDisplayId, int64_t timestamp, + std::optional<hwc2_vsync_period_t> vsyncPeriod) override; void onHotplugReceived(int32_t sequenceId, hwc2_display_t hwcDisplayId, HWC2::Connection connection) override; void onRefreshReceived(int32_t sequenceId, hwc2_display_t hwcDisplayId) override; + void onVsyncPeriodTimingChangedReceived( + int32_t sequenceId, hwc2_display_t display, + const hwc_vsync_period_change_timeline_t& updatedTimeline) override; /* ------------------------------------------------------------------------ * Message handling diff --git a/services/surfaceflinger/tests/unittests/DisplayTransactionTest.cpp b/services/surfaceflinger/tests/unittests/DisplayTransactionTest.cpp index b1a4951451..db7d04c8e3 100644 --- a/services/surfaceflinger/tests/unittests/DisplayTransactionTest.cpp +++ b/services/surfaceflinger/tests/unittests/DisplayTransactionTest.cpp @@ -469,6 +469,10 @@ struct HwcDisplayVariant { getDisplayAttribute(HWC_DISPLAY_ID, HWC_ACTIVE_CONFIG_ID, IComposerClient::Attribute::DPI_Y, _)) .WillOnce(DoAll(SetArgPointee<3>(DEFAULT_DPI), Return(Error::NONE))); + EXPECT_CALL(*test->mComposer, + getDisplayAttribute(HWC_DISPLAY_ID, HWC_ACTIVE_CONFIG_ID, + IComposerClient::Attribute::CONFIG_GROUP, _)) + .WillOnce(DoAll(SetArgPointee<3>(-1), Return(Error::NONE))); if (PhysicalDisplay::HAS_IDENTIFICATION_DATA) { EXPECT_CALL(*test->mComposer, getDisplayIdentificationData(HWC_DISPLAY_ID, _, _)) diff --git a/services/surfaceflinger/tests/unittests/mock/DisplayHardware/MockComposer.h b/services/surfaceflinger/tests/unittests/mock/DisplayHardware/MockComposer.h index 98c6aa0236..2453ccb291 100644 --- a/services/surfaceflinger/tests/unittests/mock/DisplayHardware/MockComposer.h +++ b/services/surfaceflinger/tests/unittests/mock/DisplayHardware/MockComposer.h @@ -39,8 +39,8 @@ using android::hardware::graphics::composer::V2_1::Config; using android::hardware::graphics::composer::V2_1::Display; using android::hardware::graphics::composer::V2_1::Error; using android::hardware::graphics::composer::V2_1::IComposer; -using android::hardware::graphics::composer::V2_1::IComposerCallback; using android::hardware::graphics::composer::V2_1::Layer; +using android::hardware::graphics::composer::V2_4::IComposerCallback; using android::hardware::graphics::composer::V2_4::IComposerClient; class Composer : public Hwc2::Composer { @@ -120,8 +120,16 @@ public: MOCK_METHOD3(setLayerPerFrameMetadataBlobs, Error(Display, Layer, const std::vector<IComposerClient::PerFrameMetadataBlob>&)); MOCK_METHOD2(setDisplayBrightness, Error(Display, float)); + MOCK_METHOD0(isVsyncPeriodSwitchSupported, bool()); MOCK_METHOD2(getDisplayCapabilities, Error(Display, std::vector<DisplayCapability>*)); - MOCK_METHOD2(getDisplayConnectionType, Error(Display, IComposerClient::DisplayConnectionType*)); + MOCK_METHOD2(getDisplayConnectionType, + V2_4::Error(Display, IComposerClient::DisplayConnectionType*)); + MOCK_METHOD3(getSupportedDisplayVsyncPeriods, + V2_4::Error(Display, Config, std::vector<VsyncPeriodNanos>*)); + MOCK_METHOD2(getDisplayVsyncPeriod, V2_4::Error(Display, VsyncPeriodNanos*)); + MOCK_METHOD4(setActiveConfigWithConstraints, + V2_4::Error(Display, Config, const IComposerClient::VsyncPeriodChangeConstraints&, + VsyncPeriodChangeTimeline*)); }; } // namespace mock |