Merge changes Ibdd09f42,I624700a7 into main
* changes:
[15/n Dispatcher refactor] Remove TouchState from setInputWindows
[14/n Dispatcher refactor] Move TouchState methods
diff --git a/services/inputflinger/dispatcher/InputDispatcher.cpp b/services/inputflinger/dispatcher/InputDispatcher.cpp
index 56be2e6..11ba592 100644
--- a/services/inputflinger/dispatcher/InputDispatcher.cpp
+++ b/services/inputflinger/dispatcher/InputDispatcher.cpp
@@ -1267,14 +1267,9 @@
if (dropReason == DropReason::NOT_DROPPED && isStaleEvent(currentTime, *motionEntry)) {
// The event is stale. However, only drop stale events if there isn't an ongoing
// gesture. That would allow us to complete the processing of the current stroke.
- const auto touchStateIt =
- mTouchStates.mTouchStatesByDisplay.find(motionEntry->displayId);
- if (touchStateIt != mTouchStates.mTouchStatesByDisplay.end()) {
- const TouchState& touchState = touchStateIt->second;
- if (!touchState.hasTouchingPointers(motionEntry->deviceId) &&
- !touchState.hasHoveringPointers(motionEntry->deviceId)) {
- dropReason = DropReason::STALE;
- }
+ if (!mTouchStates.hasTouchingOrHoveringPointers(motionEntry->displayId,
+ motionEntry->deviceId)) {
+ dropReason = DropReason::STALE;
}
}
if (dropReason == DropReason::NOT_DROPPED && mNextUnblockedEvent) {
@@ -1716,9 +1711,7 @@
synthesizeCancelationEventsForAllConnectionsLocked(options);
// Remove all active pointers from this device
- for (auto& [_, touchState] : mTouchStates.mTouchStatesByDisplay) {
- touchState.removeAllPointersForDevice(entry.deviceId);
- }
+ mTouchStates.removeAllPointersForDevice(entry.deviceId);
return true;
}
@@ -4581,13 +4574,8 @@
if (!(policyFlags & POLICY_FLAG_PASS_TO_USER)) {
// Set the flag anyway if we already have an ongoing gesture. That would allow us to
// complete the processing of the current stroke.
- const auto touchStateIt = mTouchStates.mTouchStatesByDisplay.find(args.displayId);
- if (touchStateIt != mTouchStates.mTouchStatesByDisplay.end()) {
- const TouchState& touchState = touchStateIt->second;
- if (touchState.hasTouchingPointers(args.deviceId) ||
- touchState.hasHoveringPointers(args.deviceId)) {
- policyFlags |= POLICY_FLAG_PASS_TO_USER;
- }
+ if (mTouchStates.hasTouchingOrHoveringPointers(args.displayId, args.deviceId)) {
+ policyFlags |= POLICY_FLAG_PASS_TO_USER;
}
}
@@ -4893,13 +4881,8 @@
if (!(policyFlags & POLICY_FLAG_PASS_TO_USER)) {
// Set the flag anyway if we already have an ongoing motion gesture. That
// would allow us to complete the processing of the current stroke.
- const auto touchStateIt = mTouchStates.mTouchStatesByDisplay.find(displayId);
- if (touchStateIt != mTouchStates.mTouchStatesByDisplay.end()) {
- const TouchState& touchState = touchStateIt->second;
- if (touchState.hasTouchingPointers(resolvedDeviceId) ||
- touchState.hasHoveringPointers(resolvedDeviceId)) {
- policyFlags |= POLICY_FLAG_PASS_TO_USER;
- }
+ if (mTouchStates.hasTouchingOrHoveringPointers(displayId, resolvedDeviceId)) {
+ policyFlags |= POLICY_FLAG_PASS_TO_USER;
}
}
@@ -5470,72 +5453,38 @@
onFocusChangedLocked(*changes, traceContext.getTracker(), removedFocusedWindowHandle);
}
- if (const auto& it = mTouchStates.mTouchStatesByDisplay.find(displayId);
- it != mTouchStates.mTouchStatesByDisplay.end()) {
- TouchState& state = it->second;
- for (size_t i = 0; i < state.windows.size();) {
- TouchedWindow& touchedWindow = state.windows[i];
- if (mWindowInfos.isWindowPresent(touchedWindow.windowHandle)) {
- i++;
- continue;
- }
- LOG(INFO) << "Touched window was removed: " << touchedWindow.windowHandle->getName()
- << " in display %" << displayId;
- CancelationOptions options(CancelationOptions::Mode::CANCEL_POINTER_EVENTS,
- "touched window was removed", traceContext.getTracker());
- synthesizeCancelationEventsForWindowLocked(touchedWindow.windowHandle, options);
- // Since we are about to drop the touch, cancel the events for the wallpaper as
- // well.
- if (touchedWindow.targetFlags.test(InputTarget::Flags::FOREGROUND) &&
- touchedWindow.windowHandle->getInfo()->inputConfig.test(
- gui::WindowInfo::InputConfig::DUPLICATE_TOUCH_TO_WALLPAPER)) {
- for (const DeviceId deviceId : touchedWindow.getTouchingDeviceIds()) {
- if (const auto& ww = state.getWallpaperWindow(deviceId); ww != nullptr) {
- options.deviceId = deviceId;
- synthesizeCancelationEventsForWindowLocked(ww, options);
- }
- }
- }
- state.windows.erase(state.windows.begin() + i);
- }
-
- // If drag window is gone, it would receive a cancel event and broadcast the DRAG_END. We
- // could just clear the state here.
- if (mDragState && mDragState->dragWindow->getInfo()->displayId == displayId &&
- std::find(windowHandles.begin(), windowHandles.end(), mDragState->dragWindow) ==
- windowHandles.end()) {
- ALOGI("Drag window went away: %s", mDragState->dragWindow->getName().c_str());
- sendDropWindowCommandLocked(nullptr, 0, 0);
- mDragState.reset();
+ CancelationOptions pointerCancellationOptions(CancelationOptions::Mode::CANCEL_POINTER_EVENTS,
+ "touched window was removed",
+ traceContext.getTracker());
+ CancelationOptions hoverCancellationOptions(CancelationOptions::Mode::CANCEL_HOVER_EVENTS,
+ "WindowInfo changed", traceContext.getTracker());
+ const std::list<DispatcherTouchState::CancellationArgs> cancellations =
+ mTouchStates.updateFromWindowInfo(displayId, mWindowInfos);
+ for (const auto& cancellationArgs : cancellations) {
+ switch (cancellationArgs.mode) {
+ case CancelationOptions::Mode::CANCEL_POINTER_EVENTS:
+ pointerCancellationOptions.deviceId = cancellationArgs.deviceId;
+ synthesizeCancelationEventsForWindowLocked(cancellationArgs.windowHandle,
+ pointerCancellationOptions);
+ break;
+ case CancelationOptions::Mode::CANCEL_HOVER_EVENTS:
+ hoverCancellationOptions.deviceId = cancellationArgs.deviceId;
+ synthesizeCancelationEventsForWindowLocked(cancellationArgs.windowHandle,
+ hoverCancellationOptions);
+ break;
+ default:
+ LOG_ALWAYS_FATAL("Unexpected cancellation Mode");
}
}
- // Check if the hovering should stop because the window is no longer eligible to receive it
- // (for example, if the touchable region changed)
- if (const auto& it = mTouchStates.mTouchStatesByDisplay.find(displayId);
- it != mTouchStates.mTouchStatesByDisplay.end()) {
- TouchState& state = it->second;
- for (TouchedWindow& touchedWindow : state.windows) {
- std::vector<DeviceId> erasedDevices = touchedWindow.eraseHoveringPointersIf(
- [this, displayId, &touchedWindow](const PointerProperties& properties, float x,
- float y) REQUIRES(mLock) {
- const bool isStylus = properties.toolType == ToolType::STYLUS;
- const ui::Transform displayTransform =
- mWindowInfos.getDisplayTransform(displayId);
- const bool stillAcceptsTouch =
- windowAcceptsTouchAt(*touchedWindow.windowHandle->getInfo(),
- displayId, x, y, isStylus, displayTransform);
- return !stillAcceptsTouch;
- });
-
- for (DeviceId deviceId : erasedDevices) {
- CancelationOptions options(CancelationOptions::Mode::CANCEL_HOVER_EVENTS,
- "WindowInfo changed",
- traceContext.getTracker());
- options.deviceId = deviceId;
- synthesizeCancelationEventsForWindowLocked(touchedWindow.windowHandle, options);
- }
- }
+ // If drag window is gone, it would receive a cancel event and broadcast the DRAG_END. We
+ // could just clear the state here.
+ if (mDragState && mDragState->dragWindow->getInfo()->displayId == displayId &&
+ std::find(windowHandles.begin(), windowHandles.end(), mDragState->dragWindow) ==
+ windowHandles.end()) {
+ ALOGI("Drag window went away: %s", mDragState->dragWindow->getName().c_str());
+ sendDropWindowCommandLocked(nullptr, 0, 0);
+ mDragState.reset();
}
// Release information for windows that are no longer present.
@@ -5552,6 +5501,76 @@
}
}
+std::list<InputDispatcher::DispatcherTouchState::CancellationArgs>
+InputDispatcher::DispatcherTouchState::updateFromWindowInfo(
+ ui::LogicalDisplayId displayId, const DispatcherWindowInfo& windowInfos) {
+ std::list<CancellationArgs> cancellations;
+ if (const auto& it = mTouchStatesByDisplay.find(displayId); it != mTouchStatesByDisplay.end()) {
+ TouchState& state = it->second;
+ cancellations = eraseRemovedWindowsFromWindowInfo(state, displayId, windowInfos);
+ cancellations.splice(cancellations.end(),
+ updateHoveringStateFromWindowInfo(state, displayId, windowInfos));
+ }
+ return cancellations;
+}
+
+std::list<InputDispatcher::DispatcherTouchState::CancellationArgs>
+InputDispatcher::DispatcherTouchState::eraseRemovedWindowsFromWindowInfo(
+ TouchState& state, ui::LogicalDisplayId displayId,
+ const DispatcherWindowInfo& windowInfos) {
+ std::list<CancellationArgs> cancellations;
+ for (auto it = state.windows.begin(); it != state.windows.end();) {
+ TouchedWindow& touchedWindow = *it;
+ if (windowInfos.isWindowPresent(touchedWindow.windowHandle)) {
+ it++;
+ continue;
+ }
+ LOG(INFO) << "Touched window was removed: " << touchedWindow.windowHandle->getName()
+ << " in display %" << displayId;
+ cancellations.emplace_back(touchedWindow.windowHandle,
+ CancelationOptions::Mode::CANCEL_POINTER_EVENTS, std::nullopt);
+ // Since we are about to drop the touch, cancel the events for the wallpaper as well.
+ if (touchedWindow.targetFlags.test(InputTarget::Flags::FOREGROUND) &&
+ touchedWindow.windowHandle->getInfo()->inputConfig.test(
+ gui::WindowInfo::InputConfig::DUPLICATE_TOUCH_TO_WALLPAPER)) {
+ for (const DeviceId deviceId : touchedWindow.getTouchingDeviceIds()) {
+ if (const auto& ww = state.getWallpaperWindow(deviceId); ww != nullptr) {
+ cancellations.emplace_back(ww, CancelationOptions::Mode::CANCEL_POINTER_EVENTS,
+ deviceId);
+ }
+ }
+ }
+ it = state.windows.erase(it);
+ }
+ return cancellations;
+}
+
+std::list<InputDispatcher::DispatcherTouchState::CancellationArgs>
+InputDispatcher::DispatcherTouchState::updateHoveringStateFromWindowInfo(
+ TouchState& state, ui::LogicalDisplayId displayId,
+ const DispatcherWindowInfo& windowInfos) {
+ std::list<CancellationArgs> cancellations;
+ // Check if the hovering should stop because the window is no longer eligible to receive it
+ // (for example, if the touchable region changed)
+ ui::Transform displayTransform = windowInfos.getDisplayTransform(displayId);
+ for (TouchedWindow& touchedWindow : state.windows) {
+ std::vector<DeviceId> erasedDevices = touchedWindow.eraseHoveringPointersIf(
+ [&](const PointerProperties& properties, float x, float y) {
+ const bool isStylus = properties.toolType == ToolType::STYLUS;
+ const bool stillAcceptsTouch =
+ windowAcceptsTouchAt(*touchedWindow.windowHandle->getInfo(), displayId,
+ x, y, isStylus, displayTransform);
+ return !stillAcceptsTouch;
+ });
+
+ for (DeviceId deviceId : erasedDevices) {
+ cancellations.emplace_back(touchedWindow.windowHandle,
+ CancelationOptions::Mode::CANCEL_HOVER_EVENTS, deviceId);
+ }
+ }
+ return cancellations;
+}
+
void InputDispatcher::setFocusedApplication(
ui::LogicalDisplayId displayId,
const std::shared_ptr<InputApplicationHandle>& inputApplicationHandle) {
@@ -5978,7 +5997,7 @@
resetNoFocusedWindowTimeoutLocked();
mAnrTracker.clear();
- mTouchStates.mTouchStatesByDisplay.clear();
+ mTouchStates.clear();
}
void InputDispatcher::logDispatchStateLocked() const {
@@ -6036,15 +6055,7 @@
dump += mFocusResolver.dump();
dump += dumpPointerCaptureStateLocked();
- if (!mTouchStates.mTouchStatesByDisplay.empty()) {
- dump += StringPrintf(INDENT "TouchStatesByDisplay:\n");
- for (const auto& [displayId, state] : mTouchStates.mTouchStatesByDisplay) {
- std::string touchStateDump = addLinePrefix(state.dump(), INDENT2);
- dump += INDENT2 + displayId.toString() + " : " + touchStateDump;
- }
- } else {
- dump += INDENT "TouchStates: <no displays touched>\n";
- }
+ dump += addLinePrefix(mTouchStates.dump(), INDENT);
if (mDragState) {
dump += StringPrintf(INDENT "DragState:\n");
@@ -7093,7 +7104,7 @@
"cancel current touch", traceContext.getTracker());
synthesizeCancelationEventsForAllConnectionsLocked(options);
- mTouchStates.mTouchStatesByDisplay.clear();
+ mTouchStates.clear();
}
// Wake up poll loop since there might be work to do.
mLooper->wake();
@@ -7228,18 +7239,7 @@
ui::LogicalDisplayId displayId, DeviceId deviceId,
int32_t pointerId) {
std::scoped_lock _l(mLock);
- auto touchStateIt = mTouchStates.mTouchStatesByDisplay.find(displayId);
- if (touchStateIt == mTouchStates.mTouchStatesByDisplay.end()) {
- return false;
- }
- for (const TouchedWindow& window : touchStateIt->second.windows) {
- if (window.windowHandle->getToken() == token &&
- (window.hasTouchingPointer(deviceId, pointerId) ||
- window.hasHoveringPointer(deviceId, pointerId))) {
- return true;
- }
- }
- return false;
+ return mTouchStates.isPointerInWindow(token, displayId, deviceId, pointerId);
}
void InputDispatcher::setInputMethodConnectionIsActive(bool isActive) {
@@ -7403,4 +7403,56 @@
return targetFlags;
}
+bool InputDispatcher::DispatcherTouchState::hasTouchingOrHoveringPointers(
+ ui::LogicalDisplayId displayId, int32_t deviceId) const {
+ const auto touchStateIt = mTouchStatesByDisplay.find(displayId);
+ if (touchStateIt == mTouchStatesByDisplay.end()) {
+ return false;
+ }
+ return touchStateIt->second.hasTouchingPointers(deviceId) ||
+ touchStateIt->second.hasHoveringPointers(deviceId);
+}
+
+bool InputDispatcher::DispatcherTouchState::isPointerInWindow(const sp<android::IBinder>& token,
+ ui::LogicalDisplayId displayId,
+ android::DeviceId deviceId,
+ int32_t pointerId) const {
+ const auto touchStateIt = mTouchStatesByDisplay.find(displayId);
+ if (touchStateIt == mTouchStatesByDisplay.end()) {
+ return false;
+ }
+ for (const TouchedWindow& window : touchStateIt->second.windows) {
+ if (window.windowHandle->getToken() == token &&
+ (window.hasTouchingPointer(deviceId, pointerId) ||
+ window.hasHoveringPointer(deviceId, pointerId))) {
+ return true;
+ }
+ }
+ return false;
+}
+
+std::string InputDispatcher::DispatcherTouchState::dump() const {
+ std::string dump;
+ if (!mTouchStatesByDisplay.empty()) {
+ dump += StringPrintf("TouchStatesByDisplay:\n");
+ for (const auto& [displayId, state] : mTouchStatesByDisplay) {
+ std::string touchStateDump = addLinePrefix(state.dump(), INDENT);
+ dump += INDENT + displayId.toString() + " : " + touchStateDump;
+ }
+ } else {
+ dump += "TouchStates: <no displays touched>\n";
+ }
+ return dump;
+}
+
+void InputDispatcher::DispatcherTouchState::removeAllPointersForDevice(android::DeviceId deviceId) {
+ for (auto& [_, touchState] : mTouchStatesByDisplay) {
+ touchState.removeAllPointersForDevice(deviceId);
+ }
+}
+
+void InputDispatcher::DispatcherTouchState::clear() {
+ mTouchStatesByDisplay.clear();
+}
+
} // namespace android::inputdispatcher
diff --git a/services/inputflinger/dispatcher/InputDispatcher.h b/services/inputflinger/dispatcher/InputDispatcher.h
index 58c8509..f590806 100644
--- a/services/inputflinger/dispatcher/InputDispatcher.h
+++ b/services/inputflinger/dispatcher/InputDispatcher.h
@@ -352,6 +352,12 @@
class DispatcherTouchState {
public:
+ struct CancellationArgs {
+ const sp<gui::WindowInfoHandle> windowHandle;
+ CancelationOptions::Mode mode;
+ std::optional<DeviceId> deviceId;
+ };
+
static void addPointerWindowTarget(const sp<android::gui::WindowInfoHandle>& windowHandle,
InputTarget::DispatchMode dispatchMode,
ftl::Flags<InputTarget::Flags> targetFlags,
@@ -373,14 +379,37 @@
sp<android::gui::WindowInfoHandle> findTouchedForegroundWindow(
ui::LogicalDisplayId displayId) const;
+ bool hasTouchingOrHoveringPointers(ui::LogicalDisplayId displayId, int32_t deviceId) const;
+
+ bool isPointerInWindow(const sp<android::IBinder>& token, ui::LogicalDisplayId displayId,
+ DeviceId deviceId, int32_t pointerId) const;
+
+ std::string dump() const;
+
+ // Updates the touchState for display from WindowInfo,
+ // return vector of CancellationArgs for every cancelled touch
+ std::list<CancellationArgs> updateFromWindowInfo(ui::LogicalDisplayId displayId,
+ const DispatcherWindowInfo& windowInfos);
+
+ void removeAllPointersForDevice(DeviceId deviceId);
+
+ void clear();
+
std::unordered_map<ui::LogicalDisplayId, TouchState> mTouchStatesByDisplay;
private:
+ static std::list<CancellationArgs> eraseRemovedWindowsFromWindowInfo(
+ TouchState& state, ui::LogicalDisplayId displayId,
+ const DispatcherWindowInfo& windowInfos);
+
+ static std::list<CancellationArgs> updateHoveringStateFromWindowInfo(
+ TouchState& state, ui::LogicalDisplayId displayId,
+ const DispatcherWindowInfo& windowInfos);
+
static std::vector<InputTarget> findOutsideTargets(
- ui::LogicalDisplayId displayId,
- const sp<android::gui::WindowInfoHandle>& touchedWindow, int32_t pointerId,
- const ConnectionManager& connections, const DispatcherWindowInfo& windowInfos,
- std::function<void()> dump);
+ ui::LogicalDisplayId displayId, const sp<gui::WindowInfoHandle>& touchedWindow,
+ int32_t pointerId, const ConnectionManager& connections,
+ const DispatcherWindowInfo& windowInfos, std::function<void()> dump);
/**
* Slip the wallpaper touch if necessary.
diff --git a/services/inputflinger/tests/InputDispatcher_test.cpp b/services/inputflinger/tests/InputDispatcher_test.cpp
index 368db1b..c0e2060 100644
--- a/services/inputflinger/tests/InputDispatcher_test.cpp
+++ b/services/inputflinger/tests/InputDispatcher_test.cpp
@@ -9959,57 +9959,63 @@
InputDispatcherUserActivityPokeTests, MinPokeTimeObserved,
REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(com::android::input::flags,
rate_limit_user_activity_poke_in_dispatcher))) {
+ // Use current time otherwise events may be dropped due to being stale.
+ const nsecs_t currentTime = systemTime(SYSTEM_TIME_MONOTONIC);
+
mDispatcher->setMinTimeBetweenUserActivityPokes(50ms);
// First event of type TOUCH. Should poke.
notifyAndConsumeMotion(ACTION_DOWN, AINPUT_SOURCE_TOUCHSCREEN, ui::LogicalDisplayId::DEFAULT,
- milliseconds_to_nanoseconds(50));
+ currentTime + milliseconds_to_nanoseconds(50));
mFakePolicy->assertUserActivityPoked(
- {{milliseconds_to_nanoseconds(50), USER_ACTIVITY_EVENT_TOUCH,
+ {{currentTime + milliseconds_to_nanoseconds(50), USER_ACTIVITY_EVENT_TOUCH,
ui::LogicalDisplayId::DEFAULT}});
// 80ns > 50ns has passed since previous TOUCH event. Should poke.
notifyAndConsumeMotion(ACTION_MOVE, AINPUT_SOURCE_TOUCHSCREEN, ui::LogicalDisplayId::DEFAULT,
- milliseconds_to_nanoseconds(130));
+ currentTime + milliseconds_to_nanoseconds(130));
mFakePolicy->assertUserActivityPoked(
- {{milliseconds_to_nanoseconds(130), USER_ACTIVITY_EVENT_TOUCH,
+ {{currentTime + milliseconds_to_nanoseconds(130), USER_ACTIVITY_EVENT_TOUCH,
ui::LogicalDisplayId::DEFAULT}});
// First event of type OTHER. Should poke (despite being within 50ns of previous TOUCH event).
notifyAndConsumeMotion(ACTION_SCROLL, AINPUT_SOURCE_ROTARY_ENCODER,
- ui::LogicalDisplayId::DEFAULT, milliseconds_to_nanoseconds(135));
+ ui::LogicalDisplayId::DEFAULT,
+ currentTime + milliseconds_to_nanoseconds(135));
mFakePolicy->assertUserActivityPoked(
- {{milliseconds_to_nanoseconds(135), USER_ACTIVITY_EVENT_OTHER,
+ {{currentTime + milliseconds_to_nanoseconds(135), USER_ACTIVITY_EVENT_OTHER,
ui::LogicalDisplayId::DEFAULT}});
// Within 50ns of previous TOUCH event. Should NOT poke.
notifyAndConsumeMotion(ACTION_UP, AINPUT_SOURCE_TOUCHSCREEN, ui::LogicalDisplayId::DEFAULT,
- milliseconds_to_nanoseconds(140));
+ currentTime + milliseconds_to_nanoseconds(140));
mFakePolicy->assertUserActivityNotPoked();
// Within 50ns of previous OTHER event. Should NOT poke.
notifyAndConsumeMotion(ACTION_SCROLL, AINPUT_SOURCE_ROTARY_ENCODER,
- ui::LogicalDisplayId::DEFAULT, milliseconds_to_nanoseconds(150));
+ ui::LogicalDisplayId::DEFAULT,
+ currentTime + milliseconds_to_nanoseconds(150));
mFakePolicy->assertUserActivityNotPoked();
// Within 50ns of previous TOUCH event (which was at time 130). Should NOT poke.
// Note that STYLUS is mapped to TOUCH user activity, since it's a pointer-type source.
notifyAndConsumeMotion(ACTION_DOWN, AINPUT_SOURCE_STYLUS, ui::LogicalDisplayId::DEFAULT,
- milliseconds_to_nanoseconds(160));
+ currentTime + milliseconds_to_nanoseconds(160));
mFakePolicy->assertUserActivityNotPoked();
// 65ns > 50ns has passed since previous OTHER event. Should poke.
notifyAndConsumeMotion(ACTION_SCROLL, AINPUT_SOURCE_ROTARY_ENCODER,
- ui::LogicalDisplayId::DEFAULT, milliseconds_to_nanoseconds(200));
+ ui::LogicalDisplayId::DEFAULT,
+ currentTime + milliseconds_to_nanoseconds(200));
mFakePolicy->assertUserActivityPoked(
- {{milliseconds_to_nanoseconds(200), USER_ACTIVITY_EVENT_OTHER,
+ {{currentTime + milliseconds_to_nanoseconds(200), USER_ACTIVITY_EVENT_OTHER,
ui::LogicalDisplayId::DEFAULT}});
// 170ns > 50ns has passed since previous TOUCH event. Should poke.
notifyAndConsumeMotion(ACTION_UP, AINPUT_SOURCE_STYLUS, ui::LogicalDisplayId::DEFAULT,
- milliseconds_to_nanoseconds(300));
+ currentTime + milliseconds_to_nanoseconds(300));
mFakePolicy->assertUserActivityPoked(
- {{milliseconds_to_nanoseconds(300), USER_ACTIVITY_EVENT_TOUCH,
+ {{currentTime + milliseconds_to_nanoseconds(300), USER_ACTIVITY_EVENT_TOUCH,
ui::LogicalDisplayId::DEFAULT}});
// Assert that there's no more user activity poke event.
@@ -10020,20 +10026,22 @@
InputDispatcherUserActivityPokeTests, DefaultMinPokeTimeOf100MsUsed,
REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(com::android::input::flags,
rate_limit_user_activity_poke_in_dispatcher))) {
+ // Use current time otherwise events may be dropped due to being stale.
+ const nsecs_t currentTime = systemTime(SYSTEM_TIME_MONOTONIC);
notifyAndConsumeMotion(ACTION_DOWN, AINPUT_SOURCE_TOUCHSCREEN, ui::LogicalDisplayId::DEFAULT,
- milliseconds_to_nanoseconds(200));
+ currentTime + milliseconds_to_nanoseconds(200));
mFakePolicy->assertUserActivityPoked(
- {{milliseconds_to_nanoseconds(200), USER_ACTIVITY_EVENT_TOUCH,
+ {{currentTime + milliseconds_to_nanoseconds(200), USER_ACTIVITY_EVENT_TOUCH,
ui::LogicalDisplayId::DEFAULT}});
notifyAndConsumeMotion(ACTION_MOVE, AINPUT_SOURCE_TOUCHSCREEN, ui::LogicalDisplayId::DEFAULT,
- milliseconds_to_nanoseconds(280));
+ currentTime + milliseconds_to_nanoseconds(280));
mFakePolicy->assertUserActivityNotPoked();
notifyAndConsumeMotion(ACTION_UP, AINPUT_SOURCE_TOUCHSCREEN, ui::LogicalDisplayId::DEFAULT,
- milliseconds_to_nanoseconds(340));
+ currentTime + milliseconds_to_nanoseconds(340));
mFakePolicy->assertUserActivityPoked(
- {{milliseconds_to_nanoseconds(340), USER_ACTIVITY_EVENT_TOUCH,
+ {{currentTime + milliseconds_to_nanoseconds(340), USER_ACTIVITY_EVENT_TOUCH,
ui::LogicalDisplayId::DEFAULT}});
}
@@ -10041,14 +10049,16 @@
InputDispatcherUserActivityPokeTests, ZeroMinPokeTimeDisablesRateLimiting,
REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(com::android::input::flags,
rate_limit_user_activity_poke_in_dispatcher))) {
+ // Use current time otherwise events may be dropped due to being stale.
+ const nsecs_t currentTime = systemTime(SYSTEM_TIME_MONOTONIC);
mDispatcher->setMinTimeBetweenUserActivityPokes(0ms);
notifyAndConsumeMotion(ACTION_DOWN, AINPUT_SOURCE_TOUCHSCREEN, ui::LogicalDisplayId::DEFAULT,
- 20);
+ currentTime + 20);
mFakePolicy->assertUserActivityPoked();
notifyAndConsumeMotion(ACTION_MOVE, AINPUT_SOURCE_TOUCHSCREEN, ui::LogicalDisplayId::DEFAULT,
- 30);
+ currentTime + 30);
mFakePolicy->assertUserActivityPoked();
}