SurfaceFlinger: Add touch events to Scheduler
Add the notion of Touch Events to Scheduler to enhance the algorithm
to move to Performance refresh rate.
Scheduler selects Performance when:
- There is a touch event
- There is a buffer to HWC
This change also removes the behavior of Scheduler to move to Performance
on Choreographer callbacks.
Test: Switch between apps using gesture navigation
Bug: 131906818
Change-Id: I588cfc32449e87744e829dc7c5261a2e4151a8f8
diff --git a/services/surfaceflinger/Scheduler/EventThread.cpp b/services/surfaceflinger/Scheduler/EventThread.cpp
index a6c7e6c..05bad4d 100644
--- a/services/surfaceflinger/Scheduler/EventThread.cpp
+++ b/services/surfaceflinger/Scheduler/EventThread.cpp
@@ -107,10 +107,8 @@
} // namespace
EventThreadConnection::EventThreadConnection(EventThread* eventThread,
- ResyncCallback resyncCallback,
- ResetIdleTimerCallback resetIdleTimerCallback)
+ ResyncCallback resyncCallback)
: resyncCallback(std::move(resyncCallback)),
- resetIdleTimerCallback(std::move(resetIdleTimerCallback)),
mEventThread(eventThread),
mChannel(gui::BitTube::DefaultSize) {}
@@ -136,12 +134,7 @@
void EventThreadConnection::requestNextVsync() {
ATRACE_NAME("requestNextVsync");
- mEventThread->requestNextVsync(this, true);
-}
-
-void EventThreadConnection::requestNextVsyncForHWC() {
- ATRACE_NAME("requestNextVsyncForHWC");
- mEventThread->requestNextVsync(this, false);
+ mEventThread->requestNextVsync(this);
}
status_t EventThreadConnection::postEvent(const DisplayEventReceiver::Event& event) {
@@ -210,10 +203,8 @@
mVSyncSource->setPhaseOffset(phaseOffset);
}
-sp<EventThreadConnection> EventThread::createEventConnection(
- ResyncCallback resyncCallback, ResetIdleTimerCallback resetIdleTimerCallback) const {
- return new EventThreadConnection(const_cast<EventThread*>(this), std::move(resyncCallback),
- std::move(resetIdleTimerCallback));
+sp<EventThreadConnection> EventThread::createEventConnection(ResyncCallback resyncCallback) const {
+ return new EventThreadConnection(const_cast<EventThread*>(this), std::move(resyncCallback));
}
status_t EventThread::registerDisplayEventConnection(const sp<EventThreadConnection>& connection) {
@@ -255,12 +246,7 @@
}
}
-void EventThread::requestNextVsync(const sp<EventThreadConnection>& connection, bool reset) {
- if (connection->resetIdleTimerCallback && reset) {
- ATRACE_NAME("resetIdleTimer");
- connection->resetIdleTimerCallback();
- }
-
+void EventThread::requestNextVsync(const sp<EventThreadConnection>& connection) {
if (connection->resyncCallback) {
connection->resyncCallback();
}
diff --git a/services/surfaceflinger/Scheduler/EventThread.h b/services/surfaceflinger/Scheduler/EventThread.h
index 7107d63..61530c6 100644
--- a/services/surfaceflinger/Scheduler/EventThread.h
+++ b/services/surfaceflinger/Scheduler/EventThread.h
@@ -45,7 +45,6 @@
// ---------------------------------------------------------------------------
using ResyncCallback = std::function<void()>;
-using ResetIdleTimerCallback = std::function<void()>;
enum class VSyncRequest {
None = -1,
@@ -70,7 +69,7 @@
class EventThreadConnection : public BnDisplayEventConnection {
public:
- EventThreadConnection(EventThread*, ResyncCallback, ResetIdleTimerCallback);
+ EventThreadConnection(EventThread*, ResyncCallback);
virtual ~EventThreadConnection();
virtual status_t postEvent(const DisplayEventReceiver::Event& event);
@@ -78,13 +77,9 @@
status_t stealReceiveChannel(gui::BitTube* outChannel) override;
status_t setVsyncRate(uint32_t rate) override;
void requestNextVsync() override; // asynchronous
- // Requesting Vsync for HWC does not reset the idle timer, since HWC requires a refresh
- // in order to update the configs.
- void requestNextVsyncForHWC();
// Called in response to requestNextVsync.
const ResyncCallback resyncCallback;
- const ResetIdleTimerCallback resetIdleTimerCallback;
VSyncRequest vsyncRequest = VSyncRequest::None;
@@ -98,8 +93,7 @@
public:
virtual ~EventThread();
- virtual sp<EventThreadConnection> createEventConnection(ResyncCallback,
- ResetIdleTimerCallback) const = 0;
+ virtual sp<EventThreadConnection> createEventConnection(ResyncCallback) const = 0;
// called before the screen is turned off from main thread
virtual void onScreenReleased() = 0;
@@ -120,8 +114,7 @@
const sp<EventThreadConnection>& connection) = 0;
virtual void setVsyncRate(uint32_t rate, const sp<EventThreadConnection>& connection) = 0;
// Requests the next vsync. If resetIdleTimer is set to true, it resets the idle timer.
- virtual void requestNextVsync(const sp<EventThreadConnection>& connection,
- bool resetIdleTimer) = 0;
+ virtual void requestNextVsync(const sp<EventThreadConnection>& connection) = 0;
};
namespace impl {
@@ -135,13 +128,11 @@
EventThread(std::unique_ptr<VSyncSource>, InterceptVSyncsCallback, const char* threadName);
~EventThread();
- sp<EventThreadConnection> createEventConnection(ResyncCallback,
- ResetIdleTimerCallback) const override;
+ sp<EventThreadConnection> createEventConnection(ResyncCallback) const override;
status_t registerDisplayEventConnection(const sp<EventThreadConnection>& connection) override;
void setVsyncRate(uint32_t rate, const sp<EventThreadConnection>& connection) override;
- void requestNextVsync(const sp<EventThreadConnection>& connection,
- bool resetIdleTimer) override;
+ void requestNextVsync(const sp<EventThreadConnection>& connection) override;
// called before the screen is turned off from main thread
void onScreenReleased() override;
diff --git a/services/surfaceflinger/Scheduler/MessageQueue.cpp b/services/surfaceflinger/Scheduler/MessageQueue.cpp
index 1f18ead..baf900d 100644
--- a/services/surfaceflinger/Scheduler/MessageQueue.cpp
+++ b/services/surfaceflinger/Scheduler/MessageQueue.cpp
@@ -96,8 +96,7 @@
}
mEventThread = eventThread;
- mEvents =
- eventThread->createEventConnection(std::move(resyncCallback), ResetIdleTimerCallback());
+ mEvents = eventThread->createEventConnection(std::move(resyncCallback));
mEvents->stealReceiveChannel(&mEventTube);
mLooper->addFd(mEventTube.getFd(), 0, Looper::EVENT_INPUT, MessageQueue::cb_eventReceiver,
this);
@@ -150,10 +149,6 @@
mEvents->requestNextVsync();
}
-void MessageQueue::invalidateForHWC() {
- mEvents->requestNextVsyncForHWC();
-}
-
void MessageQueue::refresh() {
mHandler->dispatchRefresh();
}
diff --git a/services/surfaceflinger/Scheduler/MessageQueue.h b/services/surfaceflinger/Scheduler/MessageQueue.h
index 245a8ac..0b2206d 100644
--- a/services/surfaceflinger/Scheduler/MessageQueue.h
+++ b/services/surfaceflinger/Scheduler/MessageQueue.h
@@ -91,7 +91,6 @@
virtual void waitMessage() = 0;
virtual status_t postMessage(const sp<MessageBase>& message, nsecs_t reltime = 0) = 0;
virtual void invalidate() = 0;
- virtual void invalidateForHWC() = 0;
virtual void refresh() = 0;
};
@@ -136,8 +135,6 @@
// sends INVALIDATE message at next VSYNC
void invalidate() override;
- // sends INVALIDATE message at next VSYNC, without resetting the idle timer in the Scheduler
- void invalidateForHWC();
// sends REFRESH message at next VSYNC
void refresh() override;
};
diff --git a/services/surfaceflinger/Scheduler/Scheduler.cpp b/services/surfaceflinger/Scheduler/Scheduler.cpp
index 3f9a88d..513436a 100644
--- a/services/surfaceflinger/Scheduler/Scheduler.cpp
+++ b/services/surfaceflinger/Scheduler/Scheduler.cpp
@@ -75,6 +75,8 @@
mSetIdleTimerMs = set_idle_timer_ms(0);
mSupportKernelTimer = support_kernel_idle_timer(false);
+ mSetTouchTimerMs = set_touch_timer_ms(0);
+
char value[PROPERTY_VALUE_MAX];
property_get("debug.sf.set_idle_timer_ms", value, "0");
int int_value = atoi(value);
@@ -99,10 +101,20 @@
}
mIdleTimer->start();
}
+
+ if (mSetTouchTimerMs > 0) {
+ // Touch events are coming to SF every 100ms, so the timer needs to be higher than that
+ mTouchTimer =
+ std::make_unique<scheduler::IdleTimer>(std::chrono::milliseconds(mSetTouchTimerMs),
+ [this] { resetTouchTimerCallback(); },
+ [this] { expiredTouchTimerCallback(); });
+ mTouchTimer->start();
+ }
}
Scheduler::~Scheduler() {
// Ensure the IdleTimer thread is joined before we start destroying state.
+ mTouchTimer.reset();
mIdleTimer.reset();
}
@@ -136,8 +148,7 @@
sp<EventThreadConnection> Scheduler::createConnectionInternal(EventThread* eventThread,
ResyncCallback&& resyncCallback) {
- return eventThread->createEventConnection(std::move(resyncCallback),
- [this] { resetIdleTimer(); });
+ return eventThread->createEventConnection(std::move(resyncCallback));
}
sp<IDisplayEventConnection> Scheduler::createDisplayEventConnection(
@@ -385,6 +396,16 @@
}
}
+void Scheduler::notifyTouchEvent() {
+ if (mTouchTimer) {
+ mTouchTimer->reset();
+ }
+
+ if (mSupportKernelTimer) {
+ resetIdleTimer();
+ }
+}
+
void Scheduler::resetTimerCallback() {
timerChangeRefreshRate(IdleTimerState::RESET);
ATRACE_INT("ExpiredIdleTimer", 0);
@@ -403,6 +424,18 @@
ATRACE_INT("ExpiredIdleTimer", 1);
}
+void Scheduler::resetTouchTimerCallback() {
+ // We do not notify the applications about config changes when idle timer is reset.
+ touchChangeRefreshRate(TouchState::ACTIVE);
+ ATRACE_INT("TouchState", 1);
+}
+
+void Scheduler::expiredTouchTimerCallback() {
+ // We do not notify the applications about config changes when idle timer expires.
+ touchChangeRefreshRate(TouchState::INACTIVE);
+ ATRACE_INT("TouchState", 0);
+}
+
void Scheduler::expiredKernelTimerCallback() {
ATRACE_INT("ExpiredKernelIdleTimer", 1);
// Disable HW Vsync if the timer expired, as we don't need it
@@ -413,6 +446,7 @@
std::string Scheduler::doDump() {
std::ostringstream stream;
stream << "+ Idle timer interval: " << mSetIdleTimerMs << " ms" << std::endl;
+ stream << "+ Touch timer interval: " << mSetTouchTimerMs << " ms" << std::endl;
return stream.str();
}
@@ -433,14 +467,41 @@
changeRefreshRate(newRefreshRateType, ConfigEvent::None);
}
+void Scheduler::touchChangeRefreshRate(TouchState touchState) {
+ ConfigEvent event = ConfigEvent::None;
+ RefreshRateType newRefreshRateType;
+ {
+ std::lock_guard<std::mutex> lock(mFeatureStateLock);
+ if (mCurrentTouchState == touchState) {
+ return;
+ }
+ mCurrentTouchState = touchState;
+ newRefreshRateType = calculateRefreshRateType();
+ if (mRefreshRateType == newRefreshRateType) {
+ return;
+ }
+ mRefreshRateType = newRefreshRateType;
+ // Send an event in case that content detection is on as touch has a higher priority
+ if (mCurrentContentFeatureState == ContentFeatureState::CONTENT_DETECTION_ON) {
+ event = ConfigEvent::Changed;
+ }
+ }
+ changeRefreshRate(newRefreshRateType, event);
+}
+
Scheduler::RefreshRateType Scheduler::calculateRefreshRateType() {
- // First check if timer has expired as it means there is no new content on the screen
- if (mCurrentIdleTimerState == IdleTimerState::EXPIRED) {
+ // HDR content is not supported on PERFORMANCE mode
+ if (mForceHDRContentToDefaultRefreshRate && mIsHDRContent) {
return RefreshRateType::DEFAULT;
}
- // HDR content is not supported on PERFORMANCE mode
- if (mForceHDRContentToDefaultRefreshRate && mIsHDRContent) {
+ // As long as touch is active we want to be in performance mode
+ if (mCurrentTouchState == TouchState::ACTIVE) {
+ return RefreshRateType::PERFORMANCE;
+ }
+
+ // If timer has expired as it means there is no new content on the screen
+ if (mCurrentIdleTimerState == IdleTimerState::EXPIRED) {
return RefreshRateType::DEFAULT;
}
diff --git a/services/surfaceflinger/Scheduler/Scheduler.h b/services/surfaceflinger/Scheduler/Scheduler.h
index 7c8adf0..96d4bd5 100644
--- a/services/surfaceflinger/Scheduler/Scheduler.h
+++ b/services/surfaceflinger/Scheduler/Scheduler.h
@@ -165,6 +165,12 @@
// Returns whether idle timer is enabled or not
bool isIdleTimerEnabled() { return mSetIdleTimerMs > 0; }
+ // Function that resets the idle timer.
+ void resetIdleTimer();
+
+ // Function that resets the touch timer.
+ void notifyTouchEvent();
+
// Returns relevant information about Scheduler for dumpsys purposes.
std::string doDump();
@@ -183,14 +189,14 @@
// to keep track which feature requested the config change.
enum class ContentFeatureState { CONTENT_DETECTION_ON, CONTENT_DETECTION_OFF };
enum class IdleTimerState { EXPIRED, RESET };
+ enum class TouchState { INACTIVE, ACTIVE };
// Creates a connection on the given EventThread and forwards the given callbacks.
sp<EventThreadConnection> createConnectionInternal(EventThread*, ResyncCallback&&);
nsecs_t calculateAverage() const;
void updateFrameSkipping(const int64_t skipCount);
- // Function that resets the idle timer.
- void resetIdleTimer();
+
// Function that is called when the timer resets.
void resetTimerCallback();
// Function that is called when the timer expires.
@@ -203,10 +209,16 @@
// driver timeout in the kernel. This disables hardware vsync when we move
// into idle.
void expiredKernelTimerCallback();
+ // Function that is called when the touch timer resets.
+ void resetTouchTimerCallback();
+ // Function that is called when the touch timer expires.
+ void expiredTouchTimerCallback();
// Sets vsync period.
void setVsyncPeriod(const nsecs_t period);
// Idle timer feature's function to change the refresh rate.
void timerChangeRefreshRate(IdleTimerState idleTimerState);
+ // Touch timer feature's function to change the refresh rate.
+ void touchChangeRefreshRate(TouchState touchState);
// Calculate the new refresh rate type
RefreshRateType calculateRefreshRateType() REQUIRES(mFeatureStateLock);
// Acquires a lock and calls the ChangeRefreshRateCallback() with given parameters.
@@ -258,6 +270,10 @@
// timer.
bool mSupportKernelTimer;
+ // Timer used to monitor touch events.
+ int64_t mSetTouchTimerMs = 0;
+ std::unique_ptr<scheduler::IdleTimer> mTouchTimer;
+
std::mutex mCallbackLock;
ChangeRefreshRateCallback mChangeRefreshRateCallback GUARDED_BY(mCallbackLock);
GetVsyncPeriod mGetVsyncPeriod GUARDED_BY(mCallbackLock);
@@ -268,6 +284,7 @@
ContentFeatureState mCurrentContentFeatureState GUARDED_BY(mFeatureStateLock) =
ContentFeatureState::CONTENT_DETECTION_OFF;
IdleTimerState mCurrentIdleTimerState GUARDED_BY(mFeatureStateLock) = IdleTimerState::RESET;
+ TouchState mCurrentTouchState GUARDED_BY(mFeatureStateLock) = TouchState::INACTIVE;
uint32_t mContentRefreshRate GUARDED_BY(mFeatureStateLock);
RefreshRateType mRefreshRateType GUARDED_BY(mFeatureStateLock);
bool mIsHDRContent GUARDED_BY(mFeatureStateLock) = false;