blob: 93aa6aca6df3aba1e213f54ce9f8e241311d8591 [file] [log] [blame]
Michael Wrightd02c5b62014-02-10 15:10:22 -08001/*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Garfield Tan0fc2fa72019-08-29 17:22:15 -070017#include "../dispatcher/InputDispatcher.h"
Michael Wrightd02c5b62014-02-10 15:10:22 -080018
Garfield Tan1c7bc862020-01-28 13:24:04 -080019#include <android-base/stringprintf.h>
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -070020#include <android-base/thread_annotations.h>
Robert Carr803535b2018-08-02 16:38:15 -070021#include <binder/Binder.h>
Michael Wrightd02c5b62014-02-10 15:10:22 -080022#include <gtest/gtest.h>
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -100023#include <input/Input.h>
Michael Wrightd02c5b62014-02-10 15:10:22 -080024#include <linux/input.h>
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -100025
Garfield Tan1c7bc862020-01-28 13:24:04 -080026#include <cinttypes>
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -070027#include <thread>
Garfield Tan1c7bc862020-01-28 13:24:04 -080028#include <unordered_set>
chaviwd1c23182019-12-20 18:44:56 -080029#include <vector>
Michael Wrightd02c5b62014-02-10 15:10:22 -080030
Garfield Tan1c7bc862020-01-28 13:24:04 -080031using android::base::StringPrintf;
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -080032using android::os::InputEventInjectionResult;
33using android::os::InputEventInjectionSync;
Bernardo Rufinoc3b7b8c2021-01-29 17:38:07 +000034using android::os::TouchOcclusionMode;
Michael Wright44753b12020-07-08 13:48:11 +010035using namespace android::flag_operators;
Garfield Tan1c7bc862020-01-28 13:24:04 -080036
Garfield Tane84e6f92019-08-29 17:28:41 -070037namespace android::inputdispatcher {
Michael Wrightd02c5b62014-02-10 15:10:22 -080038
39// An arbitrary time value.
40static const nsecs_t ARBITRARY_TIME = 1234;
41
42// An arbitrary device id.
43static const int32_t DEVICE_ID = 1;
44
Jeff Brownf086ddb2014-02-11 14:28:48 -080045// An arbitrary display id.
Siarhei Vishniakou777a10b2018-01-31 16:45:06 -080046static const int32_t DISPLAY_ID = ADISPLAY_ID_DEFAULT;
Jeff Brownf086ddb2014-02-11 14:28:48 -080047
Michael Wrightd02c5b62014-02-10 15:10:22 -080048// An arbitrary injector pid / uid pair that has permission to inject events.
49static const int32_t INJECTOR_PID = 999;
50static const int32_t INJECTOR_UID = 1001;
51
Siarhei Vishniakou58cfc602020-12-14 23:21:30 +000052// An arbitrary pid of the gesture monitor window
53static constexpr int32_t MONITOR_PID = 2001;
54
chaviwd1c23182019-12-20 18:44:56 -080055struct PointF {
56 float x;
57 float y;
58};
Michael Wrightd02c5b62014-02-10 15:10:22 -080059
Gang Wang342c9272020-01-13 13:15:04 -050060/**
61 * Return a DOWN key event with KEYCODE_A.
62 */
63static KeyEvent getTestKeyEvent() {
64 KeyEvent event;
65
Garfield Tanfbe732e2020-01-24 11:26:14 -080066 event.initialize(InputEvent::nextId(), DEVICE_ID, AINPUT_SOURCE_KEYBOARD, ADISPLAY_ID_NONE,
67 INVALID_HMAC, AKEY_EVENT_ACTION_DOWN, 0, AKEYCODE_A, KEY_A, AMETA_NONE, 0,
68 ARBITRARY_TIME, ARBITRARY_TIME);
Gang Wang342c9272020-01-13 13:15:04 -050069 return event;
70}
71
Michael Wrightd02c5b62014-02-10 15:10:22 -080072// --- FakeInputDispatcherPolicy ---
73
74class FakeInputDispatcherPolicy : public InputDispatcherPolicyInterface {
75 InputDispatcherConfiguration mConfig;
76
77protected:
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -100078 virtual ~FakeInputDispatcherPolicy() {}
Michael Wrightd02c5b62014-02-10 15:10:22 -080079
80public:
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -100081 FakeInputDispatcherPolicy() {}
Jackal Guof9696682018-10-05 12:23:23 +080082
Siarhei Vishniakou8935a802019-11-15 16:41:44 -080083 void assertFilterInputEventWasCalled(const NotifyKeyArgs& args) {
Siarhei Vishniakoud99e1b62019-11-26 11:01:06 -080084 assertFilterInputEventWasCalled(AINPUT_EVENT_TYPE_KEY, args.eventTime, args.action,
85 args.displayId);
Jackal Guof9696682018-10-05 12:23:23 +080086 }
87
Siarhei Vishniakou8935a802019-11-15 16:41:44 -080088 void assertFilterInputEventWasCalled(const NotifyMotionArgs& args) {
Siarhei Vishniakoud99e1b62019-11-26 11:01:06 -080089 assertFilterInputEventWasCalled(AINPUT_EVENT_TYPE_MOTION, args.eventTime, args.action,
90 args.displayId);
Jackal Guof9696682018-10-05 12:23:23 +080091 }
92
Siarhei Vishniakoucd899e82020-05-08 09:24:29 -070093 void assertFilterInputEventWasNotCalled() {
94 std::scoped_lock lock(mLock);
95 ASSERT_EQ(nullptr, mFilteredEvent);
96 }
Michael Wrightd02c5b62014-02-10 15:10:22 -080097
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -080098 void assertNotifyConfigurationChangedWasCalled(nsecs_t when) {
Siarhei Vishniakoucd899e82020-05-08 09:24:29 -070099 std::scoped_lock lock(mLock);
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -0800100 ASSERT_TRUE(mConfigurationChangedTime)
101 << "Timed out waiting for configuration changed call";
102 ASSERT_EQ(*mConfigurationChangedTime, when);
103 mConfigurationChangedTime = std::nullopt;
104 }
105
106 void assertNotifySwitchWasCalled(const NotifySwitchArgs& args) {
Siarhei Vishniakoucd899e82020-05-08 09:24:29 -0700107 std::scoped_lock lock(mLock);
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -0800108 ASSERT_TRUE(mLastNotifySwitch);
Garfield Tanc51d1ba2020-01-28 13:24:04 -0800109 // We do not check id because it is not exposed to the policy
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -0800110 EXPECT_EQ(args.eventTime, mLastNotifySwitch->eventTime);
111 EXPECT_EQ(args.policyFlags, mLastNotifySwitch->policyFlags);
112 EXPECT_EQ(args.switchValues, mLastNotifySwitch->switchValues);
113 EXPECT_EQ(args.switchMask, mLastNotifySwitch->switchMask);
114 mLastNotifySwitch = std::nullopt;
115 }
116
chaviwfd6d3512019-03-25 13:23:49 -0700117 void assertOnPointerDownEquals(const sp<IBinder>& touchedToken) {
Siarhei Vishniakoucd899e82020-05-08 09:24:29 -0700118 std::scoped_lock lock(mLock);
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -0800119 ASSERT_EQ(touchedToken, mOnPointerDownToken);
120 mOnPointerDownToken.clear();
121 }
122
123 void assertOnPointerDownWasNotCalled() {
Siarhei Vishniakoucd899e82020-05-08 09:24:29 -0700124 std::scoped_lock lock(mLock);
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -0800125 ASSERT_TRUE(mOnPointerDownToken == nullptr)
126 << "Expected onPointerDownOutsideFocus to not have been called";
chaviwfd6d3512019-03-25 13:23:49 -0700127 }
128
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -0700129 // This function must be called soon after the expected ANR timer starts,
130 // because we are also checking how much time has passed.
Siarhei Vishniakou234129c2020-10-22 22:28:12 -0500131 void assertNotifyNoFocusedWindowAnrWasCalled(
Chris Yea209fde2020-07-22 13:54:51 -0700132 std::chrono::nanoseconds timeout,
Siarhei Vishniakou234129c2020-10-22 22:28:12 -0500133 const std::shared_ptr<InputApplicationHandle>& expectedApplication) {
134 std::shared_ptr<InputApplicationHandle> application;
135 { // acquire lock
136 std::unique_lock lock(mLock);
137 android::base::ScopedLockAssertion assumeLocked(mLock);
138 ASSERT_NO_FATAL_FAILURE(
139 application = getAnrTokenLockedInterruptible(timeout, mAnrApplications, lock));
140 } // release lock
141 ASSERT_EQ(expectedApplication, application);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700142 }
143
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +0000144 void assertNotifyWindowUnresponsiveWasCalled(std::chrono::nanoseconds timeout,
145 const sp<IBinder>& expectedConnectionToken) {
146 sp<IBinder> connectionToken = getUnresponsiveWindowToken(timeout);
Siarhei Vishniakou234129c2020-10-22 22:28:12 -0500147 ASSERT_EQ(expectedConnectionToken, connectionToken);
148 }
149
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +0000150 void assertNotifyWindowResponsiveWasCalled(const sp<IBinder>& expectedConnectionToken) {
151 sp<IBinder> connectionToken = getResponsiveWindowToken();
Siarhei Vishniakou234129c2020-10-22 22:28:12 -0500152 ASSERT_EQ(expectedConnectionToken, connectionToken);
153 }
154
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +0000155 void assertNotifyMonitorUnresponsiveWasCalled(std::chrono::nanoseconds timeout) {
156 int32_t pid = getUnresponsiveMonitorPid(timeout);
157 ASSERT_EQ(MONITOR_PID, pid);
Siarhei Vishniakou234129c2020-10-22 22:28:12 -0500158 }
159
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +0000160 void assertNotifyMonitorResponsiveWasCalled() {
161 int32_t pid = getResponsiveMonitorPid();
162 ASSERT_EQ(MONITOR_PID, pid);
163 }
164
165 sp<IBinder> getUnresponsiveWindowToken(std::chrono::nanoseconds timeout) {
Siarhei Vishniakou234129c2020-10-22 22:28:12 -0500166 std::unique_lock lock(mLock);
167 android::base::ScopedLockAssertion assumeLocked(mLock);
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +0000168 return getAnrTokenLockedInterruptible(timeout, mAnrWindowTokens, lock);
169 }
170
171 sp<IBinder> getResponsiveWindowToken() {
172 std::unique_lock lock(mLock);
173 android::base::ScopedLockAssertion assumeLocked(mLock);
174 return getAnrTokenLockedInterruptible(0s, mResponsiveWindowTokens, lock);
175 }
176
177 int32_t getUnresponsiveMonitorPid(std::chrono::nanoseconds timeout) {
178 std::unique_lock lock(mLock);
179 android::base::ScopedLockAssertion assumeLocked(mLock);
180 return getAnrTokenLockedInterruptible(timeout, mAnrMonitorPids, lock);
181 }
182
183 int32_t getResponsiveMonitorPid() {
184 std::unique_lock lock(mLock);
185 android::base::ScopedLockAssertion assumeLocked(mLock);
186 return getAnrTokenLockedInterruptible(0s, mResponsiveMonitorPids, lock);
Siarhei Vishniakou234129c2020-10-22 22:28:12 -0500187 }
188
189 // All three ANR-related callbacks behave the same way, so we use this generic function to wait
190 // for a specific container to become non-empty. When the container is non-empty, return the
191 // first entry from the container and erase it.
192 template <class T>
193 T getAnrTokenLockedInterruptible(std::chrono::nanoseconds timeout, std::queue<T>& storage,
194 std::unique_lock<std::mutex>& lock) REQUIRES(mLock) {
195 const std::chrono::time_point start = std::chrono::steady_clock::now();
196 std::chrono::duration timeToWait = timeout + 100ms; // provide some slack
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -0700197
198 // If there is an ANR, Dispatcher won't be idle because there are still events
199 // in the waitQueue that we need to check on. So we can't wait for dispatcher to be idle
200 // before checking if ANR was called.
Siarhei Vishniakou234129c2020-10-22 22:28:12 -0500201 // Since dispatcher is not guaranteed to call notifyNoFocusedWindowAnr right away, we need
202 // to provide it some time to act. 100ms seems reasonable.
203 mNotifyAnr.wait_for(lock, timeToWait,
204 [&storage]() REQUIRES(mLock) { return !storage.empty(); });
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -0700205 const std::chrono::duration waited = std::chrono::steady_clock::now() - start;
Siarhei Vishniakou234129c2020-10-22 22:28:12 -0500206 if (storage.empty()) {
207 ADD_FAILURE() << "Did not receive the ANR callback";
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +0000208 return {};
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700209 }
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -0700210 // Ensure that the ANR didn't get raised too early. We can't be too strict here because
211 // the dispatcher started counting before this function was called
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700212 if (std::chrono::abs(timeout - waited) > 100ms) {
213 ADD_FAILURE() << "ANR was raised too early or too late. Expected "
214 << std::chrono::duration_cast<std::chrono::milliseconds>(timeout).count()
215 << "ms, but waited "
216 << std::chrono::duration_cast<std::chrono::milliseconds>(waited).count()
217 << "ms instead";
218 }
Siarhei Vishniakou234129c2020-10-22 22:28:12 -0500219 T token = storage.front();
220 storage.pop();
221 return token;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700222 }
223
224 void assertNotifyAnrWasNotCalled() {
225 std::scoped_lock lock(mLock);
226 ASSERT_TRUE(mAnrApplications.empty());
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +0000227 ASSERT_TRUE(mAnrWindowTokens.empty());
228 ASSERT_TRUE(mAnrMonitorPids.empty());
229 ASSERT_TRUE(mResponsiveWindowTokens.empty())
Siarhei Vishniakou234129c2020-10-22 22:28:12 -0500230 << "ANR was not called, but please also consume the 'connection is responsive' "
231 "signal";
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +0000232 ASSERT_TRUE(mResponsiveMonitorPids.empty())
233 << "Monitor ANR was not called, but please also consume the 'monitor is responsive'"
234 " signal";
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -0700235 }
236
Garfield Tan1c7bc862020-01-28 13:24:04 -0800237 void setKeyRepeatConfiguration(nsecs_t timeout, nsecs_t delay) {
238 mConfig.keyRepeatTimeout = timeout;
239 mConfig.keyRepeatDelay = delay;
240 }
241
Prabir Pradhan99987712020-11-10 18:43:05 -0800242 void waitForSetPointerCapture(bool enabled) {
243 std::unique_lock lock(mLock);
244 base::ScopedLockAssertion assumeLocked(mLock);
245
246 if (!mPointerCaptureChangedCondition.wait_for(lock, 100ms,
247 [this, enabled]() REQUIRES(mLock) {
248 return mPointerCaptureEnabled &&
249 *mPointerCaptureEnabled ==
250 enabled;
251 })) {
252 FAIL() << "Timed out waiting for setPointerCapture(" << enabled << ") to be called.";
253 }
254 mPointerCaptureEnabled.reset();
255 }
256
257 void assertSetPointerCaptureNotCalled() {
258 std::unique_lock lock(mLock);
259 base::ScopedLockAssertion assumeLocked(mLock);
260
261 if (mPointerCaptureChangedCondition.wait_for(lock, 100ms) != std::cv_status::timeout) {
262 FAIL() << "Expected setPointerCapture(enabled) to not be called, but was called. "
263 "enabled = "
264 << *mPointerCaptureEnabled;
265 }
266 mPointerCaptureEnabled.reset();
267 }
268
arthurhungf452d0b2021-01-06 00:19:52 +0800269 void assertDropTargetEquals(const sp<IBinder>& targetToken) {
270 std::scoped_lock lock(mLock);
Arthur Hung6d0571e2021-04-09 20:18:16 +0800271 ASSERT_TRUE(mNotifyDropWindowWasCalled);
arthurhungf452d0b2021-01-06 00:19:52 +0800272 ASSERT_EQ(targetToken, mDropTargetWindowToken);
Arthur Hung6d0571e2021-04-09 20:18:16 +0800273 mNotifyDropWindowWasCalled = false;
arthurhungf452d0b2021-01-06 00:19:52 +0800274 }
275
Michael Wrightd02c5b62014-02-10 15:10:22 -0800276private:
Siarhei Vishniakoucd899e82020-05-08 09:24:29 -0700277 std::mutex mLock;
278 std::unique_ptr<InputEvent> mFilteredEvent GUARDED_BY(mLock);
279 std::optional<nsecs_t> mConfigurationChangedTime GUARDED_BY(mLock);
280 sp<IBinder> mOnPointerDownToken GUARDED_BY(mLock);
281 std::optional<NotifySwitchArgs> mLastNotifySwitch GUARDED_BY(mLock);
Jackal Guof9696682018-10-05 12:23:23 +0800282
Prabir Pradhan99987712020-11-10 18:43:05 -0800283 std::condition_variable mPointerCaptureChangedCondition;
284 std::optional<bool> mPointerCaptureEnabled GUARDED_BY(mLock);
285
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -0700286 // ANR handling
Chris Yea209fde2020-07-22 13:54:51 -0700287 std::queue<std::shared_ptr<InputApplicationHandle>> mAnrApplications GUARDED_BY(mLock);
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +0000288 std::queue<sp<IBinder>> mAnrWindowTokens GUARDED_BY(mLock);
289 std::queue<sp<IBinder>> mResponsiveWindowTokens GUARDED_BY(mLock);
290 std::queue<int32_t> mAnrMonitorPids GUARDED_BY(mLock);
291 std::queue<int32_t> mResponsiveMonitorPids GUARDED_BY(mLock);
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -0700292 std::condition_variable mNotifyAnr;
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -0700293
arthurhungf452d0b2021-01-06 00:19:52 +0800294 sp<IBinder> mDropTargetWindowToken GUARDED_BY(mLock);
Arthur Hung6d0571e2021-04-09 20:18:16 +0800295 bool mNotifyDropWindowWasCalled GUARDED_BY(mLock) = false;
arthurhungf452d0b2021-01-06 00:19:52 +0800296
Siarhei Vishniakou2b4782c2020-11-07 01:51:18 -0600297 void notifyConfigurationChanged(nsecs_t when) override {
Siarhei Vishniakoucd899e82020-05-08 09:24:29 -0700298 std::scoped_lock lock(mLock);
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -0800299 mConfigurationChangedTime = when;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800300 }
301
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +0000302 void notifyWindowUnresponsive(const sp<IBinder>& connectionToken, const std::string&) override {
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -0700303 std::scoped_lock lock(mLock);
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +0000304 mAnrWindowTokens.push(connectionToken);
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -0700305 mNotifyAnr.notify_all();
Siarhei Vishniakou234129c2020-10-22 22:28:12 -0500306 }
307
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +0000308 void notifyMonitorUnresponsive(int32_t pid, const std::string&) override {
Siarhei Vishniakou234129c2020-10-22 22:28:12 -0500309 std::scoped_lock lock(mLock);
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +0000310 mAnrMonitorPids.push(pid);
311 mNotifyAnr.notify_all();
312 }
313
314 void notifyWindowResponsive(const sp<IBinder>& connectionToken) override {
315 std::scoped_lock lock(mLock);
316 mResponsiveWindowTokens.push(connectionToken);
317 mNotifyAnr.notify_all();
318 }
319
320 void notifyMonitorResponsive(int32_t pid) override {
321 std::scoped_lock lock(mLock);
322 mResponsiveMonitorPids.push(pid);
Siarhei Vishniakou234129c2020-10-22 22:28:12 -0500323 mNotifyAnr.notify_all();
324 }
325
326 void notifyNoFocusedWindowAnr(
327 const std::shared_ptr<InputApplicationHandle>& applicationHandle) override {
328 std::scoped_lock lock(mLock);
329 mAnrApplications.push(applicationHandle);
330 mNotifyAnr.notify_all();
Michael Wrightd02c5b62014-02-10 15:10:22 -0800331 }
332
Siarhei Vishniakou2b4782c2020-11-07 01:51:18 -0600333 void notifyInputChannelBroken(const sp<IBinder>&) override {}
Michael Wrightd02c5b62014-02-10 15:10:22 -0800334
Siarhei Vishniakou2b4782c2020-11-07 01:51:18 -0600335 void notifyFocusChanged(const sp<IBinder>&, const sp<IBinder>&) override {}
Robert Carr740167f2018-10-11 19:03:41 -0700336
Siarhei Vishniakou2b4782c2020-11-07 01:51:18 -0600337 void notifyUntrustedTouch(const std::string& obscuringPackage) override {}
Chris Yef59a2f42020-10-16 12:55:26 -0700338 void notifySensorEvent(int32_t deviceId, InputDeviceSensorType sensorType,
339 InputDeviceSensorAccuracy accuracy, nsecs_t timestamp,
340 const std::vector<float>& values) override {}
341
342 void notifySensorAccuracy(int deviceId, InputDeviceSensorType sensorType,
343 InputDeviceSensorAccuracy accuracy) override {}
Bernardo Rufino2e1f6512020-10-08 13:42:07 +0000344
Chris Yefb552902021-02-03 17:18:37 -0800345 void notifyVibratorState(int32_t deviceId, bool isOn) override {}
346
Siarhei Vishniakou2b4782c2020-11-07 01:51:18 -0600347 void getDispatcherConfiguration(InputDispatcherConfiguration* outConfig) override {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800348 *outConfig = mConfig;
349 }
350
Siarhei Vishniakou2b4782c2020-11-07 01:51:18 -0600351 bool filterInputEvent(const InputEvent* inputEvent, uint32_t policyFlags) override {
Siarhei Vishniakoucd899e82020-05-08 09:24:29 -0700352 std::scoped_lock lock(mLock);
Jackal Guof9696682018-10-05 12:23:23 +0800353 switch (inputEvent->getType()) {
354 case AINPUT_EVENT_TYPE_KEY: {
355 const KeyEvent* keyEvent = static_cast<const KeyEvent*>(inputEvent);
Siarhei Vishniakou8935a802019-11-15 16:41:44 -0800356 mFilteredEvent = std::make_unique<KeyEvent>(*keyEvent);
Jackal Guof9696682018-10-05 12:23:23 +0800357 break;
358 }
359
360 case AINPUT_EVENT_TYPE_MOTION: {
361 const MotionEvent* motionEvent = static_cast<const MotionEvent*>(inputEvent);
Siarhei Vishniakou8935a802019-11-15 16:41:44 -0800362 mFilteredEvent = std::make_unique<MotionEvent>(*motionEvent);
Jackal Guof9696682018-10-05 12:23:23 +0800363 break;
364 }
365 }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800366 return true;
367 }
368
Siarhei Vishniakou2b4782c2020-11-07 01:51:18 -0600369 void interceptKeyBeforeQueueing(const KeyEvent*, uint32_t&) override {}
Michael Wrightd02c5b62014-02-10 15:10:22 -0800370
Siarhei Vishniakou2b4782c2020-11-07 01:51:18 -0600371 void interceptMotionBeforeQueueing(int32_t, nsecs_t, uint32_t&) override {}
Michael Wrightd02c5b62014-02-10 15:10:22 -0800372
Siarhei Vishniakou2b4782c2020-11-07 01:51:18 -0600373 nsecs_t interceptKeyBeforeDispatching(const sp<IBinder>&, const KeyEvent*, uint32_t) override {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800374 return 0;
375 }
376
Siarhei Vishniakou2b4782c2020-11-07 01:51:18 -0600377 bool dispatchUnhandledKey(const sp<IBinder>&, const KeyEvent*, uint32_t, KeyEvent*) override {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800378 return false;
379 }
380
Siarhei Vishniakou2b4782c2020-11-07 01:51:18 -0600381 void notifySwitch(nsecs_t when, uint32_t switchValues, uint32_t switchMask,
382 uint32_t policyFlags) override {
Siarhei Vishniakoucd899e82020-05-08 09:24:29 -0700383 std::scoped_lock lock(mLock);
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -0800384 /** We simply reconstruct NotifySwitchArgs in policy because InputDispatcher is
385 * essentially a passthrough for notifySwitch.
386 */
Garfield Tanc51d1ba2020-01-28 13:24:04 -0800387 mLastNotifySwitch = NotifySwitchArgs(1 /*id*/, when, policyFlags, switchValues, switchMask);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800388 }
389
Sean Stoutb4e0a592021-02-23 07:34:53 -0800390 void pokeUserActivity(nsecs_t, int32_t, int32_t) override {}
Michael Wrightd02c5b62014-02-10 15:10:22 -0800391
Prabir Pradhan93f342c2021-03-11 15:05:30 -0800392 bool checkInjectEventsPermissionNonReentrant(int32_t pid, int32_t uid) override {
393 return pid == INJECTOR_PID && uid == INJECTOR_UID;
394 }
Jackal Guof9696682018-10-05 12:23:23 +0800395
Siarhei Vishniakou2b4782c2020-11-07 01:51:18 -0600396 void onPointerDownOutsideFocus(const sp<IBinder>& newToken) override {
Siarhei Vishniakoucd899e82020-05-08 09:24:29 -0700397 std::scoped_lock lock(mLock);
chaviwfd6d3512019-03-25 13:23:49 -0700398 mOnPointerDownToken = newToken;
399 }
400
Prabir Pradhan99987712020-11-10 18:43:05 -0800401 void setPointerCapture(bool enabled) override {
402 std::scoped_lock lock(mLock);
403 mPointerCaptureEnabled = {enabled};
404 mPointerCaptureChangedCondition.notify_all();
405 }
406
arthurhungf452d0b2021-01-06 00:19:52 +0800407 void notifyDropWindow(const sp<IBinder>& token, float x, float y) override {
408 std::scoped_lock lock(mLock);
Arthur Hung6d0571e2021-04-09 20:18:16 +0800409 mNotifyDropWindowWasCalled = true;
arthurhungf452d0b2021-01-06 00:19:52 +0800410 mDropTargetWindowToken = token;
411 }
412
Siarhei Vishniakoud99e1b62019-11-26 11:01:06 -0800413 void assertFilterInputEventWasCalled(int type, nsecs_t eventTime, int32_t action,
414 int32_t displayId) {
Siarhei Vishniakoucd899e82020-05-08 09:24:29 -0700415 std::scoped_lock lock(mLock);
Siarhei Vishniakoud99e1b62019-11-26 11:01:06 -0800416 ASSERT_NE(nullptr, mFilteredEvent) << "Expected filterInputEvent() to have been called.";
417 ASSERT_EQ(mFilteredEvent->getType(), type);
418
419 if (type == AINPUT_EVENT_TYPE_KEY) {
420 const KeyEvent& keyEvent = static_cast<const KeyEvent&>(*mFilteredEvent);
421 EXPECT_EQ(keyEvent.getEventTime(), eventTime);
422 EXPECT_EQ(keyEvent.getAction(), action);
423 EXPECT_EQ(keyEvent.getDisplayId(), displayId);
424 } else if (type == AINPUT_EVENT_TYPE_MOTION) {
425 const MotionEvent& motionEvent = static_cast<const MotionEvent&>(*mFilteredEvent);
426 EXPECT_EQ(motionEvent.getEventTime(), eventTime);
427 EXPECT_EQ(motionEvent.getAction(), action);
428 EXPECT_EQ(motionEvent.getDisplayId(), displayId);
429 } else {
430 FAIL() << "Unknown type: " << type;
431 }
432
Siarhei Vishniakou8935a802019-11-15 16:41:44 -0800433 mFilteredEvent = nullptr;
Jackal Guof9696682018-10-05 12:23:23 +0800434 }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800435};
436
Michael Wrightd02c5b62014-02-10 15:10:22 -0800437// --- InputDispatcherTest ---
438
439class InputDispatcherTest : public testing::Test {
440protected:
441 sp<FakeInputDispatcherPolicy> mFakePolicy;
442 sp<InputDispatcher> mDispatcher;
443
Siarhei Vishniakouf2652122021-03-05 21:39:46 +0000444 void SetUp() override {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800445 mFakePolicy = new FakeInputDispatcherPolicy();
446 mDispatcher = new InputDispatcher(mFakePolicy);
Arthur Hungb92218b2018-08-14 12:00:21 +0800447 mDispatcher->setInputDispatchMode(/*enabled*/ true, /*frozen*/ false);
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -1000448 // Start InputDispatcher thread
Prabir Pradhan3608aad2019-10-02 17:08:26 -0700449 ASSERT_EQ(OK, mDispatcher->start());
Michael Wrightd02c5b62014-02-10 15:10:22 -0800450 }
451
Siarhei Vishniakouf2652122021-03-05 21:39:46 +0000452 void TearDown() override {
Prabir Pradhan3608aad2019-10-02 17:08:26 -0700453 ASSERT_EQ(OK, mDispatcher->stop());
Michael Wrightd02c5b62014-02-10 15:10:22 -0800454 mFakePolicy.clear();
455 mDispatcher.clear();
456 }
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -0700457
458 /**
459 * Used for debugging when writing the test
460 */
461 void dumpDispatcherState() {
462 std::string dump;
463 mDispatcher->dump(dump);
464 std::stringstream ss(dump);
465 std::string to;
466
467 while (std::getline(ss, to, '\n')) {
468 ALOGE("%s", to.c_str());
469 }
470 }
Vishnu Nair958da932020-08-21 17:12:37 -0700471
472 void setFocusedWindow(const sp<InputWindowHandle>& window,
473 const sp<InputWindowHandle>& focusedWindow = nullptr) {
474 FocusRequest request;
475 request.token = window->getToken();
476 if (focusedWindow) {
477 request.focusedToken = focusedWindow->getToken();
478 }
479 request.timestamp = systemTime(SYSTEM_TIME_MONOTONIC);
480 request.displayId = window->getInfo()->displayId;
481 mDispatcher->setFocusedWindow(request);
482 }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800483};
484
Michael Wrightd02c5b62014-02-10 15:10:22 -0800485TEST_F(InputDispatcherTest, InjectInputEvent_ValidatesKeyEvents) {
486 KeyEvent event;
487
488 // Rejects undefined key actions.
Garfield Tanfbe732e2020-01-24 11:26:14 -0800489 event.initialize(InputEvent::nextId(), DEVICE_ID, AINPUT_SOURCE_KEYBOARD, ADISPLAY_ID_NONE,
490 INVALID_HMAC,
Siarhei Vishniakou9c858ac2020-01-23 14:20:11 -0600491 /*action*/ -1, 0, AKEYCODE_A, KEY_A, AMETA_NONE, 0, ARBITRARY_TIME,
492 ARBITRARY_TIME);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800493 ASSERT_EQ(InputEventInjectionResult::FAILED,
Siarhei Vishniakou097c3db2020-05-06 14:18:38 -0700494 mDispatcher->injectInputEvent(&event, INJECTOR_PID, INJECTOR_UID,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800495 InputEventInjectionSync::NONE, 0ms, 0))
Michael Wrightd02c5b62014-02-10 15:10:22 -0800496 << "Should reject key events with undefined action.";
497
498 // Rejects ACTION_MULTIPLE since it is not supported despite being defined in the API.
Garfield Tanfbe732e2020-01-24 11:26:14 -0800499 event.initialize(InputEvent::nextId(), DEVICE_ID, AINPUT_SOURCE_KEYBOARD, ADISPLAY_ID_NONE,
500 INVALID_HMAC, AKEY_EVENT_ACTION_MULTIPLE, 0, AKEYCODE_A, KEY_A, AMETA_NONE, 0,
Siarhei Vishniakou9c858ac2020-01-23 14:20:11 -0600501 ARBITRARY_TIME, ARBITRARY_TIME);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800502 ASSERT_EQ(InputEventInjectionResult::FAILED,
Siarhei Vishniakou097c3db2020-05-06 14:18:38 -0700503 mDispatcher->injectInputEvent(&event, INJECTOR_PID, INJECTOR_UID,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800504 InputEventInjectionSync::NONE, 0ms, 0))
Michael Wrightd02c5b62014-02-10 15:10:22 -0800505 << "Should reject key events with ACTION_MULTIPLE.";
506}
507
508TEST_F(InputDispatcherTest, InjectInputEvent_ValidatesMotionEvents) {
509 MotionEvent event;
510 PointerProperties pointerProperties[MAX_POINTERS + 1];
511 PointerCoords pointerCoords[MAX_POINTERS + 1];
512 for (int i = 0; i <= MAX_POINTERS; i++) {
513 pointerProperties[i].clear();
514 pointerProperties[i].id = i;
515 pointerCoords[i].clear();
516 }
517
Siarhei Vishniakou49e59222018-12-28 18:17:15 -0800518 // Some constants commonly used below
519 constexpr int32_t source = AINPUT_SOURCE_TOUCHSCREEN;
520 constexpr int32_t edgeFlags = AMOTION_EVENT_EDGE_FLAG_NONE;
521 constexpr int32_t metaState = AMETA_NONE;
522 constexpr MotionClassification classification = MotionClassification::NONE;
523
chaviw9eaa22c2020-07-01 16:21:27 -0700524 ui::Transform identityTransform;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800525 // Rejects undefined motion actions.
Garfield Tanfbe732e2020-01-24 11:26:14 -0800526 event.initialize(InputEvent::nextId(), DEVICE_ID, source, DISPLAY_ID, INVALID_HMAC,
chaviw9eaa22c2020-07-01 16:21:27 -0700527 /*action*/ -1, 0, 0, edgeFlags, metaState, 0, classification,
528 identityTransform, 0, 0, AMOTION_EVENT_INVALID_CURSOR_POSITION,
Evan Rosky84f07f02021-04-16 10:42:42 -0700529 AMOTION_EVENT_INVALID_CURSOR_POSITION, AMOTION_EVENT_INVALID_DISPLAY_SIZE,
530 AMOTION_EVENT_INVALID_DISPLAY_SIZE, ARBITRARY_TIME, ARBITRARY_TIME,
Garfield Tan00f511d2019-06-12 16:55:40 -0700531 /*pointerCount*/ 1, pointerProperties, pointerCoords);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800532 ASSERT_EQ(InputEventInjectionResult::FAILED,
Siarhei Vishniakou097c3db2020-05-06 14:18:38 -0700533 mDispatcher->injectInputEvent(&event, INJECTOR_PID, INJECTOR_UID,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800534 InputEventInjectionSync::NONE, 0ms, 0))
Michael Wrightd02c5b62014-02-10 15:10:22 -0800535 << "Should reject motion events with undefined action.";
536
537 // Rejects pointer down with invalid index.
Garfield Tanfbe732e2020-01-24 11:26:14 -0800538 event.initialize(InputEvent::nextId(), DEVICE_ID, source, DISPLAY_ID, INVALID_HMAC,
Garfield Tan00f511d2019-06-12 16:55:40 -0700539 AMOTION_EVENT_ACTION_POINTER_DOWN |
540 (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
chaviw9eaa22c2020-07-01 16:21:27 -0700541 0, 0, edgeFlags, metaState, 0, classification, identityTransform, 0, 0,
542 AMOTION_EVENT_INVALID_CURSOR_POSITION, AMOTION_EVENT_INVALID_CURSOR_POSITION,
Evan Rosky84f07f02021-04-16 10:42:42 -0700543 AMOTION_EVENT_INVALID_DISPLAY_SIZE, AMOTION_EVENT_INVALID_DISPLAY_SIZE,
chaviw9eaa22c2020-07-01 16:21:27 -0700544 ARBITRARY_TIME, ARBITRARY_TIME, /*pointerCount*/ 1, pointerProperties,
545 pointerCoords);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800546 ASSERT_EQ(InputEventInjectionResult::FAILED,
Siarhei Vishniakou097c3db2020-05-06 14:18:38 -0700547 mDispatcher->injectInputEvent(&event, INJECTOR_PID, INJECTOR_UID,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800548 InputEventInjectionSync::NONE, 0ms, 0))
Michael Wrightd02c5b62014-02-10 15:10:22 -0800549 << "Should reject motion events with pointer down index too large.";
550
Garfield Tanfbe732e2020-01-24 11:26:14 -0800551 event.initialize(InputEvent::nextId(), DEVICE_ID, source, DISPLAY_ID, INVALID_HMAC,
Garfield Tan00f511d2019-06-12 16:55:40 -0700552 AMOTION_EVENT_ACTION_POINTER_DOWN |
553 (~0U << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
chaviw9eaa22c2020-07-01 16:21:27 -0700554 0, 0, edgeFlags, metaState, 0, classification, identityTransform, 0, 0,
555 AMOTION_EVENT_INVALID_CURSOR_POSITION, AMOTION_EVENT_INVALID_CURSOR_POSITION,
Evan Rosky84f07f02021-04-16 10:42:42 -0700556 AMOTION_EVENT_INVALID_DISPLAY_SIZE, AMOTION_EVENT_INVALID_DISPLAY_SIZE,
chaviw9eaa22c2020-07-01 16:21:27 -0700557 ARBITRARY_TIME, ARBITRARY_TIME, /*pointerCount*/ 1, pointerProperties,
558 pointerCoords);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800559 ASSERT_EQ(InputEventInjectionResult::FAILED,
Siarhei Vishniakou097c3db2020-05-06 14:18:38 -0700560 mDispatcher->injectInputEvent(&event, INJECTOR_PID, INJECTOR_UID,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800561 InputEventInjectionSync::NONE, 0ms, 0))
Michael Wrightd02c5b62014-02-10 15:10:22 -0800562 << "Should reject motion events with pointer down index too small.";
563
564 // Rejects pointer up with invalid index.
Garfield Tanfbe732e2020-01-24 11:26:14 -0800565 event.initialize(InputEvent::nextId(), DEVICE_ID, source, DISPLAY_ID, INVALID_HMAC,
Garfield Tan00f511d2019-06-12 16:55:40 -0700566 AMOTION_EVENT_ACTION_POINTER_UP |
567 (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
chaviw9eaa22c2020-07-01 16:21:27 -0700568 0, 0, edgeFlags, metaState, 0, classification, identityTransform, 0, 0,
569 AMOTION_EVENT_INVALID_CURSOR_POSITION, AMOTION_EVENT_INVALID_CURSOR_POSITION,
Evan Rosky84f07f02021-04-16 10:42:42 -0700570 AMOTION_EVENT_INVALID_DISPLAY_SIZE, AMOTION_EVENT_INVALID_DISPLAY_SIZE,
chaviw9eaa22c2020-07-01 16:21:27 -0700571 ARBITRARY_TIME, ARBITRARY_TIME, /*pointerCount*/ 1, pointerProperties,
572 pointerCoords);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800573 ASSERT_EQ(InputEventInjectionResult::FAILED,
Siarhei Vishniakou097c3db2020-05-06 14:18:38 -0700574 mDispatcher->injectInputEvent(&event, INJECTOR_PID, INJECTOR_UID,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800575 InputEventInjectionSync::NONE, 0ms, 0))
Michael Wrightd02c5b62014-02-10 15:10:22 -0800576 << "Should reject motion events with pointer up index too large.";
577
Garfield Tanfbe732e2020-01-24 11:26:14 -0800578 event.initialize(InputEvent::nextId(), DEVICE_ID, source, DISPLAY_ID, INVALID_HMAC,
Garfield Tan00f511d2019-06-12 16:55:40 -0700579 AMOTION_EVENT_ACTION_POINTER_UP |
580 (~0U << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
chaviw9eaa22c2020-07-01 16:21:27 -0700581 0, 0, edgeFlags, metaState, 0, classification, identityTransform, 0, 0,
582 AMOTION_EVENT_INVALID_CURSOR_POSITION, AMOTION_EVENT_INVALID_CURSOR_POSITION,
Evan Rosky84f07f02021-04-16 10:42:42 -0700583 AMOTION_EVENT_INVALID_DISPLAY_SIZE, AMOTION_EVENT_INVALID_DISPLAY_SIZE,
chaviw9eaa22c2020-07-01 16:21:27 -0700584 ARBITRARY_TIME, ARBITRARY_TIME, /*pointerCount*/ 1, pointerProperties,
585 pointerCoords);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800586 ASSERT_EQ(InputEventInjectionResult::FAILED,
Siarhei Vishniakou097c3db2020-05-06 14:18:38 -0700587 mDispatcher->injectInputEvent(&event, INJECTOR_PID, INJECTOR_UID,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800588 InputEventInjectionSync::NONE, 0ms, 0))
Michael Wrightd02c5b62014-02-10 15:10:22 -0800589 << "Should reject motion events with pointer up index too small.";
590
591 // Rejects motion events with invalid number of pointers.
Garfield Tanfbe732e2020-01-24 11:26:14 -0800592 event.initialize(InputEvent::nextId(), DEVICE_ID, source, DISPLAY_ID, INVALID_HMAC,
593 AMOTION_EVENT_ACTION_DOWN, 0, 0, edgeFlags, metaState, 0, classification,
chaviw9eaa22c2020-07-01 16:21:27 -0700594 identityTransform, 0, 0, AMOTION_EVENT_INVALID_CURSOR_POSITION,
Evan Rosky84f07f02021-04-16 10:42:42 -0700595 AMOTION_EVENT_INVALID_CURSOR_POSITION, AMOTION_EVENT_INVALID_DISPLAY_SIZE,
596 AMOTION_EVENT_INVALID_DISPLAY_SIZE, ARBITRARY_TIME, ARBITRARY_TIME,
Garfield Tan00f511d2019-06-12 16:55:40 -0700597 /*pointerCount*/ 0, pointerProperties, pointerCoords);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800598 ASSERT_EQ(InputEventInjectionResult::FAILED,
Siarhei Vishniakou097c3db2020-05-06 14:18:38 -0700599 mDispatcher->injectInputEvent(&event, INJECTOR_PID, INJECTOR_UID,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800600 InputEventInjectionSync::NONE, 0ms, 0))
Michael Wrightd02c5b62014-02-10 15:10:22 -0800601 << "Should reject motion events with 0 pointers.";
602
Garfield Tanfbe732e2020-01-24 11:26:14 -0800603 event.initialize(InputEvent::nextId(), DEVICE_ID, source, DISPLAY_ID, INVALID_HMAC,
604 AMOTION_EVENT_ACTION_DOWN, 0, 0, edgeFlags, metaState, 0, classification,
chaviw9eaa22c2020-07-01 16:21:27 -0700605 identityTransform, 0, 0, AMOTION_EVENT_INVALID_CURSOR_POSITION,
Evan Rosky84f07f02021-04-16 10:42:42 -0700606 AMOTION_EVENT_INVALID_CURSOR_POSITION, AMOTION_EVENT_INVALID_DISPLAY_SIZE,
607 AMOTION_EVENT_INVALID_DISPLAY_SIZE, ARBITRARY_TIME, ARBITRARY_TIME,
Garfield Tan00f511d2019-06-12 16:55:40 -0700608 /*pointerCount*/ MAX_POINTERS + 1, pointerProperties, pointerCoords);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800609 ASSERT_EQ(InputEventInjectionResult::FAILED,
Siarhei Vishniakou097c3db2020-05-06 14:18:38 -0700610 mDispatcher->injectInputEvent(&event, INJECTOR_PID, INJECTOR_UID,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800611 InputEventInjectionSync::NONE, 0ms, 0))
Michael Wrightd02c5b62014-02-10 15:10:22 -0800612 << "Should reject motion events with more than MAX_POINTERS pointers.";
613
614 // Rejects motion events with invalid pointer ids.
615 pointerProperties[0].id = -1;
Garfield Tanfbe732e2020-01-24 11:26:14 -0800616 event.initialize(InputEvent::nextId(), DEVICE_ID, source, DISPLAY_ID, INVALID_HMAC,
617 AMOTION_EVENT_ACTION_DOWN, 0, 0, edgeFlags, metaState, 0, classification,
chaviw9eaa22c2020-07-01 16:21:27 -0700618 identityTransform, 0, 0, AMOTION_EVENT_INVALID_CURSOR_POSITION,
Evan Rosky84f07f02021-04-16 10:42:42 -0700619 AMOTION_EVENT_INVALID_CURSOR_POSITION, AMOTION_EVENT_INVALID_DISPLAY_SIZE,
620 AMOTION_EVENT_INVALID_DISPLAY_SIZE, ARBITRARY_TIME, ARBITRARY_TIME,
Garfield Tan00f511d2019-06-12 16:55:40 -0700621 /*pointerCount*/ 1, pointerProperties, pointerCoords);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800622 ASSERT_EQ(InputEventInjectionResult::FAILED,
Siarhei Vishniakou097c3db2020-05-06 14:18:38 -0700623 mDispatcher->injectInputEvent(&event, INJECTOR_PID, INJECTOR_UID,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800624 InputEventInjectionSync::NONE, 0ms, 0))
Michael Wrightd02c5b62014-02-10 15:10:22 -0800625 << "Should reject motion events with pointer ids less than 0.";
626
627 pointerProperties[0].id = MAX_POINTER_ID + 1;
Garfield Tanfbe732e2020-01-24 11:26:14 -0800628 event.initialize(InputEvent::nextId(), DEVICE_ID, source, DISPLAY_ID, INVALID_HMAC,
629 AMOTION_EVENT_ACTION_DOWN, 0, 0, edgeFlags, metaState, 0, classification,
chaviw9eaa22c2020-07-01 16:21:27 -0700630 identityTransform, 0, 0, AMOTION_EVENT_INVALID_CURSOR_POSITION,
Evan Rosky84f07f02021-04-16 10:42:42 -0700631 AMOTION_EVENT_INVALID_CURSOR_POSITION, AMOTION_EVENT_INVALID_DISPLAY_SIZE,
632 AMOTION_EVENT_INVALID_DISPLAY_SIZE, ARBITRARY_TIME, ARBITRARY_TIME,
Garfield Tan00f511d2019-06-12 16:55:40 -0700633 /*pointerCount*/ 1, pointerProperties, pointerCoords);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800634 ASSERT_EQ(InputEventInjectionResult::FAILED,
Siarhei Vishniakou097c3db2020-05-06 14:18:38 -0700635 mDispatcher->injectInputEvent(&event, INJECTOR_PID, INJECTOR_UID,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800636 InputEventInjectionSync::NONE, 0ms, 0))
Michael Wrightd02c5b62014-02-10 15:10:22 -0800637 << "Should reject motion events with pointer ids greater than MAX_POINTER_ID.";
638
639 // Rejects motion events with duplicate pointer ids.
640 pointerProperties[0].id = 1;
641 pointerProperties[1].id = 1;
Garfield Tanfbe732e2020-01-24 11:26:14 -0800642 event.initialize(InputEvent::nextId(), DEVICE_ID, source, DISPLAY_ID, INVALID_HMAC,
643 AMOTION_EVENT_ACTION_DOWN, 0, 0, edgeFlags, metaState, 0, classification,
chaviw9eaa22c2020-07-01 16:21:27 -0700644 identityTransform, 0, 0, AMOTION_EVENT_INVALID_CURSOR_POSITION,
Evan Rosky84f07f02021-04-16 10:42:42 -0700645 AMOTION_EVENT_INVALID_CURSOR_POSITION, AMOTION_EVENT_INVALID_DISPLAY_SIZE,
646 AMOTION_EVENT_INVALID_DISPLAY_SIZE, ARBITRARY_TIME, ARBITRARY_TIME,
Garfield Tan00f511d2019-06-12 16:55:40 -0700647 /*pointerCount*/ 2, pointerProperties, pointerCoords);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800648 ASSERT_EQ(InputEventInjectionResult::FAILED,
Siarhei Vishniakou097c3db2020-05-06 14:18:38 -0700649 mDispatcher->injectInputEvent(&event, INJECTOR_PID, INJECTOR_UID,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800650 InputEventInjectionSync::NONE, 0ms, 0))
Michael Wrightd02c5b62014-02-10 15:10:22 -0800651 << "Should reject motion events with duplicate pointer ids.";
652}
653
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -0800654/* Test InputDispatcher for notifyConfigurationChanged and notifySwitch events */
655
656TEST_F(InputDispatcherTest, NotifyConfigurationChanged_CallsPolicy) {
657 constexpr nsecs_t eventTime = 20;
Garfield Tanc51d1ba2020-01-28 13:24:04 -0800658 NotifyConfigurationChangedArgs args(10 /*id*/, eventTime);
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -0800659 mDispatcher->notifyConfigurationChanged(&args);
660 ASSERT_TRUE(mDispatcher->waitForIdle());
661
662 mFakePolicy->assertNotifyConfigurationChangedWasCalled(eventTime);
663}
664
665TEST_F(InputDispatcherTest, NotifySwitch_CallsPolicy) {
Garfield Tanc51d1ba2020-01-28 13:24:04 -0800666 NotifySwitchArgs args(10 /*id*/, 20 /*eventTime*/, 0 /*policyFlags*/, 1 /*switchValues*/,
667 2 /*switchMask*/);
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -0800668 mDispatcher->notifySwitch(&args);
669
670 // InputDispatcher adds POLICY_FLAG_TRUSTED because the event went through InputListener
671 args.policyFlags |= POLICY_FLAG_TRUSTED;
672 mFakePolicy->assertNotifySwitchWasCalled(args);
673}
674
Arthur Hungb92218b2018-08-14 12:00:21 +0800675// --- InputDispatcherTest SetInputWindowTest ---
Siarhei Vishniakou097c3db2020-05-06 14:18:38 -0700676static constexpr std::chrono::duration INJECT_EVENT_TIMEOUT = 500ms;
Siarhei Vishniakoucd899e82020-05-08 09:24:29 -0700677static constexpr std::chrono::nanoseconds DISPATCHING_TIMEOUT = 5s;
Arthur Hungb92218b2018-08-14 12:00:21 +0800678
679class FakeApplicationHandle : public InputApplicationHandle {
680public:
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -0700681 FakeApplicationHandle() {
682 mInfo.name = "Fake Application";
683 mInfo.token = new BBinder();
Siarhei Vishniakou70622952020-07-30 11:17:23 -0500684 mInfo.dispatchingTimeoutMillis =
685 std::chrono::duration_cast<std::chrono::milliseconds>(DISPATCHING_TIMEOUT).count();
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -0700686 }
Arthur Hungb92218b2018-08-14 12:00:21 +0800687 virtual ~FakeApplicationHandle() {}
688
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -1000689 virtual bool updateInfo() override { return true; }
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -0700690
Siarhei Vishniakou70622952020-07-30 11:17:23 -0500691 void setDispatchingTimeout(std::chrono::milliseconds timeout) {
692 mInfo.dispatchingTimeoutMillis = timeout.count();
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -0700693 }
Arthur Hungb92218b2018-08-14 12:00:21 +0800694};
695
Arthur Hung2fbf37f2018-09-13 18:16:41 +0800696class FakeInputReceiver {
Arthur Hungb92218b2018-08-14 12:00:21 +0800697public:
Garfield Tan15601662020-09-22 15:32:38 -0700698 explicit FakeInputReceiver(std::unique_ptr<InputChannel> clientChannel, const std::string name)
chaviwd1c23182019-12-20 18:44:56 -0800699 : mName(name) {
Garfield Tan15601662020-09-22 15:32:38 -0700700 mConsumer = std::make_unique<InputConsumer>(std::move(clientChannel));
chaviwd1c23182019-12-20 18:44:56 -0800701 }
702
Siarhei Vishniakou08b574f2019-11-15 18:05:52 -0800703 InputEvent* consume() {
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -0700704 InputEvent* event;
705 std::optional<uint32_t> consumeSeq = receiveEvent(&event);
706 if (!consumeSeq) {
707 return nullptr;
708 }
709 finishEvent(*consumeSeq);
710 return event;
711 }
712
713 /**
714 * Receive an event without acknowledging it.
715 * Return the sequence number that could later be used to send finished signal.
716 */
717 std::optional<uint32_t> receiveEvent(InputEvent** outEvent = nullptr) {
Arthur Hungb92218b2018-08-14 12:00:21 +0800718 uint32_t consumeSeq;
719 InputEvent* event;
Arthur Hungb92218b2018-08-14 12:00:21 +0800720
Siarhei Vishniakou08b574f2019-11-15 18:05:52 -0800721 std::chrono::time_point start = std::chrono::steady_clock::now();
722 status_t status = WOULD_BLOCK;
723 while (status == WOULD_BLOCK) {
chaviw81e2bb92019-12-18 15:03:51 -0800724 status = mConsumer->consume(&mEventFactory, true /*consumeBatches*/, -1, &consumeSeq,
Siarhei Vishniakou08b574f2019-11-15 18:05:52 -0800725 &event);
726 std::chrono::duration elapsed = std::chrono::steady_clock::now() - start;
727 if (elapsed > 100ms) {
728 break;
729 }
730 }
731
732 if (status == WOULD_BLOCK) {
733 // Just means there's no event available.
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -0700734 return std::nullopt;
Siarhei Vishniakou08b574f2019-11-15 18:05:52 -0800735 }
736
737 if (status != OK) {
738 ADD_FAILURE() << mName.c_str() << ": consumer consume should return OK.";
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -0700739 return std::nullopt;
Siarhei Vishniakou08b574f2019-11-15 18:05:52 -0800740 }
741 if (event == nullptr) {
742 ADD_FAILURE() << "Consumed correctly, but received NULL event from consumer";
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -0700743 return std::nullopt;
Siarhei Vishniakou08b574f2019-11-15 18:05:52 -0800744 }
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -0700745 if (outEvent != nullptr) {
746 *outEvent = event;
747 }
748 return consumeSeq;
749 }
Siarhei Vishniakou08b574f2019-11-15 18:05:52 -0800750
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -0700751 /**
752 * To be used together with "receiveEvent" to complete the consumption of an event.
753 */
754 void finishEvent(uint32_t consumeSeq) {
755 const status_t status = mConsumer->sendFinishedSignal(consumeSeq, true);
756 ASSERT_EQ(OK, status) << mName.c_str() << ": consumer sendFinishedSignal should return OK.";
Siarhei Vishniakou08b574f2019-11-15 18:05:52 -0800757 }
758
Siarhei Vishniakouf94ae022021-02-04 01:23:17 +0000759 void sendTimeline(int32_t inputEventId, std::array<nsecs_t, GraphicsTimeline::SIZE> timeline) {
760 const status_t status = mConsumer->sendTimeline(inputEventId, timeline);
761 ASSERT_EQ(OK, status);
762 }
763
Bernardo Rufinoc3b7b8c2021-01-29 17:38:07 +0000764 void consumeEvent(int32_t expectedEventType, int32_t expectedAction,
765 std::optional<int32_t> expectedDisplayId,
766 std::optional<int32_t> expectedFlags) {
Siarhei Vishniakou08b574f2019-11-15 18:05:52 -0800767 InputEvent* event = consume();
768
769 ASSERT_NE(nullptr, event) << mName.c_str()
770 << ": consumer should have returned non-NULL event.";
Arthur Hungb92218b2018-08-14 12:00:21 +0800771 ASSERT_EQ(expectedEventType, event->getType())
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700772 << mName.c_str() << " expected " << inputEventTypeToString(expectedEventType)
Siarhei Vishniakou7feb2ea2019-11-25 15:11:23 -0800773 << " event, got " << inputEventTypeToString(event->getType()) << " event";
Arthur Hungb92218b2018-08-14 12:00:21 +0800774
Bernardo Rufinoc3b7b8c2021-01-29 17:38:07 +0000775 if (expectedDisplayId.has_value()) {
776 EXPECT_EQ(expectedDisplayId, event->getDisplayId());
777 }
Tiger Huang8664f8c2018-10-11 19:14:35 +0800778
Tiger Huang8664f8c2018-10-11 19:14:35 +0800779 switch (expectedEventType) {
780 case AINPUT_EVENT_TYPE_KEY: {
Siarhei Vishniakouc5ca85c2019-11-15 17:20:00 -0800781 const KeyEvent& keyEvent = static_cast<const KeyEvent&>(*event);
782 EXPECT_EQ(expectedAction, keyEvent.getAction());
Bernardo Rufinoc3b7b8c2021-01-29 17:38:07 +0000783 if (expectedFlags.has_value()) {
784 EXPECT_EQ(expectedFlags.value(), keyEvent.getFlags());
785 }
Tiger Huang8664f8c2018-10-11 19:14:35 +0800786 break;
787 }
788 case AINPUT_EVENT_TYPE_MOTION: {
Siarhei Vishniakouc5ca85c2019-11-15 17:20:00 -0800789 const MotionEvent& motionEvent = static_cast<const MotionEvent&>(*event);
790 EXPECT_EQ(expectedAction, motionEvent.getAction());
Bernardo Rufinoc3b7b8c2021-01-29 17:38:07 +0000791 if (expectedFlags.has_value()) {
792 EXPECT_EQ(expectedFlags.value(), motionEvent.getFlags());
793 }
Tiger Huang8664f8c2018-10-11 19:14:35 +0800794 break;
795 }
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +0100796 case AINPUT_EVENT_TYPE_FOCUS: {
797 FAIL() << "Use 'consumeFocusEvent' for FOCUS events";
798 }
Prabir Pradhan99987712020-11-10 18:43:05 -0800799 case AINPUT_EVENT_TYPE_CAPTURE: {
800 FAIL() << "Use 'consumeCaptureEvent' for CAPTURE events";
801 }
arthurhungb89ccb02020-12-30 16:19:01 +0800802 case AINPUT_EVENT_TYPE_DRAG: {
803 FAIL() << "Use 'consumeDragEvent' for DRAG events";
804 }
Tiger Huang8664f8c2018-10-11 19:14:35 +0800805 default: {
806 FAIL() << mName.c_str() << ": invalid event type: " << expectedEventType;
807 }
808 }
Arthur Hungb92218b2018-08-14 12:00:21 +0800809 }
810
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +0100811 void consumeFocusEvent(bool hasFocus, bool inTouchMode) {
812 InputEvent* event = consume();
813 ASSERT_NE(nullptr, event) << mName.c_str()
814 << ": consumer should have returned non-NULL event.";
815 ASSERT_EQ(AINPUT_EVENT_TYPE_FOCUS, event->getType())
816 << "Got " << inputEventTypeToString(event->getType())
817 << " event instead of FOCUS event";
818
819 ASSERT_EQ(ADISPLAY_ID_NONE, event->getDisplayId())
820 << mName.c_str() << ": event displayId should always be NONE.";
821
822 FocusEvent* focusEvent = static_cast<FocusEvent*>(event);
823 EXPECT_EQ(hasFocus, focusEvent->getHasFocus());
824 EXPECT_EQ(inTouchMode, focusEvent->getInTouchMode());
825 }
826
Prabir Pradhan99987712020-11-10 18:43:05 -0800827 void consumeCaptureEvent(bool hasCapture) {
828 const InputEvent* event = consume();
829 ASSERT_NE(nullptr, event) << mName.c_str()
830 << ": consumer should have returned non-NULL event.";
831 ASSERT_EQ(AINPUT_EVENT_TYPE_CAPTURE, event->getType())
832 << "Got " << inputEventTypeToString(event->getType())
833 << " event instead of CAPTURE event";
834
835 ASSERT_EQ(ADISPLAY_ID_NONE, event->getDisplayId())
836 << mName.c_str() << ": event displayId should always be NONE.";
837
838 const auto& captureEvent = static_cast<const CaptureEvent&>(*event);
839 EXPECT_EQ(hasCapture, captureEvent.getPointerCaptureEnabled());
840 }
841
arthurhungb89ccb02020-12-30 16:19:01 +0800842 void consumeDragEvent(bool isExiting, float x, float y) {
843 const InputEvent* event = consume();
844 ASSERT_NE(nullptr, event) << mName.c_str()
845 << ": consumer should have returned non-NULL event.";
846 ASSERT_EQ(AINPUT_EVENT_TYPE_DRAG, event->getType())
847 << "Got " << inputEventTypeToString(event->getType())
848 << " event instead of DRAG event";
849
850 EXPECT_EQ(ADISPLAY_ID_NONE, event->getDisplayId())
851 << mName.c_str() << ": event displayId should always be NONE.";
852
853 const auto& dragEvent = static_cast<const DragEvent&>(*event);
854 EXPECT_EQ(isExiting, dragEvent.isExiting());
855 EXPECT_EQ(x, dragEvent.getX());
856 EXPECT_EQ(y, dragEvent.getY());
857 }
858
chaviwd1c23182019-12-20 18:44:56 -0800859 void assertNoEvents() {
860 InputEvent* event = consume();
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700861 if (event == nullptr) {
862 return;
863 }
864 if (event->getType() == AINPUT_EVENT_TYPE_KEY) {
865 KeyEvent& keyEvent = static_cast<KeyEvent&>(*event);
866 ADD_FAILURE() << "Received key event "
867 << KeyEvent::actionToString(keyEvent.getAction());
868 } else if (event->getType() == AINPUT_EVENT_TYPE_MOTION) {
869 MotionEvent& motionEvent = static_cast<MotionEvent&>(*event);
870 ADD_FAILURE() << "Received motion event "
871 << MotionEvent::actionToString(motionEvent.getAction());
872 } else if (event->getType() == AINPUT_EVENT_TYPE_FOCUS) {
873 FocusEvent& focusEvent = static_cast<FocusEvent&>(*event);
874 ADD_FAILURE() << "Received focus event, hasFocus = "
875 << (focusEvent.getHasFocus() ? "true" : "false");
Prabir Pradhan99987712020-11-10 18:43:05 -0800876 } else if (event->getType() == AINPUT_EVENT_TYPE_CAPTURE) {
877 const auto& captureEvent = static_cast<CaptureEvent&>(*event);
878 ADD_FAILURE() << "Received capture event, pointerCaptureEnabled = "
879 << (captureEvent.getPointerCaptureEnabled() ? "true" : "false");
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700880 }
881 FAIL() << mName.c_str()
882 << ": should not have received any events, so consume() should return NULL";
chaviwd1c23182019-12-20 18:44:56 -0800883 }
884
885 sp<IBinder> getToken() { return mConsumer->getChannel()->getConnectionToken(); }
886
887protected:
888 std::unique_ptr<InputConsumer> mConsumer;
889 PreallocatedInputEventFactory mEventFactory;
890
891 std::string mName;
892};
893
894class FakeWindowHandle : public InputWindowHandle {
895public:
896 static const int32_t WIDTH = 600;
897 static const int32_t HEIGHT = 800;
chaviwd1c23182019-12-20 18:44:56 -0800898
Chris Yea209fde2020-07-22 13:54:51 -0700899 FakeWindowHandle(const std::shared_ptr<InputApplicationHandle>& inputApplicationHandle,
chaviwd1c23182019-12-20 18:44:56 -0800900 const sp<InputDispatcher>& dispatcher, const std::string name,
Siarhei Vishniakoua2862a02020-07-20 16:36:46 -0500901 int32_t displayId, std::optional<sp<IBinder>> token = std::nullopt)
chaviwd1c23182019-12-20 18:44:56 -0800902 : mName(name) {
Siarhei Vishniakoua2862a02020-07-20 16:36:46 -0500903 if (token == std::nullopt) {
Garfield Tan15601662020-09-22 15:32:38 -0700904 base::Result<std::unique_ptr<InputChannel>> channel =
905 dispatcher->createInputChannel(name);
906 token = (*channel)->getConnectionToken();
907 mInputReceiver = std::make_unique<FakeInputReceiver>(std::move(*channel), name);
chaviwd1c23182019-12-20 18:44:56 -0800908 }
909
910 inputApplicationHandle->updateInfo();
911 mInfo.applicationInfo = *inputApplicationHandle->getInfo();
912
Siarhei Vishniakoua2862a02020-07-20 16:36:46 -0500913 mInfo.token = *token;
Siarhei Vishniakou540dbae2020-05-05 18:17:17 -0700914 mInfo.id = sId++;
chaviwd1c23182019-12-20 18:44:56 -0800915 mInfo.name = name;
Michael Wright44753b12020-07-08 13:48:11 +0100916 mInfo.type = InputWindowInfo::Type::APPLICATION;
Siarhei Vishniakouc1ae5562020-06-30 14:22:57 -0500917 mInfo.dispatchingTimeout = DISPATCHING_TIMEOUT;
Bernardo Rufinoc3b7b8c2021-01-29 17:38:07 +0000918 mInfo.alpha = 1.0;
chaviwd1c23182019-12-20 18:44:56 -0800919 mInfo.frameLeft = 0;
920 mInfo.frameTop = 0;
921 mInfo.frameRight = WIDTH;
922 mInfo.frameBottom = HEIGHT;
chaviw1ff3d1e2020-07-01 15:53:47 -0700923 mInfo.transform.set(0, 0);
chaviwd1c23182019-12-20 18:44:56 -0800924 mInfo.globalScaleFactor = 1.0;
925 mInfo.touchableRegion.clear();
926 mInfo.addTouchableRegion(Rect(0, 0, WIDTH, HEIGHT));
927 mInfo.visible = true;
Vishnu Nair47074b82020-08-14 11:54:47 -0700928 mInfo.focusable = false;
chaviwd1c23182019-12-20 18:44:56 -0800929 mInfo.hasWallpaper = false;
930 mInfo.paused = false;
chaviwd1c23182019-12-20 18:44:56 -0800931 mInfo.ownerPid = INJECTOR_PID;
932 mInfo.ownerUid = INJECTOR_UID;
chaviwd1c23182019-12-20 18:44:56 -0800933 mInfo.displayId = displayId;
934 }
935
936 virtual bool updateInfo() { return true; }
937
Vishnu Nair47074b82020-08-14 11:54:47 -0700938 void setFocusable(bool focusable) { mInfo.focusable = focusable; }
chaviwd1c23182019-12-20 18:44:56 -0800939
Vishnu Nair958da932020-08-21 17:12:37 -0700940 void setVisible(bool visible) { mInfo.visible = visible; }
941
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -0700942 void setDispatchingTimeout(std::chrono::nanoseconds timeout) {
Siarhei Vishniakouc1ae5562020-06-30 14:22:57 -0500943 mInfo.dispatchingTimeout = timeout;
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -0700944 }
945
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700946 void setPaused(bool paused) { mInfo.paused = paused; }
947
Bernardo Rufinoc3b7b8c2021-01-29 17:38:07 +0000948 void setAlpha(float alpha) { mInfo.alpha = alpha; }
949
950 void setTouchOcclusionMode(android::os::TouchOcclusionMode mode) {
951 mInfo.touchOcclusionMode = mode;
952 }
953
Bernardo Rufino7393d172021-02-26 13:56:11 +0000954 void setApplicationToken(sp<IBinder> token) { mInfo.applicationInfo.token = token; }
955
chaviwd1c23182019-12-20 18:44:56 -0800956 void setFrame(const Rect& frame) {
957 mInfo.frameLeft = frame.left;
958 mInfo.frameTop = frame.top;
959 mInfo.frameRight = frame.right;
960 mInfo.frameBottom = frame.bottom;
arthurhungb89ccb02020-12-30 16:19:01 +0800961 mInfo.transform.set(-frame.left, -frame.top);
chaviwd1c23182019-12-20 18:44:56 -0800962 mInfo.touchableRegion.clear();
963 mInfo.addTouchableRegion(frame);
964 }
965
Bernardo Rufinoa43a5a42021-02-17 12:21:14 +0000966 void addFlags(Flags<InputWindowInfo::Flag> flags) { mInfo.flags |= flags; }
967
Michael Wright44753b12020-07-08 13:48:11 +0100968 void setFlags(Flags<InputWindowInfo::Flag> flags) { mInfo.flags = flags; }
chaviwd1c23182019-12-20 18:44:56 -0800969
Siarhei Vishniakoua2862a02020-07-20 16:36:46 -0500970 void setInputFeatures(InputWindowInfo::Feature features) { mInfo.inputFeatures = features; }
971
chaviw9eaa22c2020-07-01 16:21:27 -0700972 void setWindowTransform(float dsdx, float dtdx, float dtdy, float dsdy) {
973 mInfo.transform.set(dsdx, dtdx, dtdy, dsdy);
974 }
975
976 void setWindowScale(float xScale, float yScale) { setWindowTransform(xScale, 0, 0, yScale); }
chaviwaf87b3e2019-10-01 16:59:28 -0700977
yunho.shinf4a80b82020-11-16 21:13:57 +0900978 void setWindowOffset(float offsetX, float offsetY) { mInfo.transform.set(offsetX, offsetY); }
979
Siarhei Vishniakouc5ca85c2019-11-15 17:20:00 -0800980 void consumeKeyDown(int32_t expectedDisplayId, int32_t expectedFlags = 0) {
981 consumeEvent(AINPUT_EVENT_TYPE_KEY, AKEY_EVENT_ACTION_DOWN, expectedDisplayId,
982 expectedFlags);
983 }
984
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -0700985 void consumeKeyUp(int32_t expectedDisplayId, int32_t expectedFlags = 0) {
986 consumeEvent(AINPUT_EVENT_TYPE_KEY, AKEY_EVENT_ACTION_UP, expectedDisplayId, expectedFlags);
987 }
988
Svet Ganov5d3bc372020-01-26 23:11:07 -0800989 void consumeMotionCancel(int32_t expectedDisplayId = ADISPLAY_ID_DEFAULT,
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -1000990 int32_t expectedFlags = 0) {
Svet Ganov5d3bc372020-01-26 23:11:07 -0800991 consumeEvent(AINPUT_EVENT_TYPE_MOTION, AMOTION_EVENT_ACTION_CANCEL, expectedDisplayId,
992 expectedFlags);
993 }
994
995 void consumeMotionMove(int32_t expectedDisplayId = ADISPLAY_ID_DEFAULT,
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -1000996 int32_t expectedFlags = 0) {
Svet Ganov5d3bc372020-01-26 23:11:07 -0800997 consumeEvent(AINPUT_EVENT_TYPE_MOTION, AMOTION_EVENT_ACTION_MOVE, expectedDisplayId,
998 expectedFlags);
999 }
1000
1001 void consumeMotionDown(int32_t expectedDisplayId = ADISPLAY_ID_DEFAULT,
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -10001002 int32_t expectedFlags = 0) {
Bernardo Rufinoc3b7b8c2021-01-29 17:38:07 +00001003 consumeAnyMotionDown(expectedDisplayId, expectedFlags);
1004 }
1005
1006 void consumeAnyMotionDown(std::optional<int32_t> expectedDisplayId = std::nullopt,
1007 std::optional<int32_t> expectedFlags = std::nullopt) {
Siarhei Vishniakouc5ca85c2019-11-15 17:20:00 -08001008 consumeEvent(AINPUT_EVENT_TYPE_MOTION, AMOTION_EVENT_ACTION_DOWN, expectedDisplayId,
1009 expectedFlags);
1010 }
1011
Svet Ganov5d3bc372020-01-26 23:11:07 -08001012 void consumeMotionPointerDown(int32_t pointerIdx,
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -10001013 int32_t expectedDisplayId = ADISPLAY_ID_DEFAULT,
1014 int32_t expectedFlags = 0) {
1015 int32_t action = AMOTION_EVENT_ACTION_POINTER_DOWN |
1016 (pointerIdx << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);
Svet Ganov5d3bc372020-01-26 23:11:07 -08001017 consumeEvent(AINPUT_EVENT_TYPE_MOTION, action, expectedDisplayId, expectedFlags);
1018 }
1019
1020 void consumeMotionPointerUp(int32_t pointerIdx, int32_t expectedDisplayId = ADISPLAY_ID_DEFAULT,
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -10001021 int32_t expectedFlags = 0) {
1022 int32_t action = AMOTION_EVENT_ACTION_POINTER_UP |
1023 (pointerIdx << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);
Svet Ganov5d3bc372020-01-26 23:11:07 -08001024 consumeEvent(AINPUT_EVENT_TYPE_MOTION, action, expectedDisplayId, expectedFlags);
1025 }
1026
1027 void consumeMotionUp(int32_t expectedDisplayId = ADISPLAY_ID_DEFAULT,
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -10001028 int32_t expectedFlags = 0) {
Michael Wright3a240c42019-12-10 20:53:41 +00001029 consumeEvent(AINPUT_EVENT_TYPE_MOTION, AMOTION_EVENT_ACTION_UP, expectedDisplayId,
1030 expectedFlags);
1031 }
1032
Siarhei Vishniakou234129c2020-10-22 22:28:12 -05001033 void consumeMotionOutside(int32_t expectedDisplayId = ADISPLAY_ID_DEFAULT,
1034 int32_t expectedFlags = 0) {
1035 consumeEvent(AINPUT_EVENT_TYPE_MOTION, AMOTION_EVENT_ACTION_OUTSIDE, expectedDisplayId,
1036 expectedFlags);
1037 }
1038
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001039 void consumeFocusEvent(bool hasFocus, bool inTouchMode = true) {
1040 ASSERT_NE(mInputReceiver, nullptr)
1041 << "Cannot consume events from a window with no receiver";
1042 mInputReceiver->consumeFocusEvent(hasFocus, inTouchMode);
1043 }
1044
Prabir Pradhan99987712020-11-10 18:43:05 -08001045 void consumeCaptureEvent(bool hasCapture) {
1046 ASSERT_NE(mInputReceiver, nullptr)
1047 << "Cannot consume events from a window with no receiver";
1048 mInputReceiver->consumeCaptureEvent(hasCapture);
1049 }
1050
Bernardo Rufinoc3b7b8c2021-01-29 17:38:07 +00001051 void consumeEvent(int32_t expectedEventType, int32_t expectedAction,
1052 std::optional<int32_t> expectedDisplayId,
1053 std::optional<int32_t> expectedFlags) {
chaviwd1c23182019-12-20 18:44:56 -08001054 ASSERT_NE(mInputReceiver, nullptr) << "Invalid consume event on window with no receiver";
1055 mInputReceiver->consumeEvent(expectedEventType, expectedAction, expectedDisplayId,
1056 expectedFlags);
1057 }
1058
arthurhungb89ccb02020-12-30 16:19:01 +08001059 void consumeDragEvent(bool isExiting, float x, float y) {
1060 mInputReceiver->consumeDragEvent(isExiting, x, y);
1061 }
1062
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001063 std::optional<uint32_t> receiveEvent(InputEvent** outEvent = nullptr) {
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07001064 if (mInputReceiver == nullptr) {
1065 ADD_FAILURE() << "Invalid receive event on window with no receiver";
1066 return std::nullopt;
1067 }
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001068 return mInputReceiver->receiveEvent(outEvent);
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07001069 }
1070
1071 void finishEvent(uint32_t sequenceNum) {
1072 ASSERT_NE(mInputReceiver, nullptr) << "Invalid receive event on window with no receiver";
1073 mInputReceiver->finishEvent(sequenceNum);
1074 }
1075
Siarhei Vishniakouf94ae022021-02-04 01:23:17 +00001076 void sendTimeline(int32_t inputEventId, std::array<nsecs_t, GraphicsTimeline::SIZE> timeline) {
1077 ASSERT_NE(mInputReceiver, nullptr) << "Invalid receive event on window with no receiver";
1078 mInputReceiver->sendTimeline(inputEventId, timeline);
1079 }
1080
chaviwaf87b3e2019-10-01 16:59:28 -07001081 InputEvent* consume() {
1082 if (mInputReceiver == nullptr) {
1083 return nullptr;
1084 }
1085 return mInputReceiver->consume();
1086 }
1087
Arthur Hungb92218b2018-08-14 12:00:21 +08001088 void assertNoEvents() {
Siarhei Vishniakoua2862a02020-07-20 16:36:46 -05001089 if (mInputReceiver == nullptr &&
1090 mInfo.inputFeatures.test(InputWindowInfo::Feature::NO_INPUT_CHANNEL)) {
1091 return; // Can't receive events if the window does not have input channel
1092 }
1093 ASSERT_NE(nullptr, mInputReceiver)
1094 << "Window without InputReceiver must specify feature NO_INPUT_CHANNEL";
chaviwd1c23182019-12-20 18:44:56 -08001095 mInputReceiver->assertNoEvents();
Arthur Hungb92218b2018-08-14 12:00:21 +08001096 }
1097
chaviwaf87b3e2019-10-01 16:59:28 -07001098 sp<IBinder> getToken() { return mInfo.token; }
1099
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001100 const std::string& getName() { return mName; }
1101
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -10001102 void setOwnerInfo(int32_t ownerPid, int32_t ownerUid) {
1103 mInfo.ownerPid = ownerPid;
1104 mInfo.ownerUid = ownerUid;
1105 }
1106
chaviwd1c23182019-12-20 18:44:56 -08001107private:
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001108 const std::string mName;
chaviwd1c23182019-12-20 18:44:56 -08001109 std::unique_ptr<FakeInputReceiver> mInputReceiver;
Siarhei Vishniakou540dbae2020-05-05 18:17:17 -07001110 static std::atomic<int32_t> sId; // each window gets a unique id, like in surfaceflinger
Arthur Hung2fbf37f2018-09-13 18:16:41 +08001111};
1112
Siarhei Vishniakou540dbae2020-05-05 18:17:17 -07001113std::atomic<int32_t> FakeWindowHandle::sId{1};
1114
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001115static InputEventInjectionResult injectKey(
1116 const sp<InputDispatcher>& dispatcher, int32_t action, int32_t repeatCount,
1117 int32_t displayId = ADISPLAY_ID_NONE,
1118 InputEventInjectionSync syncMode = InputEventInjectionSync::WAIT_FOR_RESULT,
Prabir Pradhan93f342c2021-03-11 15:05:30 -08001119 std::chrono::milliseconds injectionTimeout = INJECT_EVENT_TIMEOUT,
1120 bool allowKeyRepeat = true) {
Arthur Hungb92218b2018-08-14 12:00:21 +08001121 KeyEvent event;
1122 nsecs_t currentTime = systemTime(SYSTEM_TIME_MONOTONIC);
1123
1124 // Define a valid key down event.
Garfield Tanfbe732e2020-01-24 11:26:14 -08001125 event.initialize(InputEvent::nextId(), DEVICE_ID, AINPUT_SOURCE_KEYBOARD, displayId,
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07001126 INVALID_HMAC, action, /* flags */ 0, AKEYCODE_A, KEY_A, AMETA_NONE,
1127 repeatCount, currentTime, currentTime);
Arthur Hungb92218b2018-08-14 12:00:21 +08001128
Prabir Pradhan93f342c2021-03-11 15:05:30 -08001129 int32_t policyFlags = POLICY_FLAG_FILTERED | POLICY_FLAG_PASS_TO_USER;
1130 if (!allowKeyRepeat) {
1131 policyFlags |= POLICY_FLAG_DISABLE_KEY_REPEAT;
1132 }
Arthur Hungb92218b2018-08-14 12:00:21 +08001133 // Inject event until dispatch out.
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001134 return dispatcher->injectInputEvent(&event, INJECTOR_PID, INJECTOR_UID, syncMode,
Prabir Pradhan93f342c2021-03-11 15:05:30 -08001135 injectionTimeout, policyFlags);
Arthur Hungb92218b2018-08-14 12:00:21 +08001136}
1137
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001138static InputEventInjectionResult injectKeyDown(const sp<InputDispatcher>& dispatcher,
1139 int32_t displayId = ADISPLAY_ID_NONE) {
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07001140 return injectKey(dispatcher, AKEY_EVENT_ACTION_DOWN, /* repeatCount */ 0, displayId);
1141}
1142
Prabir Pradhan93f342c2021-03-11 15:05:30 -08001143// Inject a down event that has key repeat disabled. This allows InputDispatcher to idle without
1144// sending a subsequent key up. When key repeat is enabled, the dispatcher cannot idle because it
1145// has to be woken up to process the repeating key.
1146static InputEventInjectionResult injectKeyDownNoRepeat(const sp<InputDispatcher>& dispatcher,
1147 int32_t displayId = ADISPLAY_ID_NONE) {
1148 return injectKey(dispatcher, AKEY_EVENT_ACTION_DOWN, /* repeatCount */ 0, displayId,
1149 InputEventInjectionSync::WAIT_FOR_RESULT, INJECT_EVENT_TIMEOUT,
1150 /* allowKeyRepeat */ false);
1151}
1152
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001153static InputEventInjectionResult injectKeyUp(const sp<InputDispatcher>& dispatcher,
1154 int32_t displayId = ADISPLAY_ID_NONE) {
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001155 return injectKey(dispatcher, AKEY_EVENT_ACTION_UP, /* repeatCount */ 0, displayId);
1156}
1157
Garfield Tandf26e862020-07-01 20:18:19 -07001158class PointerBuilder {
1159public:
1160 PointerBuilder(int32_t id, int32_t toolType) {
1161 mProperties.clear();
1162 mProperties.id = id;
1163 mProperties.toolType = toolType;
1164 mCoords.clear();
1165 }
1166
1167 PointerBuilder& x(float x) { return axis(AMOTION_EVENT_AXIS_X, x); }
1168
1169 PointerBuilder& y(float y) { return axis(AMOTION_EVENT_AXIS_Y, y); }
1170
1171 PointerBuilder& axis(int32_t axis, float value) {
1172 mCoords.setAxisValue(axis, value);
1173 return *this;
1174 }
1175
1176 PointerProperties buildProperties() const { return mProperties; }
1177
1178 PointerCoords buildCoords() const { return mCoords; }
1179
1180private:
1181 PointerProperties mProperties;
1182 PointerCoords mCoords;
1183};
1184
1185class MotionEventBuilder {
1186public:
1187 MotionEventBuilder(int32_t action, int32_t source) {
1188 mAction = action;
1189 mSource = source;
1190 mEventTime = systemTime(SYSTEM_TIME_MONOTONIC);
1191 }
1192
1193 MotionEventBuilder& eventTime(nsecs_t eventTime) {
1194 mEventTime = eventTime;
1195 return *this;
1196 }
1197
1198 MotionEventBuilder& displayId(int32_t displayId) {
1199 mDisplayId = displayId;
1200 return *this;
1201 }
1202
1203 MotionEventBuilder& actionButton(int32_t actionButton) {
1204 mActionButton = actionButton;
1205 return *this;
1206 }
1207
arthurhung6d4bed92021-03-17 11:59:33 +08001208 MotionEventBuilder& buttonState(int32_t buttonState) {
1209 mButtonState = buttonState;
Garfield Tandf26e862020-07-01 20:18:19 -07001210 return *this;
1211 }
1212
1213 MotionEventBuilder& rawXCursorPosition(float rawXCursorPosition) {
1214 mRawXCursorPosition = rawXCursorPosition;
1215 return *this;
1216 }
1217
1218 MotionEventBuilder& rawYCursorPosition(float rawYCursorPosition) {
1219 mRawYCursorPosition = rawYCursorPosition;
1220 return *this;
1221 }
1222
1223 MotionEventBuilder& pointer(PointerBuilder pointer) {
1224 mPointers.push_back(pointer);
1225 return *this;
1226 }
1227
Prabir Pradhan47cf0a02021-03-11 20:30:57 -08001228 MotionEventBuilder& addFlag(uint32_t flags) {
1229 mFlags |= flags;
1230 return *this;
1231 }
1232
Garfield Tandf26e862020-07-01 20:18:19 -07001233 MotionEvent build() {
1234 std::vector<PointerProperties> pointerProperties;
1235 std::vector<PointerCoords> pointerCoords;
1236 for (const PointerBuilder& pointer : mPointers) {
1237 pointerProperties.push_back(pointer.buildProperties());
1238 pointerCoords.push_back(pointer.buildCoords());
1239 }
1240
1241 // Set mouse cursor position for the most common cases to avoid boilerplate.
1242 if (mSource == AINPUT_SOURCE_MOUSE &&
1243 !MotionEvent::isValidCursorPosition(mRawXCursorPosition, mRawYCursorPosition) &&
1244 mPointers.size() == 1) {
1245 mRawXCursorPosition = pointerCoords[0].getX();
1246 mRawYCursorPosition = pointerCoords[0].getY();
1247 }
1248
1249 MotionEvent event;
chaviw9eaa22c2020-07-01 16:21:27 -07001250 ui::Transform identityTransform;
Garfield Tandf26e862020-07-01 20:18:19 -07001251 event.initialize(InputEvent::nextId(), DEVICE_ID, mSource, mDisplayId, INVALID_HMAC,
Prabir Pradhan47cf0a02021-03-11 20:30:57 -08001252 mAction, mActionButton, mFlags, /* edgeFlags */ 0, AMETA_NONE,
chaviw9eaa22c2020-07-01 16:21:27 -07001253 mButtonState, MotionClassification::NONE, identityTransform,
1254 /* xPrecision */ 0, /* yPrecision */ 0, mRawXCursorPosition,
Evan Rosky84f07f02021-04-16 10:42:42 -07001255 mRawYCursorPosition, mDisplayWidth, mDisplayHeight, mEventTime, mEventTime,
1256 mPointers.size(), pointerProperties.data(), pointerCoords.data());
Garfield Tandf26e862020-07-01 20:18:19 -07001257
1258 return event;
1259 }
1260
1261private:
1262 int32_t mAction;
1263 int32_t mSource;
1264 nsecs_t mEventTime;
1265 int32_t mDisplayId{ADISPLAY_ID_DEFAULT};
1266 int32_t mActionButton{0};
1267 int32_t mButtonState{0};
Prabir Pradhan47cf0a02021-03-11 20:30:57 -08001268 int32_t mFlags{0};
Garfield Tandf26e862020-07-01 20:18:19 -07001269 float mRawXCursorPosition{AMOTION_EVENT_INVALID_CURSOR_POSITION};
1270 float mRawYCursorPosition{AMOTION_EVENT_INVALID_CURSOR_POSITION};
Evan Rosky84f07f02021-04-16 10:42:42 -07001271 int32_t mDisplayWidth{AMOTION_EVENT_INVALID_DISPLAY_SIZE};
1272 int32_t mDisplayHeight{AMOTION_EVENT_INVALID_DISPLAY_SIZE};
Garfield Tandf26e862020-07-01 20:18:19 -07001273
1274 std::vector<PointerBuilder> mPointers;
1275};
1276
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001277static InputEventInjectionResult injectMotionEvent(
Garfield Tandf26e862020-07-01 20:18:19 -07001278 const sp<InputDispatcher>& dispatcher, const MotionEvent& event,
1279 std::chrono::milliseconds injectionTimeout = INJECT_EVENT_TIMEOUT,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001280 InputEventInjectionSync injectionMode = InputEventInjectionSync::WAIT_FOR_RESULT) {
Garfield Tandf26e862020-07-01 20:18:19 -07001281 return dispatcher->injectInputEvent(&event, INJECTOR_PID, INJECTOR_UID, injectionMode,
1282 injectionTimeout,
1283 POLICY_FLAG_FILTERED | POLICY_FLAG_PASS_TO_USER);
1284}
1285
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001286static InputEventInjectionResult injectMotionEvent(
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07001287 const sp<InputDispatcher>& dispatcher, int32_t action, int32_t source, int32_t displayId,
1288 const PointF& position,
1289 const PointF& cursorPosition = {AMOTION_EVENT_INVALID_CURSOR_POSITION,
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001290 AMOTION_EVENT_INVALID_CURSOR_POSITION},
1291 std::chrono::milliseconds injectionTimeout = INJECT_EVENT_TIMEOUT,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001292 InputEventInjectionSync injectionMode = InputEventInjectionSync::WAIT_FOR_RESULT,
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07001293 nsecs_t eventTime = systemTime(SYSTEM_TIME_MONOTONIC)) {
Garfield Tandf26e862020-07-01 20:18:19 -07001294 MotionEvent event = MotionEventBuilder(action, source)
1295 .displayId(displayId)
1296 .eventTime(eventTime)
1297 .rawXCursorPosition(cursorPosition.x)
1298 .rawYCursorPosition(cursorPosition.y)
1299 .pointer(PointerBuilder(/* id */ 0, AMOTION_EVENT_TOOL_TYPE_FINGER)
1300 .x(position.x)
1301 .y(position.y))
1302 .build();
Arthur Hungb92218b2018-08-14 12:00:21 +08001303
1304 // Inject event until dispatch out.
Prabir Pradhan93f342c2021-03-11 15:05:30 -08001305 return injectMotionEvent(dispatcher, event, injectionTimeout, injectionMode);
Arthur Hungb92218b2018-08-14 12:00:21 +08001306}
1307
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001308static InputEventInjectionResult injectMotionDown(const sp<InputDispatcher>& dispatcher,
1309 int32_t source, int32_t displayId,
1310 const PointF& location = {100, 200}) {
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07001311 return injectMotionEvent(dispatcher, AMOTION_EVENT_ACTION_DOWN, source, displayId, location);
Garfield Tan00f511d2019-06-12 16:55:40 -07001312}
1313
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001314static InputEventInjectionResult injectMotionUp(const sp<InputDispatcher>& dispatcher,
1315 int32_t source, int32_t displayId,
1316 const PointF& location = {100, 200}) {
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07001317 return injectMotionEvent(dispatcher, AMOTION_EVENT_ACTION_UP, source, displayId, location);
Michael Wright3a240c42019-12-10 20:53:41 +00001318}
1319
Jackal Guof9696682018-10-05 12:23:23 +08001320static NotifyKeyArgs generateKeyArgs(int32_t action, int32_t displayId = ADISPLAY_ID_NONE) {
1321 nsecs_t currentTime = systemTime(SYSTEM_TIME_MONOTONIC);
1322 // Define a valid key event.
Siarhei Vishniakou58ba3d12021-02-11 01:31:07 +00001323 NotifyKeyArgs args(/* id */ 0, currentTime, 0 /*readTime*/, DEVICE_ID, AINPUT_SOURCE_KEYBOARD,
1324 displayId, POLICY_FLAG_PASS_TO_USER, action, /* flags */ 0, AKEYCODE_A,
1325 KEY_A, AMETA_NONE, currentTime);
Jackal Guof9696682018-10-05 12:23:23 +08001326
1327 return args;
1328}
1329
chaviwd1c23182019-12-20 18:44:56 -08001330static NotifyMotionArgs generateMotionArgs(int32_t action, int32_t source, int32_t displayId,
1331 const std::vector<PointF>& points) {
1332 size_t pointerCount = points.size();
chaviwaf87b3e2019-10-01 16:59:28 -07001333 if (action == AMOTION_EVENT_ACTION_DOWN || action == AMOTION_EVENT_ACTION_UP) {
1334 EXPECT_EQ(1U, pointerCount) << "Actions DOWN and UP can only contain a single pointer";
1335 }
1336
chaviwd1c23182019-12-20 18:44:56 -08001337 PointerProperties pointerProperties[pointerCount];
1338 PointerCoords pointerCoords[pointerCount];
Jackal Guof9696682018-10-05 12:23:23 +08001339
chaviwd1c23182019-12-20 18:44:56 -08001340 for (size_t i = 0; i < pointerCount; i++) {
1341 pointerProperties[i].clear();
1342 pointerProperties[i].id = i;
1343 pointerProperties[i].toolType = AMOTION_EVENT_TOOL_TYPE_FINGER;
Jackal Guof9696682018-10-05 12:23:23 +08001344
chaviwd1c23182019-12-20 18:44:56 -08001345 pointerCoords[i].clear();
1346 pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_X, points[i].x);
1347 pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_Y, points[i].y);
1348 }
Jackal Guof9696682018-10-05 12:23:23 +08001349
1350 nsecs_t currentTime = systemTime(SYSTEM_TIME_MONOTONIC);
1351 // Define a valid motion event.
Siarhei Vishniakou58ba3d12021-02-11 01:31:07 +00001352 NotifyMotionArgs args(/* id */ 0, currentTime, 0 /*readTime*/, DEVICE_ID, source, displayId,
Garfield Tan00f511d2019-06-12 16:55:40 -07001353 POLICY_FLAG_PASS_TO_USER, action, /* actionButton */ 0, /* flags */ 0,
1354 AMETA_NONE, /* buttonState */ 0, MotionClassification::NONE,
chaviwd1c23182019-12-20 18:44:56 -08001355 AMOTION_EVENT_EDGE_FLAG_NONE, pointerCount, pointerProperties,
1356 pointerCoords, /* xPrecision */ 0, /* yPrecision */ 0,
Garfield Tan00f511d2019-06-12 16:55:40 -07001357 AMOTION_EVENT_INVALID_CURSOR_POSITION,
1358 AMOTION_EVENT_INVALID_CURSOR_POSITION, currentTime, /* videoFrames */ {});
Jackal Guof9696682018-10-05 12:23:23 +08001359
1360 return args;
1361}
1362
chaviwd1c23182019-12-20 18:44:56 -08001363static NotifyMotionArgs generateMotionArgs(int32_t action, int32_t source, int32_t displayId) {
1364 return generateMotionArgs(action, source, displayId, {PointF{100, 200}});
1365}
1366
Prabir Pradhan99987712020-11-10 18:43:05 -08001367static NotifyPointerCaptureChangedArgs generatePointerCaptureChangedArgs(bool enabled) {
1368 return NotifyPointerCaptureChangedArgs(/* id */ 0, systemTime(SYSTEM_TIME_MONOTONIC), enabled);
1369}
1370
Arthur Hungb92218b2018-08-14 12:00:21 +08001371TEST_F(InputDispatcherTest, SetInputWindow_SingleWindowTouch) {
Chris Yea209fde2020-07-22 13:54:51 -07001372 std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -10001373 sp<FakeWindowHandle> window =
1374 new FakeWindowHandle(application, mDispatcher, "Fake Window", ADISPLAY_ID_DEFAULT);
Arthur Hungb92218b2018-08-14 12:00:21 +08001375
Arthur Hung72d8dc32020-03-28 00:48:39 +00001376 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {window}}});
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001377 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
1378 injectMotionDown(mDispatcher, AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT))
1379 << "Inject motion event should return InputEventInjectionResult::SUCCEEDED";
Arthur Hungb92218b2018-08-14 12:00:21 +08001380
1381 // Window should receive motion event.
Siarhei Vishniakouc5ca85c2019-11-15 17:20:00 -08001382 window->consumeMotionDown(ADISPLAY_ID_DEFAULT);
Arthur Hungb92218b2018-08-14 12:00:21 +08001383}
1384
Siarhei Vishniakoufb9fcda2020-05-04 14:59:19 -07001385/**
1386 * Calling setInputWindows once with FLAG_NOT_TOUCH_MODAL should not cause any issues.
1387 * To ensure that window receives only events that were directly inside of it, add
1388 * FLAG_NOT_TOUCH_MODAL. This will enforce using the touchableRegion of the input
1389 * when finding touched windows.
1390 * This test serves as a sanity check for the next test, where setInputWindows is
1391 * called twice.
1392 */
1393TEST_F(InputDispatcherTest, SetInputWindowOnce_SingleWindowTouch) {
Chris Yea209fde2020-07-22 13:54:51 -07001394 std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
Siarhei Vishniakoufb9fcda2020-05-04 14:59:19 -07001395 sp<FakeWindowHandle> window =
1396 new FakeWindowHandle(application, mDispatcher, "Fake Window", ADISPLAY_ID_DEFAULT);
1397 window->setFrame(Rect(0, 0, 100, 100));
Michael Wright44753b12020-07-08 13:48:11 +01001398 window->setFlags(InputWindowInfo::Flag::NOT_TOUCH_MODAL);
Siarhei Vishniakoufb9fcda2020-05-04 14:59:19 -07001399
1400 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {window}}});
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001401 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
Siarhei Vishniakoufb9fcda2020-05-04 14:59:19 -07001402 injectMotionDown(mDispatcher, AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT,
1403 {50, 50}))
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001404 << "Inject motion event should return InputEventInjectionResult::SUCCEEDED";
Siarhei Vishniakoufb9fcda2020-05-04 14:59:19 -07001405
1406 // Window should receive motion event.
1407 window->consumeMotionDown(ADISPLAY_ID_DEFAULT);
1408}
1409
1410/**
1411 * Calling setInputWindows twice, with the same info, should not cause any issues.
1412 * To ensure that window receives only events that were directly inside of it, add
1413 * FLAG_NOT_TOUCH_MODAL. This will enforce using the touchableRegion of the input
1414 * when finding touched windows.
1415 */
1416TEST_F(InputDispatcherTest, SetInputWindowTwice_SingleWindowTouch) {
Chris Yea209fde2020-07-22 13:54:51 -07001417 std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
Siarhei Vishniakoufb9fcda2020-05-04 14:59:19 -07001418 sp<FakeWindowHandle> window =
1419 new FakeWindowHandle(application, mDispatcher, "Fake Window", ADISPLAY_ID_DEFAULT);
1420 window->setFrame(Rect(0, 0, 100, 100));
Michael Wright44753b12020-07-08 13:48:11 +01001421 window->setFlags(InputWindowInfo::Flag::NOT_TOUCH_MODAL);
Siarhei Vishniakoufb9fcda2020-05-04 14:59:19 -07001422
1423 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {window}}});
1424 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {window}}});
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001425 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
Siarhei Vishniakoufb9fcda2020-05-04 14:59:19 -07001426 injectMotionDown(mDispatcher, AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT,
1427 {50, 50}))
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001428 << "Inject motion event should return InputEventInjectionResult::SUCCEEDED";
Siarhei Vishniakoufb9fcda2020-05-04 14:59:19 -07001429
1430 // Window should receive motion event.
1431 window->consumeMotionDown(ADISPLAY_ID_DEFAULT);
1432}
1433
Arthur Hungb92218b2018-08-14 12:00:21 +08001434// The foreground window should receive the first touch down event.
1435TEST_F(InputDispatcherTest, SetInputWindow_MultiWindowsTouch) {
Chris Yea209fde2020-07-22 13:54:51 -07001436 std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -10001437 sp<FakeWindowHandle> windowTop =
1438 new FakeWindowHandle(application, mDispatcher, "Top", ADISPLAY_ID_DEFAULT);
1439 sp<FakeWindowHandle> windowSecond =
1440 new FakeWindowHandle(application, mDispatcher, "Second", ADISPLAY_ID_DEFAULT);
Arthur Hungb92218b2018-08-14 12:00:21 +08001441
Arthur Hung72d8dc32020-03-28 00:48:39 +00001442 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {windowTop, windowSecond}}});
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001443 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
1444 injectMotionDown(mDispatcher, AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT))
1445 << "Inject motion event should return InputEventInjectionResult::SUCCEEDED";
Arthur Hungb92218b2018-08-14 12:00:21 +08001446
1447 // Top window should receive the touch down event. Second window should not receive anything.
Siarhei Vishniakouc5ca85c2019-11-15 17:20:00 -08001448 windowTop->consumeMotionDown(ADISPLAY_ID_DEFAULT);
Arthur Hungb92218b2018-08-14 12:00:21 +08001449 windowSecond->assertNoEvents();
1450}
1451
Garfield Tandf26e862020-07-01 20:18:19 -07001452TEST_F(InputDispatcherTest, HoverMoveEnterMouseClickAndHoverMoveExit) {
Chris Yea209fde2020-07-22 13:54:51 -07001453 std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
Garfield Tandf26e862020-07-01 20:18:19 -07001454 sp<FakeWindowHandle> windowLeft =
1455 new FakeWindowHandle(application, mDispatcher, "Left", ADISPLAY_ID_DEFAULT);
1456 windowLeft->setFrame(Rect(0, 0, 600, 800));
Michael Wright44753b12020-07-08 13:48:11 +01001457 windowLeft->setFlags(InputWindowInfo::Flag::NOT_TOUCH_MODAL);
Garfield Tandf26e862020-07-01 20:18:19 -07001458 sp<FakeWindowHandle> windowRight =
1459 new FakeWindowHandle(application, mDispatcher, "Right", ADISPLAY_ID_DEFAULT);
1460 windowRight->setFrame(Rect(600, 0, 1200, 800));
Michael Wright44753b12020-07-08 13:48:11 +01001461 windowRight->setFlags(InputWindowInfo::Flag::NOT_TOUCH_MODAL);
Garfield Tandf26e862020-07-01 20:18:19 -07001462
1463 mDispatcher->setFocusedApplication(ADISPLAY_ID_DEFAULT, application);
1464
1465 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {windowLeft, windowRight}}});
1466
1467 // Start cursor position in right window so that we can move the cursor to left window.
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001468 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
Garfield Tandf26e862020-07-01 20:18:19 -07001469 injectMotionEvent(mDispatcher,
1470 MotionEventBuilder(AMOTION_EVENT_ACTION_HOVER_MOVE,
1471 AINPUT_SOURCE_MOUSE)
1472 .pointer(PointerBuilder(0, AMOTION_EVENT_TOOL_TYPE_MOUSE)
1473 .x(900)
1474 .y(400))
1475 .build()));
1476 windowRight->consumeEvent(AINPUT_EVENT_TYPE_MOTION, AMOTION_EVENT_ACTION_HOVER_ENTER,
1477 ADISPLAY_ID_DEFAULT, 0 /* expectedFlag */);
1478 windowRight->consumeEvent(AINPUT_EVENT_TYPE_MOTION, AMOTION_EVENT_ACTION_HOVER_MOVE,
1479 ADISPLAY_ID_DEFAULT, 0 /* expectedFlag */);
1480
1481 // Move cursor into left window
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001482 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
Garfield Tandf26e862020-07-01 20:18:19 -07001483 injectMotionEvent(mDispatcher,
1484 MotionEventBuilder(AMOTION_EVENT_ACTION_HOVER_MOVE,
1485 AINPUT_SOURCE_MOUSE)
1486 .pointer(PointerBuilder(0, AMOTION_EVENT_TOOL_TYPE_MOUSE)
1487 .x(300)
1488 .y(400))
1489 .build()));
1490 windowRight->consumeEvent(AINPUT_EVENT_TYPE_MOTION, AMOTION_EVENT_ACTION_HOVER_EXIT,
1491 ADISPLAY_ID_DEFAULT, 0 /* expectedFlag */);
1492 windowLeft->consumeEvent(AINPUT_EVENT_TYPE_MOTION, AMOTION_EVENT_ACTION_HOVER_ENTER,
1493 ADISPLAY_ID_DEFAULT, 0 /* expectedFlag */);
1494 windowLeft->consumeEvent(AINPUT_EVENT_TYPE_MOTION, AMOTION_EVENT_ACTION_HOVER_MOVE,
1495 ADISPLAY_ID_DEFAULT, 0 /* expectedFlag */);
1496
1497 // Inject a series of mouse events for a mouse click
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001498 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
Garfield Tandf26e862020-07-01 20:18:19 -07001499 injectMotionEvent(mDispatcher,
1500 MotionEventBuilder(AMOTION_EVENT_ACTION_DOWN, AINPUT_SOURCE_MOUSE)
1501 .buttonState(AMOTION_EVENT_BUTTON_PRIMARY)
1502 .pointer(PointerBuilder(0, AMOTION_EVENT_TOOL_TYPE_MOUSE)
1503 .x(300)
1504 .y(400))
1505 .build()));
1506 windowLeft->consumeMotionDown(ADISPLAY_ID_DEFAULT);
1507
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001508 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
Garfield Tandf26e862020-07-01 20:18:19 -07001509 injectMotionEvent(mDispatcher,
1510 MotionEventBuilder(AMOTION_EVENT_ACTION_BUTTON_PRESS,
1511 AINPUT_SOURCE_MOUSE)
1512 .buttonState(AMOTION_EVENT_BUTTON_PRIMARY)
1513 .actionButton(AMOTION_EVENT_BUTTON_PRIMARY)
1514 .pointer(PointerBuilder(0, AMOTION_EVENT_TOOL_TYPE_MOUSE)
1515 .x(300)
1516 .y(400))
1517 .build()));
1518 windowLeft->consumeEvent(AINPUT_EVENT_TYPE_MOTION, AMOTION_EVENT_ACTION_BUTTON_PRESS,
1519 ADISPLAY_ID_DEFAULT, 0 /* expectedFlag */);
1520
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001521 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
Garfield Tandf26e862020-07-01 20:18:19 -07001522 injectMotionEvent(mDispatcher,
1523 MotionEventBuilder(AMOTION_EVENT_ACTION_BUTTON_RELEASE,
1524 AINPUT_SOURCE_MOUSE)
1525 .buttonState(0)
1526 .actionButton(AMOTION_EVENT_BUTTON_PRIMARY)
1527 .pointer(PointerBuilder(0, AMOTION_EVENT_TOOL_TYPE_MOUSE)
1528 .x(300)
1529 .y(400))
1530 .build()));
1531 windowLeft->consumeEvent(AINPUT_EVENT_TYPE_MOTION, AMOTION_EVENT_ACTION_BUTTON_RELEASE,
1532 ADISPLAY_ID_DEFAULT, 0 /* expectedFlag */);
1533
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001534 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
Garfield Tandf26e862020-07-01 20:18:19 -07001535 injectMotionEvent(mDispatcher,
1536 MotionEventBuilder(AMOTION_EVENT_ACTION_UP, AINPUT_SOURCE_MOUSE)
1537 .buttonState(0)
1538 .pointer(PointerBuilder(0, AMOTION_EVENT_TOOL_TYPE_MOUSE)
1539 .x(300)
1540 .y(400))
1541 .build()));
1542 windowLeft->consumeMotionUp(ADISPLAY_ID_DEFAULT);
1543
1544 // Move mouse cursor back to right window
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001545 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
Garfield Tandf26e862020-07-01 20:18:19 -07001546 injectMotionEvent(mDispatcher,
1547 MotionEventBuilder(AMOTION_EVENT_ACTION_HOVER_MOVE,
1548 AINPUT_SOURCE_MOUSE)
1549 .pointer(PointerBuilder(0, AMOTION_EVENT_TOOL_TYPE_MOUSE)
1550 .x(900)
1551 .y(400))
1552 .build()));
1553 windowLeft->consumeEvent(AINPUT_EVENT_TYPE_MOTION, AMOTION_EVENT_ACTION_HOVER_EXIT,
1554 ADISPLAY_ID_DEFAULT, 0 /* expectedFlag */);
1555 windowRight->consumeEvent(AINPUT_EVENT_TYPE_MOTION, AMOTION_EVENT_ACTION_HOVER_ENTER,
1556 ADISPLAY_ID_DEFAULT, 0 /* expectedFlag */);
1557 windowRight->consumeEvent(AINPUT_EVENT_TYPE_MOTION, AMOTION_EVENT_ACTION_HOVER_MOVE,
1558 ADISPLAY_ID_DEFAULT, 0 /* expectedFlag */);
1559}
1560
1561// This test is different from the test above that HOVER_ENTER and HOVER_EXIT events are injected
1562// directly in this test.
1563TEST_F(InputDispatcherTest, HoverEnterMouseClickAndHoverExit) {
Chris Yea209fde2020-07-22 13:54:51 -07001564 std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
Garfield Tandf26e862020-07-01 20:18:19 -07001565 sp<FakeWindowHandle> window =
1566 new FakeWindowHandle(application, mDispatcher, "Window", ADISPLAY_ID_DEFAULT);
1567 window->setFrame(Rect(0, 0, 1200, 800));
Michael Wright44753b12020-07-08 13:48:11 +01001568 window->setFlags(InputWindowInfo::Flag::NOT_TOUCH_MODAL);
Garfield Tandf26e862020-07-01 20:18:19 -07001569
1570 mDispatcher->setFocusedApplication(ADISPLAY_ID_DEFAULT, application);
1571
1572 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {window}}});
1573
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001574 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
Garfield Tandf26e862020-07-01 20:18:19 -07001575 injectMotionEvent(mDispatcher,
1576 MotionEventBuilder(AMOTION_EVENT_ACTION_HOVER_ENTER,
1577 AINPUT_SOURCE_MOUSE)
1578 .pointer(PointerBuilder(0, AMOTION_EVENT_TOOL_TYPE_MOUSE)
1579 .x(300)
1580 .y(400))
1581 .build()));
1582 window->consumeEvent(AINPUT_EVENT_TYPE_MOTION, AMOTION_EVENT_ACTION_HOVER_ENTER,
1583 ADISPLAY_ID_DEFAULT, 0 /* expectedFlag */);
1584
1585 // Inject a series of mouse events for a mouse click
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001586 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
Garfield Tandf26e862020-07-01 20:18:19 -07001587 injectMotionEvent(mDispatcher,
1588 MotionEventBuilder(AMOTION_EVENT_ACTION_DOWN, AINPUT_SOURCE_MOUSE)
1589 .buttonState(AMOTION_EVENT_BUTTON_PRIMARY)
1590 .pointer(PointerBuilder(0, AMOTION_EVENT_TOOL_TYPE_MOUSE)
1591 .x(300)
1592 .y(400))
1593 .build()));
1594 window->consumeMotionDown(ADISPLAY_ID_DEFAULT);
1595
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001596 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
Garfield Tandf26e862020-07-01 20:18:19 -07001597 injectMotionEvent(mDispatcher,
1598 MotionEventBuilder(AMOTION_EVENT_ACTION_BUTTON_PRESS,
1599 AINPUT_SOURCE_MOUSE)
1600 .buttonState(AMOTION_EVENT_BUTTON_PRIMARY)
1601 .actionButton(AMOTION_EVENT_BUTTON_PRIMARY)
1602 .pointer(PointerBuilder(0, AMOTION_EVENT_TOOL_TYPE_MOUSE)
1603 .x(300)
1604 .y(400))
1605 .build()));
1606 window->consumeEvent(AINPUT_EVENT_TYPE_MOTION, AMOTION_EVENT_ACTION_BUTTON_PRESS,
1607 ADISPLAY_ID_DEFAULT, 0 /* expectedFlag */);
1608
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001609 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
Garfield Tandf26e862020-07-01 20:18:19 -07001610 injectMotionEvent(mDispatcher,
1611 MotionEventBuilder(AMOTION_EVENT_ACTION_BUTTON_RELEASE,
1612 AINPUT_SOURCE_MOUSE)
1613 .buttonState(0)
1614 .actionButton(AMOTION_EVENT_BUTTON_PRIMARY)
1615 .pointer(PointerBuilder(0, AMOTION_EVENT_TOOL_TYPE_MOUSE)
1616 .x(300)
1617 .y(400))
1618 .build()));
1619 window->consumeEvent(AINPUT_EVENT_TYPE_MOTION, AMOTION_EVENT_ACTION_BUTTON_RELEASE,
1620 ADISPLAY_ID_DEFAULT, 0 /* expectedFlag */);
1621
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001622 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
Garfield Tandf26e862020-07-01 20:18:19 -07001623 injectMotionEvent(mDispatcher,
1624 MotionEventBuilder(AMOTION_EVENT_ACTION_UP, AINPUT_SOURCE_MOUSE)
1625 .buttonState(0)
1626 .pointer(PointerBuilder(0, AMOTION_EVENT_TOOL_TYPE_MOUSE)
1627 .x(300)
1628 .y(400))
1629 .build()));
1630 window->consumeMotionUp(ADISPLAY_ID_DEFAULT);
1631
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001632 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
Garfield Tandf26e862020-07-01 20:18:19 -07001633 injectMotionEvent(mDispatcher,
1634 MotionEventBuilder(AMOTION_EVENT_ACTION_HOVER_EXIT,
1635 AINPUT_SOURCE_MOUSE)
1636 .pointer(PointerBuilder(0, AMOTION_EVENT_TOOL_TYPE_MOUSE)
1637 .x(300)
1638 .y(400))
1639 .build()));
1640 window->consumeEvent(AINPUT_EVENT_TYPE_MOTION, AMOTION_EVENT_ACTION_HOVER_EXIT,
1641 ADISPLAY_ID_DEFAULT, 0 /* expectedFlag */);
1642}
1643
Garfield Tan00f511d2019-06-12 16:55:40 -07001644TEST_F(InputDispatcherTest, DispatchMouseEventsUnderCursor) {
Chris Yea209fde2020-07-22 13:54:51 -07001645 std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
Garfield Tan00f511d2019-06-12 16:55:40 -07001646
1647 sp<FakeWindowHandle> windowLeft =
1648 new FakeWindowHandle(application, mDispatcher, "Left", ADISPLAY_ID_DEFAULT);
1649 windowLeft->setFrame(Rect(0, 0, 600, 800));
Michael Wright44753b12020-07-08 13:48:11 +01001650 windowLeft->setFlags(InputWindowInfo::Flag::NOT_TOUCH_MODAL);
Garfield Tan00f511d2019-06-12 16:55:40 -07001651 sp<FakeWindowHandle> windowRight =
1652 new FakeWindowHandle(application, mDispatcher, "Right", ADISPLAY_ID_DEFAULT);
1653 windowRight->setFrame(Rect(600, 0, 1200, 800));
Michael Wright44753b12020-07-08 13:48:11 +01001654 windowRight->setFlags(InputWindowInfo::Flag::NOT_TOUCH_MODAL);
Garfield Tan00f511d2019-06-12 16:55:40 -07001655
1656 mDispatcher->setFocusedApplication(ADISPLAY_ID_DEFAULT, application);
1657
Arthur Hung72d8dc32020-03-28 00:48:39 +00001658 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {windowLeft, windowRight}}});
Garfield Tan00f511d2019-06-12 16:55:40 -07001659
1660 // Inject an event with coordinate in the area of right window, with mouse cursor in the area of
1661 // left window. This event should be dispatched to the left window.
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08001662 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
Garfield Tan00f511d2019-06-12 16:55:40 -07001663 injectMotionEvent(mDispatcher, AMOTION_EVENT_ACTION_DOWN, AINPUT_SOURCE_MOUSE,
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07001664 ADISPLAY_ID_DEFAULT, {610, 400}, {599, 400}));
Siarhei Vishniakouc5ca85c2019-11-15 17:20:00 -08001665 windowLeft->consumeMotionDown(ADISPLAY_ID_DEFAULT);
Garfield Tan00f511d2019-06-12 16:55:40 -07001666 windowRight->assertNoEvents();
1667}
1668
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -08001669TEST_F(InputDispatcherTest, NotifyDeviceReset_CancelsKeyStream) {
Chris Yea209fde2020-07-22 13:54:51 -07001670 std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -08001671 sp<FakeWindowHandle> window =
1672 new FakeWindowHandle(application, mDispatcher, "Fake Window", ADISPLAY_ID_DEFAULT);
Vishnu Nair47074b82020-08-14 11:54:47 -07001673 window->setFocusable(true);
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -08001674
Arthur Hung72d8dc32020-03-28 00:48:39 +00001675 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {window}}});
Vishnu Nair958da932020-08-21 17:12:37 -07001676 setFocusedWindow(window);
1677
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001678 window->consumeFocusEvent(true);
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -08001679
1680 NotifyKeyArgs keyArgs = generateKeyArgs(AKEY_EVENT_ACTION_DOWN, ADISPLAY_ID_DEFAULT);
1681 mDispatcher->notifyKey(&keyArgs);
1682
1683 // Window should receive key down event.
1684 window->consumeKeyDown(ADISPLAY_ID_DEFAULT);
1685
1686 // When device reset happens, that key stream should be terminated with FLAG_CANCELED
1687 // on the app side.
Garfield Tanc51d1ba2020-01-28 13:24:04 -08001688 NotifyDeviceResetArgs args(10 /*id*/, 20 /*eventTime*/, DEVICE_ID);
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -08001689 mDispatcher->notifyDeviceReset(&args);
1690 window->consumeEvent(AINPUT_EVENT_TYPE_KEY, AKEY_EVENT_ACTION_UP, ADISPLAY_ID_DEFAULT,
1691 AKEY_EVENT_FLAG_CANCELED);
1692}
1693
1694TEST_F(InputDispatcherTest, NotifyDeviceReset_CancelsMotionStream) {
Chris Yea209fde2020-07-22 13:54:51 -07001695 std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -08001696 sp<FakeWindowHandle> window =
1697 new FakeWindowHandle(application, mDispatcher, "Fake Window", ADISPLAY_ID_DEFAULT);
1698
Arthur Hung72d8dc32020-03-28 00:48:39 +00001699 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {window}}});
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -08001700
1701 NotifyMotionArgs motionArgs =
1702 generateMotionArgs(AMOTION_EVENT_ACTION_DOWN, AINPUT_SOURCE_TOUCHSCREEN,
1703 ADISPLAY_ID_DEFAULT);
1704 mDispatcher->notifyMotion(&motionArgs);
1705
1706 // Window should receive motion down event.
1707 window->consumeMotionDown(ADISPLAY_ID_DEFAULT);
1708
1709 // When device reset happens, that motion stream should be terminated with ACTION_CANCEL
1710 // on the app side.
Garfield Tanc51d1ba2020-01-28 13:24:04 -08001711 NotifyDeviceResetArgs args(10 /*id*/, 20 /*eventTime*/, DEVICE_ID);
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -08001712 mDispatcher->notifyDeviceReset(&args);
1713 window->consumeEvent(AINPUT_EVENT_TYPE_MOTION, AMOTION_EVENT_ACTION_CANCEL, ADISPLAY_ID_DEFAULT,
1714 0 /*expectedFlags*/);
1715}
1716
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +00001717using TransferFunction =
1718 std::function<bool(sp<InputDispatcher> dispatcher, sp<IBinder>, sp<IBinder>)>;
1719
1720class TransferTouchFixture : public InputDispatcherTest,
1721 public ::testing::WithParamInterface<TransferFunction> {};
1722
1723TEST_P(TransferTouchFixture, TransferTouch_OnePointer) {
Chris Yea209fde2020-07-22 13:54:51 -07001724 std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
Svet Ganov5d3bc372020-01-26 23:11:07 -08001725
1726 // Create a couple of windows
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -10001727 sp<FakeWindowHandle> firstWindow =
1728 new FakeWindowHandle(application, mDispatcher, "First Window", ADISPLAY_ID_DEFAULT);
1729 sp<FakeWindowHandle> secondWindow =
1730 new FakeWindowHandle(application, mDispatcher, "Second Window", ADISPLAY_ID_DEFAULT);
Svet Ganov5d3bc372020-01-26 23:11:07 -08001731
1732 // Add the windows to the dispatcher
Arthur Hung72d8dc32020-03-28 00:48:39 +00001733 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {firstWindow, secondWindow}}});
Svet Ganov5d3bc372020-01-26 23:11:07 -08001734
1735 // Send down to the first window
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -10001736 NotifyMotionArgs downMotionArgs =
1737 generateMotionArgs(AMOTION_EVENT_ACTION_DOWN, AINPUT_SOURCE_TOUCHSCREEN,
1738 ADISPLAY_ID_DEFAULT);
Svet Ganov5d3bc372020-01-26 23:11:07 -08001739 mDispatcher->notifyMotion(&downMotionArgs);
1740 // Only the first window should get the down event
1741 firstWindow->consumeMotionDown();
1742 secondWindow->assertNoEvents();
1743
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +00001744 // Transfer touch to the second window
1745 TransferFunction f = GetParam();
1746 const bool success = f(mDispatcher, firstWindow->getToken(), secondWindow->getToken());
1747 ASSERT_TRUE(success);
Svet Ganov5d3bc372020-01-26 23:11:07 -08001748 // The first window gets cancel and the second gets down
1749 firstWindow->consumeMotionCancel();
1750 secondWindow->consumeMotionDown();
1751
1752 // Send up event to the second window
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -10001753 NotifyMotionArgs upMotionArgs =
1754 generateMotionArgs(AMOTION_EVENT_ACTION_UP, AINPUT_SOURCE_TOUCHSCREEN,
1755 ADISPLAY_ID_DEFAULT);
Svet Ganov5d3bc372020-01-26 23:11:07 -08001756 mDispatcher->notifyMotion(&upMotionArgs);
1757 // The first window gets no events and the second gets up
1758 firstWindow->assertNoEvents();
1759 secondWindow->consumeMotionUp();
1760}
1761
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +00001762TEST_P(TransferTouchFixture, TransferTouch_TwoPointersNonSplitTouch) {
Chris Yea209fde2020-07-22 13:54:51 -07001763 std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
Svet Ganov5d3bc372020-01-26 23:11:07 -08001764
1765 PointF touchPoint = {10, 10};
1766
1767 // Create a couple of windows
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -10001768 sp<FakeWindowHandle> firstWindow =
1769 new FakeWindowHandle(application, mDispatcher, "First Window", ADISPLAY_ID_DEFAULT);
1770 sp<FakeWindowHandle> secondWindow =
1771 new FakeWindowHandle(application, mDispatcher, "Second Window", ADISPLAY_ID_DEFAULT);
Svet Ganov5d3bc372020-01-26 23:11:07 -08001772
1773 // Add the windows to the dispatcher
Arthur Hung72d8dc32020-03-28 00:48:39 +00001774 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {firstWindow, secondWindow}}});
Svet Ganov5d3bc372020-01-26 23:11:07 -08001775
1776 // Send down to the first window
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -10001777 NotifyMotionArgs downMotionArgs =
1778 generateMotionArgs(AMOTION_EVENT_ACTION_DOWN, AINPUT_SOURCE_TOUCHSCREEN,
1779 ADISPLAY_ID_DEFAULT, {touchPoint});
Svet Ganov5d3bc372020-01-26 23:11:07 -08001780 mDispatcher->notifyMotion(&downMotionArgs);
1781 // Only the first window should get the down event
1782 firstWindow->consumeMotionDown();
1783 secondWindow->assertNoEvents();
1784
1785 // Send pointer down to the first window
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -10001786 NotifyMotionArgs pointerDownMotionArgs =
1787 generateMotionArgs(AMOTION_EVENT_ACTION_POINTER_DOWN |
1788 (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
1789 AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT,
1790 {touchPoint, touchPoint});
Svet Ganov5d3bc372020-01-26 23:11:07 -08001791 mDispatcher->notifyMotion(&pointerDownMotionArgs);
1792 // Only the first window should get the pointer down event
1793 firstWindow->consumeMotionPointerDown(1);
1794 secondWindow->assertNoEvents();
1795
1796 // Transfer touch focus to the second window
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +00001797 TransferFunction f = GetParam();
1798 bool success = f(mDispatcher, firstWindow->getToken(), secondWindow->getToken());
1799 ASSERT_TRUE(success);
Svet Ganov5d3bc372020-01-26 23:11:07 -08001800 // The first window gets cancel and the second gets down and pointer down
1801 firstWindow->consumeMotionCancel();
1802 secondWindow->consumeMotionDown();
1803 secondWindow->consumeMotionPointerDown(1);
1804
1805 // Send pointer up to the second window
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -10001806 NotifyMotionArgs pointerUpMotionArgs =
1807 generateMotionArgs(AMOTION_EVENT_ACTION_POINTER_UP |
1808 (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
1809 AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT,
1810 {touchPoint, touchPoint});
Svet Ganov5d3bc372020-01-26 23:11:07 -08001811 mDispatcher->notifyMotion(&pointerUpMotionArgs);
1812 // The first window gets nothing and the second gets pointer up
1813 firstWindow->assertNoEvents();
1814 secondWindow->consumeMotionPointerUp(1);
1815
1816 // Send up event to the second window
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -10001817 NotifyMotionArgs upMotionArgs =
1818 generateMotionArgs(AMOTION_EVENT_ACTION_UP, AINPUT_SOURCE_TOUCHSCREEN,
1819 ADISPLAY_ID_DEFAULT);
Svet Ganov5d3bc372020-01-26 23:11:07 -08001820 mDispatcher->notifyMotion(&upMotionArgs);
1821 // The first window gets nothing and the second gets up
1822 firstWindow->assertNoEvents();
1823 secondWindow->consumeMotionUp();
1824}
1825
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +00001826// For the cases of single pointer touch and two pointers non-split touch, the api's
1827// 'transferTouch' and 'transferTouchFocus' are equivalent in behaviour. They only differ
1828// for the case where there are multiple pointers split across several windows.
1829INSTANTIATE_TEST_SUITE_P(TransferFunctionTests, TransferTouchFixture,
1830 ::testing::Values(
1831 [&](sp<InputDispatcher> dispatcher, sp<IBinder> /*ignored*/,
1832 sp<IBinder> destChannelToken) {
1833 return dispatcher->transferTouch(destChannelToken);
1834 },
1835 [&](sp<InputDispatcher> dispatcher, sp<IBinder> from,
1836 sp<IBinder> to) {
1837 return dispatcher->transferTouchFocus(from, to,
1838 false /*isDragAndDrop*/);
1839 }));
1840
Svet Ganov5d3bc372020-01-26 23:11:07 -08001841TEST_F(InputDispatcherTest, TransferTouchFocus_TwoPointersSplitTouch) {
Chris Yea209fde2020-07-22 13:54:51 -07001842 std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
Svet Ganov5d3bc372020-01-26 23:11:07 -08001843
1844 // Create a non touch modal window that supports split touch
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -10001845 sp<FakeWindowHandle> firstWindow =
1846 new FakeWindowHandle(application, mDispatcher, "First Window", ADISPLAY_ID_DEFAULT);
Svet Ganov5d3bc372020-01-26 23:11:07 -08001847 firstWindow->setFrame(Rect(0, 0, 600, 400));
Michael Wright44753b12020-07-08 13:48:11 +01001848 firstWindow->setFlags(InputWindowInfo::Flag::NOT_TOUCH_MODAL |
1849 InputWindowInfo::Flag::SPLIT_TOUCH);
Svet Ganov5d3bc372020-01-26 23:11:07 -08001850
1851 // Create a non touch modal window that supports split touch
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -10001852 sp<FakeWindowHandle> secondWindow =
1853 new FakeWindowHandle(application, mDispatcher, "Second Window", ADISPLAY_ID_DEFAULT);
Svet Ganov5d3bc372020-01-26 23:11:07 -08001854 secondWindow->setFrame(Rect(0, 400, 600, 800));
Michael Wright44753b12020-07-08 13:48:11 +01001855 secondWindow->setFlags(InputWindowInfo::Flag::NOT_TOUCH_MODAL |
1856 InputWindowInfo::Flag::SPLIT_TOUCH);
Svet Ganov5d3bc372020-01-26 23:11:07 -08001857
1858 // Add the windows to the dispatcher
Arthur Hung72d8dc32020-03-28 00:48:39 +00001859 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {firstWindow, secondWindow}}});
Svet Ganov5d3bc372020-01-26 23:11:07 -08001860
1861 PointF pointInFirst = {300, 200};
1862 PointF pointInSecond = {300, 600};
1863
1864 // Send down to the first window
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -10001865 NotifyMotionArgs firstDownMotionArgs =
1866 generateMotionArgs(AMOTION_EVENT_ACTION_DOWN, AINPUT_SOURCE_TOUCHSCREEN,
1867 ADISPLAY_ID_DEFAULT, {pointInFirst});
Svet Ganov5d3bc372020-01-26 23:11:07 -08001868 mDispatcher->notifyMotion(&firstDownMotionArgs);
1869 // Only the first window should get the down event
1870 firstWindow->consumeMotionDown();
1871 secondWindow->assertNoEvents();
1872
1873 // Send down to the second window
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -10001874 NotifyMotionArgs secondDownMotionArgs =
1875 generateMotionArgs(AMOTION_EVENT_ACTION_POINTER_DOWN |
1876 (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
1877 AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT,
1878 {pointInFirst, pointInSecond});
Svet Ganov5d3bc372020-01-26 23:11:07 -08001879 mDispatcher->notifyMotion(&secondDownMotionArgs);
1880 // The first window gets a move and the second a down
1881 firstWindow->consumeMotionMove();
1882 secondWindow->consumeMotionDown();
1883
1884 // Transfer touch focus to the second window
1885 mDispatcher->transferTouchFocus(firstWindow->getToken(), secondWindow->getToken());
1886 // The first window gets cancel and the new gets pointer down (it already saw down)
1887 firstWindow->consumeMotionCancel();
1888 secondWindow->consumeMotionPointerDown(1);
1889
1890 // Send pointer up to the second window
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -10001891 NotifyMotionArgs pointerUpMotionArgs =
1892 generateMotionArgs(AMOTION_EVENT_ACTION_POINTER_UP |
1893 (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
1894 AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT,
1895 {pointInFirst, pointInSecond});
Svet Ganov5d3bc372020-01-26 23:11:07 -08001896 mDispatcher->notifyMotion(&pointerUpMotionArgs);
1897 // The first window gets nothing and the second gets pointer up
1898 firstWindow->assertNoEvents();
1899 secondWindow->consumeMotionPointerUp(1);
1900
1901 // Send up event to the second window
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -10001902 NotifyMotionArgs upMotionArgs =
1903 generateMotionArgs(AMOTION_EVENT_ACTION_UP, AINPUT_SOURCE_TOUCHSCREEN,
1904 ADISPLAY_ID_DEFAULT);
Svet Ganov5d3bc372020-01-26 23:11:07 -08001905 mDispatcher->notifyMotion(&upMotionArgs);
1906 // The first window gets nothing and the second gets up
1907 firstWindow->assertNoEvents();
1908 secondWindow->consumeMotionUp();
1909}
1910
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +00001911// Same as TransferTouchFocus_TwoPointersSplitTouch, but using 'transferTouch' api.
1912// Unlike 'transferTouchFocus', calling 'transferTouch' when there are two windows receiving
1913// touch is not supported, so the touch should continue on those windows and the transferred-to
1914// window should get nothing.
1915TEST_F(InputDispatcherTest, TransferTouch_TwoPointersSplitTouch) {
1916 std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
1917
1918 // Create a non touch modal window that supports split touch
1919 sp<FakeWindowHandle> firstWindow =
1920 new FakeWindowHandle(application, mDispatcher, "First Window", ADISPLAY_ID_DEFAULT);
1921 firstWindow->setFrame(Rect(0, 0, 600, 400));
1922 firstWindow->setFlags(InputWindowInfo::Flag::NOT_TOUCH_MODAL |
1923 InputWindowInfo::Flag::SPLIT_TOUCH);
1924
1925 // Create a non touch modal window that supports split touch
1926 sp<FakeWindowHandle> secondWindow =
1927 new FakeWindowHandle(application, mDispatcher, "Second Window", ADISPLAY_ID_DEFAULT);
1928 secondWindow->setFrame(Rect(0, 400, 600, 800));
1929 secondWindow->setFlags(InputWindowInfo::Flag::NOT_TOUCH_MODAL |
1930 InputWindowInfo::Flag::SPLIT_TOUCH);
1931
1932 // Add the windows to the dispatcher
1933 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {firstWindow, secondWindow}}});
1934
1935 PointF pointInFirst = {300, 200};
1936 PointF pointInSecond = {300, 600};
1937
1938 // Send down to the first window
1939 NotifyMotionArgs firstDownMotionArgs =
1940 generateMotionArgs(AMOTION_EVENT_ACTION_DOWN, AINPUT_SOURCE_TOUCHSCREEN,
1941 ADISPLAY_ID_DEFAULT, {pointInFirst});
1942 mDispatcher->notifyMotion(&firstDownMotionArgs);
1943 // Only the first window should get the down event
1944 firstWindow->consumeMotionDown();
1945 secondWindow->assertNoEvents();
1946
1947 // Send down to the second window
1948 NotifyMotionArgs secondDownMotionArgs =
1949 generateMotionArgs(AMOTION_EVENT_ACTION_POINTER_DOWN |
1950 (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
1951 AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT,
1952 {pointInFirst, pointInSecond});
1953 mDispatcher->notifyMotion(&secondDownMotionArgs);
1954 // The first window gets a move and the second a down
1955 firstWindow->consumeMotionMove();
1956 secondWindow->consumeMotionDown();
1957
1958 // Transfer touch focus to the second window
1959 const bool transferred = mDispatcher->transferTouch(secondWindow->getToken());
1960 // The 'transferTouch' call should not succeed, because there are 2 touched windows
1961 ASSERT_FALSE(transferred);
1962 firstWindow->assertNoEvents();
1963 secondWindow->assertNoEvents();
1964
1965 // The rest of the dispatch should proceed as normal
1966 // Send pointer up to the second window
1967 NotifyMotionArgs pointerUpMotionArgs =
1968 generateMotionArgs(AMOTION_EVENT_ACTION_POINTER_UP |
1969 (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
1970 AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT,
1971 {pointInFirst, pointInSecond});
1972 mDispatcher->notifyMotion(&pointerUpMotionArgs);
1973 // The first window gets MOVE and the second gets pointer up
1974 firstWindow->consumeMotionMove();
1975 secondWindow->consumeMotionUp();
1976
1977 // Send up event to the first window
1978 NotifyMotionArgs upMotionArgs =
1979 generateMotionArgs(AMOTION_EVENT_ACTION_UP, AINPUT_SOURCE_TOUCHSCREEN,
1980 ADISPLAY_ID_DEFAULT);
1981 mDispatcher->notifyMotion(&upMotionArgs);
1982 // The first window gets nothing and the second gets up
1983 firstWindow->consumeMotionUp();
1984 secondWindow->assertNoEvents();
1985}
1986
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001987TEST_F(InputDispatcherTest, FocusedWindow_ReceivesFocusEventAndKeyEvent) {
Chris Yea209fde2020-07-22 13:54:51 -07001988 std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001989 sp<FakeWindowHandle> window =
1990 new FakeWindowHandle(application, mDispatcher, "Fake Window", ADISPLAY_ID_DEFAULT);
1991
Vishnu Nair47074b82020-08-14 11:54:47 -07001992 window->setFocusable(true);
Arthur Hung72d8dc32020-03-28 00:48:39 +00001993 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {window}}});
Vishnu Nair958da932020-08-21 17:12:37 -07001994 setFocusedWindow(window);
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01001995
1996 window->consumeFocusEvent(true);
1997
1998 NotifyKeyArgs keyArgs = generateKeyArgs(AKEY_EVENT_ACTION_DOWN, ADISPLAY_ID_DEFAULT);
1999 mDispatcher->notifyKey(&keyArgs);
2000
2001 // Window should receive key down event.
2002 window->consumeKeyDown(ADISPLAY_ID_DEFAULT);
2003}
2004
2005TEST_F(InputDispatcherTest, UnfocusedWindow_DoesNotReceiveFocusEventOrKeyEvent) {
Chris Yea209fde2020-07-22 13:54:51 -07002006 std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01002007 sp<FakeWindowHandle> window =
2008 new FakeWindowHandle(application, mDispatcher, "Fake Window", ADISPLAY_ID_DEFAULT);
2009
Arthur Hung72d8dc32020-03-28 00:48:39 +00002010 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {window}}});
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01002011
2012 NotifyKeyArgs keyArgs = generateKeyArgs(AKEY_EVENT_ACTION_DOWN, ADISPLAY_ID_DEFAULT);
2013 mDispatcher->notifyKey(&keyArgs);
2014 mDispatcher->waitForIdle();
2015
2016 window->assertNoEvents();
2017}
2018
2019// If a window is touchable, but does not have focus, it should receive motion events, but not keys
2020TEST_F(InputDispatcherTest, UnfocusedWindow_ReceivesMotionsButNotKeys) {
Chris Yea209fde2020-07-22 13:54:51 -07002021 std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01002022 sp<FakeWindowHandle> window =
2023 new FakeWindowHandle(application, mDispatcher, "Fake Window", ADISPLAY_ID_DEFAULT);
2024
Arthur Hung72d8dc32020-03-28 00:48:39 +00002025 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {window}}});
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01002026
2027 // Send key
2028 NotifyKeyArgs keyArgs = generateKeyArgs(AKEY_EVENT_ACTION_DOWN, ADISPLAY_ID_DEFAULT);
2029 mDispatcher->notifyKey(&keyArgs);
2030 // Send motion
2031 NotifyMotionArgs motionArgs =
2032 generateMotionArgs(AMOTION_EVENT_ACTION_DOWN, AINPUT_SOURCE_TOUCHSCREEN,
2033 ADISPLAY_ID_DEFAULT);
2034 mDispatcher->notifyMotion(&motionArgs);
2035
2036 // Window should receive only the motion event
2037 window->consumeMotionDown(ADISPLAY_ID_DEFAULT);
2038 window->assertNoEvents(); // Key event or focus event will not be received
2039}
2040
arthurhungea3f4fc2020-12-21 23:18:53 +08002041TEST_F(InputDispatcherTest, PointerCancel_SendCancelWhenSplitTouch) {
2042 std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
2043
2044 // Create first non touch modal window that supports split touch
2045 sp<FakeWindowHandle> firstWindow =
2046 new FakeWindowHandle(application, mDispatcher, "First Window", ADISPLAY_ID_DEFAULT);
2047 firstWindow->setFrame(Rect(0, 0, 600, 400));
2048 firstWindow->setFlags(InputWindowInfo::Flag::NOT_TOUCH_MODAL |
2049 InputWindowInfo::Flag::SPLIT_TOUCH);
2050
2051 // Create second non touch modal window that supports split touch
2052 sp<FakeWindowHandle> secondWindow =
2053 new FakeWindowHandle(application, mDispatcher, "Second Window", ADISPLAY_ID_DEFAULT);
2054 secondWindow->setFrame(Rect(0, 400, 600, 800));
2055 secondWindow->setFlags(InputWindowInfo::Flag::NOT_TOUCH_MODAL |
2056 InputWindowInfo::Flag::SPLIT_TOUCH);
2057
2058 // Add the windows to the dispatcher
2059 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {firstWindow, secondWindow}}});
2060
2061 PointF pointInFirst = {300, 200};
2062 PointF pointInSecond = {300, 600};
2063
2064 // Send down to the first window
2065 NotifyMotionArgs firstDownMotionArgs =
2066 generateMotionArgs(AMOTION_EVENT_ACTION_DOWN, AINPUT_SOURCE_TOUCHSCREEN,
2067 ADISPLAY_ID_DEFAULT, {pointInFirst});
2068 mDispatcher->notifyMotion(&firstDownMotionArgs);
2069 // Only the first window should get the down event
2070 firstWindow->consumeMotionDown();
2071 secondWindow->assertNoEvents();
2072
2073 // Send down to the second window
2074 NotifyMotionArgs secondDownMotionArgs =
2075 generateMotionArgs(AMOTION_EVENT_ACTION_POINTER_DOWN |
2076 (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
2077 AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT,
2078 {pointInFirst, pointInSecond});
2079 mDispatcher->notifyMotion(&secondDownMotionArgs);
2080 // The first window gets a move and the second a down
2081 firstWindow->consumeMotionMove();
2082 secondWindow->consumeMotionDown();
2083
2084 // Send pointer cancel to the second window
2085 NotifyMotionArgs pointerUpMotionArgs =
2086 generateMotionArgs(AMOTION_EVENT_ACTION_POINTER_UP |
2087 (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
2088 AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT,
2089 {pointInFirst, pointInSecond});
2090 pointerUpMotionArgs.flags |= AMOTION_EVENT_FLAG_CANCELED;
2091 mDispatcher->notifyMotion(&pointerUpMotionArgs);
2092 // The first window gets move and the second gets cancel.
2093 firstWindow->consumeMotionMove(ADISPLAY_ID_DEFAULT, AMOTION_EVENT_FLAG_CANCELED);
2094 secondWindow->consumeMotionCancel(ADISPLAY_ID_DEFAULT, AMOTION_EVENT_FLAG_CANCELED);
2095
2096 // Send up event.
2097 NotifyMotionArgs upMotionArgs =
2098 generateMotionArgs(AMOTION_EVENT_ACTION_UP, AINPUT_SOURCE_TOUCHSCREEN,
2099 ADISPLAY_ID_DEFAULT);
2100 mDispatcher->notifyMotion(&upMotionArgs);
2101 // The first window gets up and the second gets nothing.
2102 firstWindow->consumeMotionUp();
2103 secondWindow->assertNoEvents();
2104}
2105
Siarhei Vishniakouf94ae022021-02-04 01:23:17 +00002106TEST_F(InputDispatcherTest, SendTimeline_DoesNotCrashDispatcher) {
2107 std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
2108
2109 sp<FakeWindowHandle> window =
2110 new FakeWindowHandle(application, mDispatcher, "Window", ADISPLAY_ID_DEFAULT);
2111 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {window}}});
2112 std::array<nsecs_t, GraphicsTimeline::SIZE> graphicsTimeline;
2113 graphicsTimeline[GraphicsTimeline::GPU_COMPLETED_TIME] = 2;
2114 graphicsTimeline[GraphicsTimeline::PRESENT_TIME] = 3;
2115
2116 window->sendTimeline(1 /*inputEventId*/, graphicsTimeline);
2117 window->assertNoEvents();
2118 mDispatcher->waitForIdle();
2119}
2120
chaviwd1c23182019-12-20 18:44:56 -08002121class FakeMonitorReceiver {
Michael Wright3a240c42019-12-10 20:53:41 +00002122public:
2123 FakeMonitorReceiver(const sp<InputDispatcher>& dispatcher, const std::string name,
chaviwd1c23182019-12-20 18:44:56 -08002124 int32_t displayId, bool isGestureMonitor = false) {
Garfield Tan15601662020-09-22 15:32:38 -07002125 base::Result<std::unique_ptr<InputChannel>> channel =
Siarhei Vishniakou58cfc602020-12-14 23:21:30 +00002126 dispatcher->createInputMonitor(displayId, isGestureMonitor, name, MONITOR_PID);
Garfield Tan15601662020-09-22 15:32:38 -07002127 mInputReceiver = std::make_unique<FakeInputReceiver>(std::move(*channel), name);
Michael Wright3a240c42019-12-10 20:53:41 +00002128 }
2129
chaviwd1c23182019-12-20 18:44:56 -08002130 sp<IBinder> getToken() { return mInputReceiver->getToken(); }
2131
2132 void consumeKeyDown(int32_t expectedDisplayId, int32_t expectedFlags = 0) {
2133 mInputReceiver->consumeEvent(AINPUT_EVENT_TYPE_KEY, AKEY_EVENT_ACTION_DOWN,
2134 expectedDisplayId, expectedFlags);
2135 }
2136
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002137 std::optional<int32_t> receiveEvent() { return mInputReceiver->receiveEvent(); }
2138
2139 void finishEvent(uint32_t consumeSeq) { return mInputReceiver->finishEvent(consumeSeq); }
2140
chaviwd1c23182019-12-20 18:44:56 -08002141 void consumeMotionDown(int32_t expectedDisplayId, int32_t expectedFlags = 0) {
2142 mInputReceiver->consumeEvent(AINPUT_EVENT_TYPE_MOTION, AMOTION_EVENT_ACTION_DOWN,
2143 expectedDisplayId, expectedFlags);
2144 }
2145
2146 void consumeMotionUp(int32_t expectedDisplayId, int32_t expectedFlags = 0) {
2147 mInputReceiver->consumeEvent(AINPUT_EVENT_TYPE_MOTION, AMOTION_EVENT_ACTION_UP,
2148 expectedDisplayId, expectedFlags);
2149 }
2150
Evan Rosky84f07f02021-04-16 10:42:42 -07002151 MotionEvent* consumeMotion() {
2152 InputEvent* event = mInputReceiver->consume();
2153 if (!event) {
2154 ADD_FAILURE() << "No event was produced";
2155 return nullptr;
2156 }
2157 if (event->getType() != AINPUT_EVENT_TYPE_MOTION) {
2158 ADD_FAILURE() << "Received event of type " << event->getType() << " instead of motion";
2159 return nullptr;
2160 }
2161 return static_cast<MotionEvent*>(event);
2162 }
2163
chaviwd1c23182019-12-20 18:44:56 -08002164 void assertNoEvents() { mInputReceiver->assertNoEvents(); }
2165
2166private:
2167 std::unique_ptr<FakeInputReceiver> mInputReceiver;
Michael Wright3a240c42019-12-10 20:53:41 +00002168};
2169
2170// Tests for gesture monitors
2171TEST_F(InputDispatcherTest, GestureMonitor_ReceivesMotionEvents) {
Chris Yea209fde2020-07-22 13:54:51 -07002172 std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
Michael Wright3a240c42019-12-10 20:53:41 +00002173 sp<FakeWindowHandle> window =
2174 new FakeWindowHandle(application, mDispatcher, "Fake Window", ADISPLAY_ID_DEFAULT);
Arthur Hung72d8dc32020-03-28 00:48:39 +00002175 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {window}}});
Michael Wright3a240c42019-12-10 20:53:41 +00002176
chaviwd1c23182019-12-20 18:44:56 -08002177 FakeMonitorReceiver monitor = FakeMonitorReceiver(mDispatcher, "GM_1", ADISPLAY_ID_DEFAULT,
2178 true /*isGestureMonitor*/);
Michael Wright3a240c42019-12-10 20:53:41 +00002179
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08002180 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
Michael Wright3a240c42019-12-10 20:53:41 +00002181 injectMotionDown(mDispatcher, AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT))
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08002182 << "Inject motion event should return InputEventInjectionResult::SUCCEEDED";
Michael Wright3a240c42019-12-10 20:53:41 +00002183 window->consumeMotionDown(ADISPLAY_ID_DEFAULT);
chaviwd1c23182019-12-20 18:44:56 -08002184 monitor.consumeMotionDown(ADISPLAY_ID_DEFAULT);
Michael Wright3a240c42019-12-10 20:53:41 +00002185}
2186
2187TEST_F(InputDispatcherTest, GestureMonitor_DoesNotReceiveKeyEvents) {
Chris Yea209fde2020-07-22 13:54:51 -07002188 std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
Michael Wright3a240c42019-12-10 20:53:41 +00002189 sp<FakeWindowHandle> window =
2190 new FakeWindowHandle(application, mDispatcher, "Fake Window", ADISPLAY_ID_DEFAULT);
2191
2192 mDispatcher->setFocusedApplication(ADISPLAY_ID_DEFAULT, application);
Vishnu Nair47074b82020-08-14 11:54:47 -07002193 window->setFocusable(true);
Michael Wright3a240c42019-12-10 20:53:41 +00002194
Arthur Hung72d8dc32020-03-28 00:48:39 +00002195 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {window}}});
Vishnu Nair958da932020-08-21 17:12:37 -07002196 setFocusedWindow(window);
2197
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01002198 window->consumeFocusEvent(true);
Michael Wright3a240c42019-12-10 20:53:41 +00002199
chaviwd1c23182019-12-20 18:44:56 -08002200 FakeMonitorReceiver monitor = FakeMonitorReceiver(mDispatcher, "GM_1", ADISPLAY_ID_DEFAULT,
2201 true /*isGestureMonitor*/);
Michael Wright3a240c42019-12-10 20:53:41 +00002202
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08002203 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED, injectKeyDown(mDispatcher, ADISPLAY_ID_DEFAULT))
2204 << "Inject key event should return InputEventInjectionResult::SUCCEEDED";
Michael Wright3a240c42019-12-10 20:53:41 +00002205 window->consumeKeyDown(ADISPLAY_ID_DEFAULT);
chaviwd1c23182019-12-20 18:44:56 -08002206 monitor.assertNoEvents();
Michael Wright3a240c42019-12-10 20:53:41 +00002207}
2208
2209TEST_F(InputDispatcherTest, GestureMonitor_CanPilferAfterWindowIsRemovedMidStream) {
Chris Yea209fde2020-07-22 13:54:51 -07002210 std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
Michael Wright3a240c42019-12-10 20:53:41 +00002211 sp<FakeWindowHandle> window =
2212 new FakeWindowHandle(application, mDispatcher, "Fake Window", ADISPLAY_ID_DEFAULT);
Arthur Hung72d8dc32020-03-28 00:48:39 +00002213 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {window}}});
Michael Wright3a240c42019-12-10 20:53:41 +00002214
chaviwd1c23182019-12-20 18:44:56 -08002215 FakeMonitorReceiver monitor = FakeMonitorReceiver(mDispatcher, "GM_1", ADISPLAY_ID_DEFAULT,
2216 true /*isGestureMonitor*/);
Michael Wright3a240c42019-12-10 20:53:41 +00002217
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08002218 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
Michael Wright3a240c42019-12-10 20:53:41 +00002219 injectMotionDown(mDispatcher, AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT))
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08002220 << "Inject motion event should return InputEventInjectionResult::SUCCEEDED";
Michael Wright3a240c42019-12-10 20:53:41 +00002221 window->consumeMotionDown(ADISPLAY_ID_DEFAULT);
chaviwd1c23182019-12-20 18:44:56 -08002222 monitor.consumeMotionDown(ADISPLAY_ID_DEFAULT);
Michael Wright3a240c42019-12-10 20:53:41 +00002223
2224 window->releaseChannel();
2225
chaviwd1c23182019-12-20 18:44:56 -08002226 mDispatcher->pilferPointers(monitor.getToken());
Michael Wright3a240c42019-12-10 20:53:41 +00002227
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08002228 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
Michael Wright3a240c42019-12-10 20:53:41 +00002229 injectMotionUp(mDispatcher, AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT))
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08002230 << "Inject motion event should return InputEventInjectionResult::SUCCEEDED";
chaviwd1c23182019-12-20 18:44:56 -08002231 monitor.consumeMotionUp(ADISPLAY_ID_DEFAULT);
Michael Wright3a240c42019-12-10 20:53:41 +00002232}
2233
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002234TEST_F(InputDispatcherTest, UnresponsiveGestureMonitor_GetsAnr) {
2235 FakeMonitorReceiver monitor =
2236 FakeMonitorReceiver(mDispatcher, "Gesture monitor", ADISPLAY_ID_DEFAULT,
2237 true /*isGestureMonitor*/);
2238
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08002239 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002240 injectMotionDown(mDispatcher, AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT));
2241 std::optional<uint32_t> consumeSeq = monitor.receiveEvent();
2242 ASSERT_TRUE(consumeSeq);
2243
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00002244 mFakePolicy->assertNotifyMonitorUnresponsiveWasCalled(DISPATCHING_TIMEOUT);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002245 monitor.finishEvent(*consumeSeq);
2246 ASSERT_TRUE(mDispatcher->waitForIdle());
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00002247 mFakePolicy->assertNotifyMonitorResponsiveWasCalled();
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07002248}
2249
Evan Rosky84f07f02021-04-16 10:42:42 -07002250// Tests for gesture monitors
2251TEST_F(InputDispatcherTest, GestureMonitor_NoWindowTransform) {
2252 std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
2253 sp<FakeWindowHandle> window =
2254 new FakeWindowHandle(application, mDispatcher, "Fake Window", ADISPLAY_ID_DEFAULT);
2255 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {window}}});
2256 window->setWindowOffset(20, 40);
2257 window->setWindowTransform(0, 1, -1, 0);
2258
2259 FakeMonitorReceiver monitor = FakeMonitorReceiver(mDispatcher, "GM_1", ADISPLAY_ID_DEFAULT,
2260 true /*isGestureMonitor*/);
2261
2262 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
2263 injectMotionDown(mDispatcher, AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT))
2264 << "Inject motion event should return InputEventInjectionResult::SUCCEEDED";
2265 window->consumeMotionDown(ADISPLAY_ID_DEFAULT);
2266 MotionEvent* event = monitor.consumeMotion();
2267 // Even though window has transform, gesture monitor must not.
2268 ASSERT_EQ(ui::Transform(), event->getTransform());
2269}
2270
chaviw81e2bb92019-12-18 15:03:51 -08002271TEST_F(InputDispatcherTest, TestMoveEvent) {
Chris Yea209fde2020-07-22 13:54:51 -07002272 std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
chaviw81e2bb92019-12-18 15:03:51 -08002273 sp<FakeWindowHandle> window =
2274 new FakeWindowHandle(application, mDispatcher, "Fake Window", ADISPLAY_ID_DEFAULT);
2275
Arthur Hung72d8dc32020-03-28 00:48:39 +00002276 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {window}}});
chaviw81e2bb92019-12-18 15:03:51 -08002277
2278 NotifyMotionArgs motionArgs =
2279 generateMotionArgs(AMOTION_EVENT_ACTION_DOWN, AINPUT_SOURCE_TOUCHSCREEN,
2280 ADISPLAY_ID_DEFAULT);
2281
2282 mDispatcher->notifyMotion(&motionArgs);
2283 // Window should receive motion down event.
2284 window->consumeMotionDown(ADISPLAY_ID_DEFAULT);
2285
2286 motionArgs.action = AMOTION_EVENT_ACTION_MOVE;
Garfield Tanc51d1ba2020-01-28 13:24:04 -08002287 motionArgs.id += 1;
chaviw81e2bb92019-12-18 15:03:51 -08002288 motionArgs.eventTime = systemTime(SYSTEM_TIME_MONOTONIC);
2289 motionArgs.pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_X,
2290 motionArgs.pointerCoords[0].getX() - 10);
2291
2292 mDispatcher->notifyMotion(&motionArgs);
2293 window->consumeEvent(AINPUT_EVENT_TYPE_MOTION, AMOTION_EVENT_ACTION_MOVE, ADISPLAY_ID_DEFAULT,
2294 0 /*expectedFlags*/);
2295}
2296
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01002297/**
2298 * Dispatcher has touch mode enabled by default. Typically, the policy overrides that value to
2299 * the device default right away. In the test scenario, we check both the default value,
2300 * and the action of enabling / disabling.
2301 */
2302TEST_F(InputDispatcherTest, TouchModeState_IsSentToApps) {
Chris Yea209fde2020-07-22 13:54:51 -07002303 std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01002304 sp<FakeWindowHandle> window =
2305 new FakeWindowHandle(application, mDispatcher, "Test window", ADISPLAY_ID_DEFAULT);
2306
2307 // Set focused application.
2308 mDispatcher->setFocusedApplication(ADISPLAY_ID_DEFAULT, application);
Vishnu Nair47074b82020-08-14 11:54:47 -07002309 window->setFocusable(true);
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01002310
2311 SCOPED_TRACE("Check default value of touch mode");
Arthur Hung72d8dc32020-03-28 00:48:39 +00002312 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {window}}});
Vishnu Nair958da932020-08-21 17:12:37 -07002313 setFocusedWindow(window);
2314
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01002315 window->consumeFocusEvent(true /*hasFocus*/, true /*inTouchMode*/);
2316
2317 SCOPED_TRACE("Remove the window to trigger focus loss");
Vishnu Nair47074b82020-08-14 11:54:47 -07002318 window->setFocusable(false);
Arthur Hung72d8dc32020-03-28 00:48:39 +00002319 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {window}}});
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01002320 window->consumeFocusEvent(false /*hasFocus*/, true /*inTouchMode*/);
2321
2322 SCOPED_TRACE("Disable touch mode");
2323 mDispatcher->setInTouchMode(false);
Vishnu Nair47074b82020-08-14 11:54:47 -07002324 window->setFocusable(true);
Arthur Hung72d8dc32020-03-28 00:48:39 +00002325 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {window}}});
Vishnu Nair958da932020-08-21 17:12:37 -07002326 setFocusedWindow(window);
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01002327 window->consumeFocusEvent(true /*hasFocus*/, false /*inTouchMode*/);
2328
2329 SCOPED_TRACE("Remove the window to trigger focus loss");
Vishnu Nair47074b82020-08-14 11:54:47 -07002330 window->setFocusable(false);
Arthur Hung72d8dc32020-03-28 00:48:39 +00002331 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {window}}});
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01002332 window->consumeFocusEvent(false /*hasFocus*/, false /*inTouchMode*/);
2333
2334 SCOPED_TRACE("Enable touch mode again");
2335 mDispatcher->setInTouchMode(true);
Vishnu Nair47074b82020-08-14 11:54:47 -07002336 window->setFocusable(true);
Arthur Hung72d8dc32020-03-28 00:48:39 +00002337 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {window}}});
Vishnu Nair958da932020-08-21 17:12:37 -07002338 setFocusedWindow(window);
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01002339 window->consumeFocusEvent(true /*hasFocus*/, true /*inTouchMode*/);
2340
2341 window->assertNoEvents();
2342}
2343
Gang Wange9087892020-01-07 12:17:14 -05002344TEST_F(InputDispatcherTest, VerifyInputEvent_KeyEvent) {
Chris Yea209fde2020-07-22 13:54:51 -07002345 std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
Gang Wange9087892020-01-07 12:17:14 -05002346 sp<FakeWindowHandle> window =
2347 new FakeWindowHandle(application, mDispatcher, "Test window", ADISPLAY_ID_DEFAULT);
2348
2349 mDispatcher->setFocusedApplication(ADISPLAY_ID_DEFAULT, application);
Vishnu Nair47074b82020-08-14 11:54:47 -07002350 window->setFocusable(true);
Gang Wange9087892020-01-07 12:17:14 -05002351
Arthur Hung72d8dc32020-03-28 00:48:39 +00002352 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {window}}});
Vishnu Nair958da932020-08-21 17:12:37 -07002353 setFocusedWindow(window);
2354
Gang Wange9087892020-01-07 12:17:14 -05002355 window->consumeFocusEvent(true /*hasFocus*/, true /*inTouchMode*/);
2356
2357 NotifyKeyArgs keyArgs = generateKeyArgs(AKEY_EVENT_ACTION_DOWN);
2358 mDispatcher->notifyKey(&keyArgs);
2359
2360 InputEvent* event = window->consume();
2361 ASSERT_NE(event, nullptr);
2362
2363 std::unique_ptr<VerifiedInputEvent> verified = mDispatcher->verifyInputEvent(*event);
2364 ASSERT_NE(verified, nullptr);
2365 ASSERT_EQ(verified->type, VerifiedInputEvent::Type::KEY);
2366
2367 ASSERT_EQ(keyArgs.eventTime, verified->eventTimeNanos);
2368 ASSERT_EQ(keyArgs.deviceId, verified->deviceId);
2369 ASSERT_EQ(keyArgs.source, verified->source);
2370 ASSERT_EQ(keyArgs.displayId, verified->displayId);
2371
2372 const VerifiedKeyEvent& verifiedKey = static_cast<const VerifiedKeyEvent&>(*verified);
2373
2374 ASSERT_EQ(keyArgs.action, verifiedKey.action);
2375 ASSERT_EQ(keyArgs.downTime, verifiedKey.downTimeNanos);
Gang Wange9087892020-01-07 12:17:14 -05002376 ASSERT_EQ(keyArgs.flags & VERIFIED_KEY_EVENT_FLAGS, verifiedKey.flags);
2377 ASSERT_EQ(keyArgs.keyCode, verifiedKey.keyCode);
2378 ASSERT_EQ(keyArgs.scanCode, verifiedKey.scanCode);
2379 ASSERT_EQ(keyArgs.metaState, verifiedKey.metaState);
2380 ASSERT_EQ(0, verifiedKey.repeatCount);
2381}
2382
Siarhei Vishniakou47040bf2020-02-28 15:03:13 -08002383TEST_F(InputDispatcherTest, VerifyInputEvent_MotionEvent) {
Chris Yea209fde2020-07-22 13:54:51 -07002384 std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
Siarhei Vishniakou47040bf2020-02-28 15:03:13 -08002385 sp<FakeWindowHandle> window =
2386 new FakeWindowHandle(application, mDispatcher, "Test window", ADISPLAY_ID_DEFAULT);
2387
2388 mDispatcher->setFocusedApplication(ADISPLAY_ID_DEFAULT, application);
2389
Arthur Hung72d8dc32020-03-28 00:48:39 +00002390 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {window}}});
Siarhei Vishniakou47040bf2020-02-28 15:03:13 -08002391
2392 NotifyMotionArgs motionArgs =
2393 generateMotionArgs(AMOTION_EVENT_ACTION_DOWN, AINPUT_SOURCE_TOUCHSCREEN,
2394 ADISPLAY_ID_DEFAULT);
2395 mDispatcher->notifyMotion(&motionArgs);
2396
2397 InputEvent* event = window->consume();
2398 ASSERT_NE(event, nullptr);
2399
2400 std::unique_ptr<VerifiedInputEvent> verified = mDispatcher->verifyInputEvent(*event);
2401 ASSERT_NE(verified, nullptr);
2402 ASSERT_EQ(verified->type, VerifiedInputEvent::Type::MOTION);
2403
2404 EXPECT_EQ(motionArgs.eventTime, verified->eventTimeNanos);
2405 EXPECT_EQ(motionArgs.deviceId, verified->deviceId);
2406 EXPECT_EQ(motionArgs.source, verified->source);
2407 EXPECT_EQ(motionArgs.displayId, verified->displayId);
2408
2409 const VerifiedMotionEvent& verifiedMotion = static_cast<const VerifiedMotionEvent&>(*verified);
2410
2411 EXPECT_EQ(motionArgs.pointerCoords[0].getX(), verifiedMotion.rawX);
2412 EXPECT_EQ(motionArgs.pointerCoords[0].getY(), verifiedMotion.rawY);
2413 EXPECT_EQ(motionArgs.action & AMOTION_EVENT_ACTION_MASK, verifiedMotion.actionMasked);
2414 EXPECT_EQ(motionArgs.downTime, verifiedMotion.downTimeNanos);
2415 EXPECT_EQ(motionArgs.flags & VERIFIED_MOTION_EVENT_FLAGS, verifiedMotion.flags);
2416 EXPECT_EQ(motionArgs.metaState, verifiedMotion.metaState);
2417 EXPECT_EQ(motionArgs.buttonState, verifiedMotion.buttonState);
2418}
2419
Prabir Pradhanbd527712021-03-09 19:17:09 -08002420TEST_F(InputDispatcherTest, NonPointerMotionEvent_NotTransformed) {
yunho.shinf4a80b82020-11-16 21:13:57 +09002421 std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
2422 sp<FakeWindowHandle> window =
2423 new FakeWindowHandle(application, mDispatcher, "Test window", ADISPLAY_ID_DEFAULT);
2424 const std::string name = window->getName();
2425
2426 // Window gets transformed by offset values.
2427 window->setWindowOffset(500.0f, 500.0f);
2428
2429 mDispatcher->setFocusedApplication(ADISPLAY_ID_DEFAULT, application);
2430 window->setFocusable(true);
2431
2432 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {window}}});
2433
2434 // First, we set focused window so that focusedWindowHandle is not null.
2435 setFocusedWindow(window);
2436
2437 // Second, we consume focus event if it is right or wrong according to onFocusChangedLocked.
2438 window->consumeFocusEvent(true);
2439
Prabir Pradhanbd527712021-03-09 19:17:09 -08002440 constexpr const std::array nonPointerSources = {AINPUT_SOURCE_TRACKBALL,
2441 AINPUT_SOURCE_MOUSE_RELATIVE,
2442 AINPUT_SOURCE_JOYSTICK};
2443 for (const int source : nonPointerSources) {
2444 // Notify motion with a non-pointer source.
2445 NotifyMotionArgs motionArgs =
2446 generateMotionArgs(AMOTION_EVENT_ACTION_MOVE, source, ADISPLAY_ID_DEFAULT);
2447 mDispatcher->notifyMotion(&motionArgs);
yunho.shinf4a80b82020-11-16 21:13:57 +09002448
Prabir Pradhanbd527712021-03-09 19:17:09 -08002449 InputEvent* event = window->consume();
2450 ASSERT_NE(event, nullptr);
2451 ASSERT_EQ(AINPUT_EVENT_TYPE_MOTION, event->getType())
2452 << name.c_str() << "expected " << inputEventTypeToString(AINPUT_EVENT_TYPE_MOTION)
2453 << " event, got " << inputEventTypeToString(event->getType()) << " event";
yunho.shinf4a80b82020-11-16 21:13:57 +09002454
Prabir Pradhanbd527712021-03-09 19:17:09 -08002455 const MotionEvent& motionEvent = static_cast<const MotionEvent&>(*event);
2456 EXPECT_EQ(AMOTION_EVENT_ACTION_MOVE, motionEvent.getAction());
2457 EXPECT_EQ(motionArgs.pointerCount, motionEvent.getPointerCount());
yunho.shinf4a80b82020-11-16 21:13:57 +09002458
Prabir Pradhanbd527712021-03-09 19:17:09 -08002459 float expectedX = motionArgs.pointerCoords[0].getX();
2460 float expectedY = motionArgs.pointerCoords[0].getY();
yunho.shinf4a80b82020-11-16 21:13:57 +09002461
Prabir Pradhanbd527712021-03-09 19:17:09 -08002462 // Ensure the axis values from the final motion event are not transformed.
2463 EXPECT_EQ(expectedX, motionEvent.getX(0))
2464 << "expected " << expectedX << " for x coord of " << name.c_str() << ", got "
2465 << motionEvent.getX(0);
2466 EXPECT_EQ(expectedY, motionEvent.getY(0))
2467 << "expected " << expectedY << " for y coord of " << name.c_str() << ", got "
2468 << motionEvent.getY(0);
2469 // Ensure the raw and transformed axis values for the motion event are the same.
2470 EXPECT_EQ(motionEvent.getRawX(0), motionEvent.getX(0))
2471 << "expected raw and transformed X-axis values to be equal";
2472 EXPECT_EQ(motionEvent.getRawY(0), motionEvent.getY(0))
2473 << "expected raw and transformed Y-axis values to be equal";
2474 }
yunho.shinf4a80b82020-11-16 21:13:57 +09002475}
2476
chaviw09c8d2d2020-08-24 15:48:26 -07002477/**
2478 * Ensure that separate calls to sign the same data are generating the same key.
2479 * We avoid asserting against INVALID_HMAC. Since the key is random, there is a non-zero chance
2480 * that a specific key and data combination would produce INVALID_HMAC, which would cause flaky
2481 * tests.
2482 */
2483TEST_F(InputDispatcherTest, GeneratedHmac_IsConsistent) {
2484 KeyEvent event = getTestKeyEvent();
2485 VerifiedKeyEvent verifiedEvent = verifiedKeyEventFromKeyEvent(event);
2486
2487 std::array<uint8_t, 32> hmac1 = mDispatcher->sign(verifiedEvent);
2488 std::array<uint8_t, 32> hmac2 = mDispatcher->sign(verifiedEvent);
2489 ASSERT_EQ(hmac1, hmac2);
2490}
2491
2492/**
2493 * Ensure that changes in VerifiedKeyEvent produce a different hmac.
2494 */
2495TEST_F(InputDispatcherTest, GeneratedHmac_ChangesWhenFieldsChange) {
2496 KeyEvent event = getTestKeyEvent();
2497 VerifiedKeyEvent verifiedEvent = verifiedKeyEventFromKeyEvent(event);
2498 std::array<uint8_t, 32> initialHmac = mDispatcher->sign(verifiedEvent);
2499
2500 verifiedEvent.deviceId += 1;
2501 ASSERT_NE(initialHmac, mDispatcher->sign(verifiedEvent));
2502
2503 verifiedEvent.source += 1;
2504 ASSERT_NE(initialHmac, mDispatcher->sign(verifiedEvent));
2505
2506 verifiedEvent.eventTimeNanos += 1;
2507 ASSERT_NE(initialHmac, mDispatcher->sign(verifiedEvent));
2508
2509 verifiedEvent.displayId += 1;
2510 ASSERT_NE(initialHmac, mDispatcher->sign(verifiedEvent));
2511
2512 verifiedEvent.action += 1;
2513 ASSERT_NE(initialHmac, mDispatcher->sign(verifiedEvent));
2514
2515 verifiedEvent.downTimeNanos += 1;
2516 ASSERT_NE(initialHmac, mDispatcher->sign(verifiedEvent));
2517
2518 verifiedEvent.flags += 1;
2519 ASSERT_NE(initialHmac, mDispatcher->sign(verifiedEvent));
2520
2521 verifiedEvent.keyCode += 1;
2522 ASSERT_NE(initialHmac, mDispatcher->sign(verifiedEvent));
2523
2524 verifiedEvent.scanCode += 1;
2525 ASSERT_NE(initialHmac, mDispatcher->sign(verifiedEvent));
2526
2527 verifiedEvent.metaState += 1;
2528 ASSERT_NE(initialHmac, mDispatcher->sign(verifiedEvent));
2529
2530 verifiedEvent.repeatCount += 1;
2531 ASSERT_NE(initialHmac, mDispatcher->sign(verifiedEvent));
2532}
2533
Vishnu Nair958da932020-08-21 17:12:37 -07002534TEST_F(InputDispatcherTest, SetFocusedWindow) {
2535 std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
2536 sp<FakeWindowHandle> windowTop =
2537 new FakeWindowHandle(application, mDispatcher, "Top", ADISPLAY_ID_DEFAULT);
2538 sp<FakeWindowHandle> windowSecond =
2539 new FakeWindowHandle(application, mDispatcher, "Second", ADISPLAY_ID_DEFAULT);
2540 mDispatcher->setFocusedApplication(ADISPLAY_ID_DEFAULT, application);
2541
2542 // Top window is also focusable but is not granted focus.
2543 windowTop->setFocusable(true);
2544 windowSecond->setFocusable(true);
2545 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {windowTop, windowSecond}}});
2546 setFocusedWindow(windowSecond);
2547
2548 windowSecond->consumeFocusEvent(true);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08002549 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED, injectKeyDown(mDispatcher))
2550 << "Inject key event should return InputEventInjectionResult::SUCCEEDED";
Vishnu Nair958da932020-08-21 17:12:37 -07002551
2552 // Focused window should receive event.
2553 windowSecond->consumeKeyDown(ADISPLAY_ID_NONE);
2554 windowTop->assertNoEvents();
2555}
2556
2557TEST_F(InputDispatcherTest, SetFocusedWindow_DropRequestInvalidChannel) {
2558 std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
2559 sp<FakeWindowHandle> window =
2560 new FakeWindowHandle(application, mDispatcher, "TestWindow", ADISPLAY_ID_DEFAULT);
2561 mDispatcher->setFocusedApplication(ADISPLAY_ID_DEFAULT, application);
2562
2563 window->setFocusable(true);
2564 // Release channel for window is no longer valid.
2565 window->releaseChannel();
2566 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {window}}});
2567 setFocusedWindow(window);
2568
2569 // Test inject a key down, should timeout.
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08002570 ASSERT_EQ(InputEventInjectionResult::TIMED_OUT, injectKeyDown(mDispatcher))
2571 << "Inject key event should return InputEventInjectionResult::TIMED_OUT";
Vishnu Nair958da932020-08-21 17:12:37 -07002572
2573 // window channel is invalid, so it should not receive any input event.
2574 window->assertNoEvents();
2575}
2576
2577TEST_F(InputDispatcherTest, SetFocusedWindow_DropRequestNoFocusableWindow) {
2578 std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
2579 sp<FakeWindowHandle> window =
2580 new FakeWindowHandle(application, mDispatcher, "TestWindow", ADISPLAY_ID_DEFAULT);
2581 mDispatcher->setFocusedApplication(ADISPLAY_ID_DEFAULT, application);
2582
2583 // Window is not focusable.
2584 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {window}}});
2585 setFocusedWindow(window);
2586
2587 // Test inject a key down, should timeout.
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08002588 ASSERT_EQ(InputEventInjectionResult::TIMED_OUT, injectKeyDown(mDispatcher))
2589 << "Inject key event should return InputEventInjectionResult::TIMED_OUT";
Vishnu Nair958da932020-08-21 17:12:37 -07002590
2591 // window is invalid, so it should not receive any input event.
2592 window->assertNoEvents();
2593}
2594
2595TEST_F(InputDispatcherTest, SetFocusedWindow_CheckFocusedToken) {
2596 std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
2597 sp<FakeWindowHandle> windowTop =
2598 new FakeWindowHandle(application, mDispatcher, "Top", ADISPLAY_ID_DEFAULT);
2599 sp<FakeWindowHandle> windowSecond =
2600 new FakeWindowHandle(application, mDispatcher, "Second", ADISPLAY_ID_DEFAULT);
2601 mDispatcher->setFocusedApplication(ADISPLAY_ID_DEFAULT, application);
2602
2603 windowTop->setFocusable(true);
2604 windowSecond->setFocusable(true);
2605 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {windowTop, windowSecond}}});
2606 setFocusedWindow(windowTop);
2607 windowTop->consumeFocusEvent(true);
2608
2609 setFocusedWindow(windowSecond, windowTop);
2610 windowSecond->consumeFocusEvent(true);
2611 windowTop->consumeFocusEvent(false);
2612
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08002613 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED, injectKeyDown(mDispatcher))
2614 << "Inject key event should return InputEventInjectionResult::SUCCEEDED";
Vishnu Nair958da932020-08-21 17:12:37 -07002615
2616 // Focused window should receive event.
2617 windowSecond->consumeKeyDown(ADISPLAY_ID_NONE);
2618}
2619
2620TEST_F(InputDispatcherTest, SetFocusedWindow_DropRequestFocusTokenNotFocused) {
2621 std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
2622 sp<FakeWindowHandle> windowTop =
2623 new FakeWindowHandle(application, mDispatcher, "Top", ADISPLAY_ID_DEFAULT);
2624 sp<FakeWindowHandle> windowSecond =
2625 new FakeWindowHandle(application, mDispatcher, "Second", ADISPLAY_ID_DEFAULT);
2626 mDispatcher->setFocusedApplication(ADISPLAY_ID_DEFAULT, application);
2627
2628 windowTop->setFocusable(true);
2629 windowSecond->setFocusable(true);
2630 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {windowTop, windowSecond}}});
2631 setFocusedWindow(windowSecond, windowTop);
2632
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08002633 ASSERT_EQ(InputEventInjectionResult::TIMED_OUT, injectKeyDown(mDispatcher))
2634 << "Inject key event should return InputEventInjectionResult::TIMED_OUT";
Vishnu Nair958da932020-08-21 17:12:37 -07002635
2636 // Event should be dropped.
2637 windowTop->assertNoEvents();
2638 windowSecond->assertNoEvents();
2639}
2640
2641TEST_F(InputDispatcherTest, SetFocusedWindow_DeferInvisibleWindow) {
2642 std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
2643 sp<FakeWindowHandle> window =
2644 new FakeWindowHandle(application, mDispatcher, "TestWindow", ADISPLAY_ID_DEFAULT);
2645 sp<FakeWindowHandle> previousFocusedWindow =
2646 new FakeWindowHandle(application, mDispatcher, "previousFocusedWindow",
2647 ADISPLAY_ID_DEFAULT);
2648 mDispatcher->setFocusedApplication(ADISPLAY_ID_DEFAULT, application);
2649
2650 window->setFocusable(true);
2651 previousFocusedWindow->setFocusable(true);
2652 window->setVisible(false);
2653 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {window, previousFocusedWindow}}});
2654 setFocusedWindow(previousFocusedWindow);
2655 previousFocusedWindow->consumeFocusEvent(true);
2656
2657 // Requesting focus on invisible window takes focus from currently focused window.
2658 setFocusedWindow(window);
2659 previousFocusedWindow->consumeFocusEvent(false);
2660
2661 // Injected key goes to pending queue.
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08002662 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
Vishnu Nair958da932020-08-21 17:12:37 -07002663 injectKey(mDispatcher, AKEY_EVENT_ACTION_DOWN, 0 /* repeatCount */,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08002664 ADISPLAY_ID_DEFAULT, InputEventInjectionSync::NONE));
Vishnu Nair958da932020-08-21 17:12:37 -07002665
2666 // Window does not get focus event or key down.
2667 window->assertNoEvents();
2668
2669 // Window becomes visible.
2670 window->setVisible(true);
2671 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {window}}});
2672
2673 // Window receives focus event.
2674 window->consumeFocusEvent(true);
2675 // Focused window receives key down.
2676 window->consumeKeyDown(ADISPLAY_ID_DEFAULT);
2677}
2678
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -10002679/**
2680 * Launch two windows, with different owners. One window (slipperyExitWindow) has Flag::SLIPPERY,
2681 * and overlaps the other window, slipperyEnterWindow. The window 'slipperyExitWindow' is on top
2682 * of the 'slipperyEnterWindow'.
2683 *
2684 * Inject touch down into the top window. Upon receipt of the DOWN event, move the window in such
2685 * a way so that the touched location is no longer covered by the top window.
2686 *
2687 * Next, inject a MOVE event. Because the top window already moved earlier, this event is now
2688 * positioned over the bottom (slipperyEnterWindow) only. And because the top window had
2689 * Flag::SLIPPERY, this will cause the top window to lose the touch event (it will receive
2690 * ACTION_CANCEL instead), and the bottom window will receive a newly generated gesture (starting
2691 * with ACTION_DOWN).
2692 * Thus, the touch has been transferred from the top window into the bottom window, because the top
2693 * window moved itself away from the touched location and had Flag::SLIPPERY.
2694 *
2695 * Even though the top window moved away from the touched location, it is still obscuring the bottom
2696 * window. It's just not obscuring it at the touched location. That means, FLAG_WINDOW_IS_PARTIALLY_
2697 * OBSCURED should be set for the MotionEvent that reaches the bottom window.
2698 *
2699 * In this test, we ensure that the event received by the bottom window has
2700 * FLAG_WINDOW_IS_PARTIALLY_OBSCURED.
2701 */
2702TEST_F(InputDispatcherTest, SlipperyWindow_SetsFlagPartiallyObscured) {
2703 constexpr int32_t SLIPPERY_PID = INJECTOR_PID + 1;
2704 constexpr int32_t SLIPPERY_UID = INJECTOR_UID + 1;
2705
2706 std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();
2707 mDispatcher->setFocusedApplication(ADISPLAY_ID_DEFAULT, application);
2708
2709 sp<FakeWindowHandle> slipperyExitWindow =
2710 new FakeWindowHandle(application, mDispatcher, "Top", ADISPLAY_ID_DEFAULT);
2711 slipperyExitWindow->setFlags(InputWindowInfo::Flag::NOT_TOUCH_MODAL |
2712 InputWindowInfo::Flag::SLIPPERY);
2713 // Make sure this one overlaps the bottom window
2714 slipperyExitWindow->setFrame(Rect(25, 25, 75, 75));
2715 // Change the owner uid/pid of the window so that it is considered to be occluding the bottom
2716 // one. Windows with the same owner are not considered to be occluding each other.
2717 slipperyExitWindow->setOwnerInfo(SLIPPERY_PID, SLIPPERY_UID);
2718
2719 sp<FakeWindowHandle> slipperyEnterWindow =
2720 new FakeWindowHandle(application, mDispatcher, "Second", ADISPLAY_ID_DEFAULT);
2721 slipperyExitWindow->setFrame(Rect(0, 0, 100, 100));
2722
2723 mDispatcher->setInputWindows(
2724 {{ADISPLAY_ID_DEFAULT, {slipperyExitWindow, slipperyEnterWindow}}});
2725
2726 // Use notifyMotion instead of injecting to avoid dealing with injection permissions
2727 NotifyMotionArgs args = generateMotionArgs(AMOTION_EVENT_ACTION_DOWN, AINPUT_SOURCE_TOUCHSCREEN,
2728 ADISPLAY_ID_DEFAULT, {{50, 50}});
2729 mDispatcher->notifyMotion(&args);
2730 slipperyExitWindow->consumeMotionDown();
2731 slipperyExitWindow->setFrame(Rect(70, 70, 100, 100));
2732 mDispatcher->setInputWindows(
2733 {{ADISPLAY_ID_DEFAULT, {slipperyExitWindow, slipperyEnterWindow}}});
2734
2735 args = generateMotionArgs(AMOTION_EVENT_ACTION_MOVE, AINPUT_SOURCE_TOUCHSCREEN,
2736 ADISPLAY_ID_DEFAULT, {{51, 51}});
2737 mDispatcher->notifyMotion(&args);
2738
2739 slipperyExitWindow->consumeMotionCancel();
2740
2741 slipperyEnterWindow->consumeMotionDown(ADISPLAY_ID_DEFAULT,
2742 AMOTION_EVENT_FLAG_WINDOW_IS_PARTIALLY_OBSCURED);
2743}
2744
Garfield Tan1c7bc862020-01-28 13:24:04 -08002745class InputDispatcherKeyRepeatTest : public InputDispatcherTest {
2746protected:
2747 static constexpr nsecs_t KEY_REPEAT_TIMEOUT = 40 * 1000000; // 40 ms
2748 static constexpr nsecs_t KEY_REPEAT_DELAY = 40 * 1000000; // 40 ms
2749
Chris Yea209fde2020-07-22 13:54:51 -07002750 std::shared_ptr<FakeApplicationHandle> mApp;
Garfield Tan1c7bc862020-01-28 13:24:04 -08002751 sp<FakeWindowHandle> mWindow;
2752
2753 virtual void SetUp() override {
2754 mFakePolicy = new FakeInputDispatcherPolicy();
2755 mFakePolicy->setKeyRepeatConfiguration(KEY_REPEAT_TIMEOUT, KEY_REPEAT_DELAY);
2756 mDispatcher = new InputDispatcher(mFakePolicy);
2757 mDispatcher->setInputDispatchMode(/*enabled*/ true, /*frozen*/ false);
2758 ASSERT_EQ(OK, mDispatcher->start());
2759
2760 setUpWindow();
2761 }
2762
2763 void setUpWindow() {
Chris Yea209fde2020-07-22 13:54:51 -07002764 mApp = std::make_shared<FakeApplicationHandle>();
Garfield Tan1c7bc862020-01-28 13:24:04 -08002765 mWindow = new FakeWindowHandle(mApp, mDispatcher, "Fake Window", ADISPLAY_ID_DEFAULT);
2766
Vishnu Nair47074b82020-08-14 11:54:47 -07002767 mWindow->setFocusable(true);
Arthur Hung72d8dc32020-03-28 00:48:39 +00002768 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {mWindow}}});
Vishnu Nair958da932020-08-21 17:12:37 -07002769 setFocusedWindow(mWindow);
Garfield Tan1c7bc862020-01-28 13:24:04 -08002770 mWindow->consumeFocusEvent(true);
2771 }
2772
Chris Ye2ad95392020-09-01 13:44:44 -07002773 void sendAndConsumeKeyDown(int32_t deviceId) {
Garfield Tan1c7bc862020-01-28 13:24:04 -08002774 NotifyKeyArgs keyArgs = generateKeyArgs(AKEY_EVENT_ACTION_DOWN, ADISPLAY_ID_DEFAULT);
Chris Ye2ad95392020-09-01 13:44:44 -07002775 keyArgs.deviceId = deviceId;
Garfield Tan1c7bc862020-01-28 13:24:04 -08002776 keyArgs.policyFlags |= POLICY_FLAG_TRUSTED; // Otherwise it won't generate repeat event
2777 mDispatcher->notifyKey(&keyArgs);
2778
2779 // Window should receive key down event.
2780 mWindow->consumeKeyDown(ADISPLAY_ID_DEFAULT);
2781 }
2782
2783 void expectKeyRepeatOnce(int32_t repeatCount) {
2784 SCOPED_TRACE(StringPrintf("Checking event with repeat count %" PRId32, repeatCount));
2785 InputEvent* repeatEvent = mWindow->consume();
2786 ASSERT_NE(nullptr, repeatEvent);
2787
2788 uint32_t eventType = repeatEvent->getType();
2789 ASSERT_EQ(AINPUT_EVENT_TYPE_KEY, eventType);
2790
2791 KeyEvent* repeatKeyEvent = static_cast<KeyEvent*>(repeatEvent);
2792 uint32_t eventAction = repeatKeyEvent->getAction();
2793 EXPECT_EQ(AKEY_EVENT_ACTION_DOWN, eventAction);
2794 EXPECT_EQ(repeatCount, repeatKeyEvent->getRepeatCount());
2795 }
2796
Chris Ye2ad95392020-09-01 13:44:44 -07002797 void sendAndConsumeKeyUp(int32_t deviceId) {
Garfield Tan1c7bc862020-01-28 13:24:04 -08002798 NotifyKeyArgs keyArgs = generateKeyArgs(AKEY_EVENT_ACTION_UP, ADISPLAY_ID_DEFAULT);
Chris Ye2ad95392020-09-01 13:44:44 -07002799 keyArgs.deviceId = deviceId;
Garfield Tan1c7bc862020-01-28 13:24:04 -08002800 keyArgs.policyFlags |= POLICY_FLAG_TRUSTED; // Unless it won't generate repeat event
2801 mDispatcher->notifyKey(&keyArgs);
2802
2803 // Window should receive key down event.
2804 mWindow->consumeEvent(AINPUT_EVENT_TYPE_KEY, AKEY_EVENT_ACTION_UP, ADISPLAY_ID_DEFAULT,
2805 0 /*expectedFlags*/);
2806 }
2807};
2808
2809TEST_F(InputDispatcherKeyRepeatTest, FocusedWindow_ReceivesKeyRepeat) {
Chris Ye2ad95392020-09-01 13:44:44 -07002810 sendAndConsumeKeyDown(1 /* deviceId */);
2811 for (int32_t repeatCount = 1; repeatCount <= 10; ++repeatCount) {
2812 expectKeyRepeatOnce(repeatCount);
2813 }
2814}
2815
2816TEST_F(InputDispatcherKeyRepeatTest, FocusedWindow_ReceivesKeyRepeatFromTwoDevices) {
2817 sendAndConsumeKeyDown(1 /* deviceId */);
2818 for (int32_t repeatCount = 1; repeatCount <= 10; ++repeatCount) {
2819 expectKeyRepeatOnce(repeatCount);
2820 }
2821 sendAndConsumeKeyDown(2 /* deviceId */);
2822 /* repeatCount will start from 1 for deviceId 2 */
Garfield Tan1c7bc862020-01-28 13:24:04 -08002823 for (int32_t repeatCount = 1; repeatCount <= 10; ++repeatCount) {
2824 expectKeyRepeatOnce(repeatCount);
2825 }
2826}
2827
2828TEST_F(InputDispatcherKeyRepeatTest, FocusedWindow_StopsKeyRepeatAfterUp) {
Chris Ye2ad95392020-09-01 13:44:44 -07002829 sendAndConsumeKeyDown(1 /* deviceId */);
Garfield Tan1c7bc862020-01-28 13:24:04 -08002830 expectKeyRepeatOnce(1 /*repeatCount*/);
Chris Ye2ad95392020-09-01 13:44:44 -07002831 sendAndConsumeKeyUp(1 /* deviceId */);
2832 mWindow->assertNoEvents();
2833}
2834
2835TEST_F(InputDispatcherKeyRepeatTest, FocusedWindow_KeyRepeatAfterStaleDeviceKeyUp) {
2836 sendAndConsumeKeyDown(1 /* deviceId */);
2837 expectKeyRepeatOnce(1 /*repeatCount*/);
2838 sendAndConsumeKeyDown(2 /* deviceId */);
2839 expectKeyRepeatOnce(1 /*repeatCount*/);
2840 // Stale key up from device 1.
2841 sendAndConsumeKeyUp(1 /* deviceId */);
2842 // Device 2 is still down, keep repeating
2843 expectKeyRepeatOnce(2 /*repeatCount*/);
2844 expectKeyRepeatOnce(3 /*repeatCount*/);
2845 // Device 2 key up
2846 sendAndConsumeKeyUp(2 /* deviceId */);
2847 mWindow->assertNoEvents();
2848}
2849
2850TEST_F(InputDispatcherKeyRepeatTest, FocusedWindow_KeyRepeatStopsAfterRepeatingKeyUp) {
2851 sendAndConsumeKeyDown(1 /* deviceId */);
2852 expectKeyRepeatOnce(1 /*repeatCount*/);
2853 sendAndConsumeKeyDown(2 /* deviceId */);
2854 expectKeyRepeatOnce(1 /*repeatCount*/);
2855 // Device 2 which holds the key repeating goes up, expect the repeating to stop.
2856 sendAndConsumeKeyUp(2 /* deviceId */);
2857 // Device 1 still holds key down, but the repeating was already stopped
Garfield Tan1c7bc862020-01-28 13:24:04 -08002858 mWindow->assertNoEvents();
2859}
2860
2861TEST_F(InputDispatcherKeyRepeatTest, FocusedWindow_RepeatKeyEventsUseEventIdFromInputDispatcher) {
Chris Ye2ad95392020-09-01 13:44:44 -07002862 sendAndConsumeKeyDown(1 /* deviceId */);
Garfield Tan1c7bc862020-01-28 13:24:04 -08002863 for (int32_t repeatCount = 1; repeatCount <= 10; ++repeatCount) {
2864 InputEvent* repeatEvent = mWindow->consume();
2865 ASSERT_NE(nullptr, repeatEvent) << "Didn't receive event with repeat count " << repeatCount;
2866 EXPECT_EQ(IdGenerator::Source::INPUT_DISPATCHER,
2867 IdGenerator::getSource(repeatEvent->getId()));
2868 }
2869}
2870
2871TEST_F(InputDispatcherKeyRepeatTest, FocusedWindow_RepeatKeyEventsUseUniqueEventId) {
Chris Ye2ad95392020-09-01 13:44:44 -07002872 sendAndConsumeKeyDown(1 /* deviceId */);
Garfield Tan1c7bc862020-01-28 13:24:04 -08002873
2874 std::unordered_set<int32_t> idSet;
2875 for (int32_t repeatCount = 1; repeatCount <= 10; ++repeatCount) {
2876 InputEvent* repeatEvent = mWindow->consume();
2877 ASSERT_NE(nullptr, repeatEvent) << "Didn't receive event with repeat count " << repeatCount;
2878 int32_t id = repeatEvent->getId();
2879 EXPECT_EQ(idSet.end(), idSet.find(id));
2880 idSet.insert(id);
2881 }
2882}
2883
Arthur Hung2fbf37f2018-09-13 18:16:41 +08002884/* Test InputDispatcher for MultiDisplay */
2885class InputDispatcherFocusOnTwoDisplaysTest : public InputDispatcherTest {
2886public:
2887 static constexpr int32_t SECOND_DISPLAY_ID = 1;
Prabir Pradhan3608aad2019-10-02 17:08:26 -07002888 virtual void SetUp() override {
Arthur Hung2fbf37f2018-09-13 18:16:41 +08002889 InputDispatcherTest::SetUp();
Arthur Hungb92218b2018-08-14 12:00:21 +08002890
Chris Yea209fde2020-07-22 13:54:51 -07002891 application1 = std::make_shared<FakeApplicationHandle>();
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -10002892 windowInPrimary =
2893 new FakeWindowHandle(application1, mDispatcher, "D_1", ADISPLAY_ID_DEFAULT);
Siarhei Vishniakoub9b15352019-11-26 13:19:26 -08002894
Arthur Hung2fbf37f2018-09-13 18:16:41 +08002895 // Set focus window for primary display, but focused display would be second one.
2896 mDispatcher->setFocusedApplication(ADISPLAY_ID_DEFAULT, application1);
Vishnu Nair47074b82020-08-14 11:54:47 -07002897 windowInPrimary->setFocusable(true);
Arthur Hung72d8dc32020-03-28 00:48:39 +00002898 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {windowInPrimary}}});
Vishnu Nair958da932020-08-21 17:12:37 -07002899 setFocusedWindow(windowInPrimary);
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01002900 windowInPrimary->consumeFocusEvent(true);
Arthur Hungb92218b2018-08-14 12:00:21 +08002901
Chris Yea209fde2020-07-22 13:54:51 -07002902 application2 = std::make_shared<FakeApplicationHandle>();
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -10002903 windowInSecondary =
2904 new FakeWindowHandle(application2, mDispatcher, "D_2", SECOND_DISPLAY_ID);
Arthur Hung2fbf37f2018-09-13 18:16:41 +08002905 // Set focus to second display window.
Arthur Hung2fbf37f2018-09-13 18:16:41 +08002906 // Set focus display to second one.
2907 mDispatcher->setFocusedDisplay(SECOND_DISPLAY_ID);
2908 // Set focus window for second display.
2909 mDispatcher->setFocusedApplication(SECOND_DISPLAY_ID, application2);
Vishnu Nair47074b82020-08-14 11:54:47 -07002910 windowInSecondary->setFocusable(true);
Arthur Hung72d8dc32020-03-28 00:48:39 +00002911 mDispatcher->setInputWindows({{SECOND_DISPLAY_ID, {windowInSecondary}}});
Vishnu Nair958da932020-08-21 17:12:37 -07002912 setFocusedWindow(windowInSecondary);
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01002913 windowInSecondary->consumeFocusEvent(true);
Arthur Hung2fbf37f2018-09-13 18:16:41 +08002914 }
2915
Prabir Pradhan3608aad2019-10-02 17:08:26 -07002916 virtual void TearDown() override {
Arthur Hung2fbf37f2018-09-13 18:16:41 +08002917 InputDispatcherTest::TearDown();
2918
Chris Yea209fde2020-07-22 13:54:51 -07002919 application1.reset();
Arthur Hung2fbf37f2018-09-13 18:16:41 +08002920 windowInPrimary.clear();
Chris Yea209fde2020-07-22 13:54:51 -07002921 application2.reset();
Arthur Hung2fbf37f2018-09-13 18:16:41 +08002922 windowInSecondary.clear();
2923 }
2924
2925protected:
Chris Yea209fde2020-07-22 13:54:51 -07002926 std::shared_ptr<FakeApplicationHandle> application1;
Arthur Hung2fbf37f2018-09-13 18:16:41 +08002927 sp<FakeWindowHandle> windowInPrimary;
Chris Yea209fde2020-07-22 13:54:51 -07002928 std::shared_ptr<FakeApplicationHandle> application2;
Arthur Hung2fbf37f2018-09-13 18:16:41 +08002929 sp<FakeWindowHandle> windowInSecondary;
2930};
2931
2932TEST_F(InputDispatcherFocusOnTwoDisplaysTest, SetInputWindow_MultiDisplayTouch) {
2933 // Test touch down on primary display.
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08002934 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
2935 injectMotionDown(mDispatcher, AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT))
2936 << "Inject motion event should return InputEventInjectionResult::SUCCEEDED";
Siarhei Vishniakouc5ca85c2019-11-15 17:20:00 -08002937 windowInPrimary->consumeMotionDown(ADISPLAY_ID_DEFAULT);
Arthur Hungb92218b2018-08-14 12:00:21 +08002938 windowInSecondary->assertNoEvents();
2939
Arthur Hung2fbf37f2018-09-13 18:16:41 +08002940 // Test touch down on second display.
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08002941 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
2942 injectMotionDown(mDispatcher, AINPUT_SOURCE_TOUCHSCREEN, SECOND_DISPLAY_ID))
2943 << "Inject motion event should return InputEventInjectionResult::SUCCEEDED";
Arthur Hungb92218b2018-08-14 12:00:21 +08002944 windowInPrimary->assertNoEvents();
Siarhei Vishniakouc5ca85c2019-11-15 17:20:00 -08002945 windowInSecondary->consumeMotionDown(SECOND_DISPLAY_ID);
Arthur Hungb92218b2018-08-14 12:00:21 +08002946}
2947
Arthur Hung2fbf37f2018-09-13 18:16:41 +08002948TEST_F(InputDispatcherFocusOnTwoDisplaysTest, SetInputWindow_MultiDisplayFocus) {
Tiger Huang721e26f2018-07-24 22:26:19 +08002949 // Test inject a key down with display id specified.
Prabir Pradhan93f342c2021-03-11 15:05:30 -08002950 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
2951 injectKeyDownNoRepeat(mDispatcher, ADISPLAY_ID_DEFAULT))
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08002952 << "Inject key event should return InputEventInjectionResult::SUCCEEDED";
Siarhei Vishniakouc5ca85c2019-11-15 17:20:00 -08002953 windowInPrimary->consumeKeyDown(ADISPLAY_ID_DEFAULT);
Tiger Huang721e26f2018-07-24 22:26:19 +08002954 windowInSecondary->assertNoEvents();
2955
2956 // Test inject a key down without display id specified.
Prabir Pradhan93f342c2021-03-11 15:05:30 -08002957 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED, injectKeyDownNoRepeat(mDispatcher))
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08002958 << "Inject key event should return InputEventInjectionResult::SUCCEEDED";
Arthur Hungb92218b2018-08-14 12:00:21 +08002959 windowInPrimary->assertNoEvents();
Siarhei Vishniakouc5ca85c2019-11-15 17:20:00 -08002960 windowInSecondary->consumeKeyDown(ADISPLAY_ID_NONE);
Arthur Hungb92218b2018-08-14 12:00:21 +08002961
Siarhei Vishniakoub9b15352019-11-26 13:19:26 -08002962 // Remove all windows in secondary display.
Arthur Hung72d8dc32020-03-28 00:48:39 +00002963 mDispatcher->setInputWindows({{SECOND_DISPLAY_ID, {}}});
Arthur Hungb92218b2018-08-14 12:00:21 +08002964
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08002965 // Old focus should receive a cancel event.
Siarhei Vishniakouc5ca85c2019-11-15 17:20:00 -08002966 windowInSecondary->consumeEvent(AINPUT_EVENT_TYPE_KEY, AKEY_EVENT_ACTION_UP, ADISPLAY_ID_NONE,
2967 AKEY_EVENT_FLAG_CANCELED);
Arthur Hungb92218b2018-08-14 12:00:21 +08002968
2969 // Test inject a key down, should timeout because of no target window.
Prabir Pradhan93f342c2021-03-11 15:05:30 -08002970 ASSERT_EQ(InputEventInjectionResult::TIMED_OUT, injectKeyDownNoRepeat(mDispatcher))
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08002971 << "Inject key event should return InputEventInjectionResult::TIMED_OUT";
Arthur Hungb92218b2018-08-14 12:00:21 +08002972 windowInPrimary->assertNoEvents();
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01002973 windowInSecondary->consumeFocusEvent(false);
Arthur Hungb92218b2018-08-14 12:00:21 +08002974 windowInSecondary->assertNoEvents();
2975}
2976
Arthur Hung2fbf37f2018-09-13 18:16:41 +08002977// Test per-display input monitors for motion event.
2978TEST_F(InputDispatcherFocusOnTwoDisplaysTest, MonitorMotionEvent_MultiDisplay) {
chaviwd1c23182019-12-20 18:44:56 -08002979 FakeMonitorReceiver monitorInPrimary =
2980 FakeMonitorReceiver(mDispatcher, "M_1", ADISPLAY_ID_DEFAULT);
2981 FakeMonitorReceiver monitorInSecondary =
2982 FakeMonitorReceiver(mDispatcher, "M_2", SECOND_DISPLAY_ID);
Arthur Hung2fbf37f2018-09-13 18:16:41 +08002983
2984 // Test touch down on primary display.
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08002985 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
2986 injectMotionDown(mDispatcher, AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT))
2987 << "Inject motion event should return InputEventInjectionResult::SUCCEEDED";
Siarhei Vishniakouc5ca85c2019-11-15 17:20:00 -08002988 windowInPrimary->consumeMotionDown(ADISPLAY_ID_DEFAULT);
chaviwd1c23182019-12-20 18:44:56 -08002989 monitorInPrimary.consumeMotionDown(ADISPLAY_ID_DEFAULT);
Arthur Hung2fbf37f2018-09-13 18:16:41 +08002990 windowInSecondary->assertNoEvents();
chaviwd1c23182019-12-20 18:44:56 -08002991 monitorInSecondary.assertNoEvents();
Arthur Hung2fbf37f2018-09-13 18:16:41 +08002992
2993 // Test touch down on second display.
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08002994 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
2995 injectMotionDown(mDispatcher, AINPUT_SOURCE_TOUCHSCREEN, SECOND_DISPLAY_ID))
2996 << "Inject motion event should return InputEventInjectionResult::SUCCEEDED";
Arthur Hung2fbf37f2018-09-13 18:16:41 +08002997 windowInPrimary->assertNoEvents();
chaviwd1c23182019-12-20 18:44:56 -08002998 monitorInPrimary.assertNoEvents();
Siarhei Vishniakouc5ca85c2019-11-15 17:20:00 -08002999 windowInSecondary->consumeMotionDown(SECOND_DISPLAY_ID);
chaviwd1c23182019-12-20 18:44:56 -08003000 monitorInSecondary.consumeMotionDown(SECOND_DISPLAY_ID);
Arthur Hung2fbf37f2018-09-13 18:16:41 +08003001
3002 // Test inject a non-pointer motion event.
3003 // If specific a display, it will dispatch to the focused window of particular display,
3004 // or it will dispatch to the focused window of focused display.
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003005 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
3006 injectMotionDown(mDispatcher, AINPUT_SOURCE_TRACKBALL, ADISPLAY_ID_NONE))
3007 << "Inject motion event should return InputEventInjectionResult::SUCCEEDED";
Arthur Hung2fbf37f2018-09-13 18:16:41 +08003008 windowInPrimary->assertNoEvents();
chaviwd1c23182019-12-20 18:44:56 -08003009 monitorInPrimary.assertNoEvents();
Siarhei Vishniakouc5ca85c2019-11-15 17:20:00 -08003010 windowInSecondary->consumeMotionDown(ADISPLAY_ID_NONE);
chaviwd1c23182019-12-20 18:44:56 -08003011 monitorInSecondary.consumeMotionDown(ADISPLAY_ID_NONE);
Arthur Hung2fbf37f2018-09-13 18:16:41 +08003012}
3013
3014// Test per-display input monitors for key event.
3015TEST_F(InputDispatcherFocusOnTwoDisplaysTest, MonitorKeyEvent_MultiDisplay) {
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -10003016 // Input monitor per display.
chaviwd1c23182019-12-20 18:44:56 -08003017 FakeMonitorReceiver monitorInPrimary =
3018 FakeMonitorReceiver(mDispatcher, "M_1", ADISPLAY_ID_DEFAULT);
3019 FakeMonitorReceiver monitorInSecondary =
3020 FakeMonitorReceiver(mDispatcher, "M_2", SECOND_DISPLAY_ID);
Arthur Hung2fbf37f2018-09-13 18:16:41 +08003021
3022 // Test inject a key down.
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003023 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED, injectKeyDown(mDispatcher))
3024 << "Inject key event should return InputEventInjectionResult::SUCCEEDED";
Arthur Hung2fbf37f2018-09-13 18:16:41 +08003025 windowInPrimary->assertNoEvents();
chaviwd1c23182019-12-20 18:44:56 -08003026 monitorInPrimary.assertNoEvents();
Siarhei Vishniakouc5ca85c2019-11-15 17:20:00 -08003027 windowInSecondary->consumeKeyDown(ADISPLAY_ID_NONE);
chaviwd1c23182019-12-20 18:44:56 -08003028 monitorInSecondary.consumeKeyDown(ADISPLAY_ID_NONE);
Arthur Hung2fbf37f2018-09-13 18:16:41 +08003029}
3030
Vishnu Nair958da932020-08-21 17:12:37 -07003031TEST_F(InputDispatcherFocusOnTwoDisplaysTest, CanFocusWindowOnUnfocusedDisplay) {
3032 sp<FakeWindowHandle> secondWindowInPrimary =
3033 new FakeWindowHandle(application1, mDispatcher, "D_1_W2", ADISPLAY_ID_DEFAULT);
3034 secondWindowInPrimary->setFocusable(true);
3035 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {windowInPrimary, secondWindowInPrimary}}});
3036 setFocusedWindow(secondWindowInPrimary);
3037 windowInPrimary->consumeFocusEvent(false);
3038 secondWindowInPrimary->consumeFocusEvent(true);
3039
3040 // Test inject a key down.
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003041 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED, injectKeyDown(mDispatcher, ADISPLAY_ID_DEFAULT))
3042 << "Inject key event should return InputEventInjectionResult::SUCCEEDED";
Vishnu Nair958da932020-08-21 17:12:37 -07003043 windowInPrimary->assertNoEvents();
3044 windowInSecondary->assertNoEvents();
3045 secondWindowInPrimary->consumeKeyDown(ADISPLAY_ID_DEFAULT);
3046}
3047
Jackal Guof9696682018-10-05 12:23:23 +08003048class InputFilterTest : public InputDispatcherTest {
3049protected:
3050 static constexpr int32_t SECOND_DISPLAY_ID = 1;
3051
3052 void testNotifyMotion(int32_t displayId, bool expectToBeFiltered) {
3053 NotifyMotionArgs motionArgs;
3054
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -10003055 motionArgs =
3056 generateMotionArgs(AMOTION_EVENT_ACTION_DOWN, AINPUT_SOURCE_TOUCHSCREEN, displayId);
Jackal Guof9696682018-10-05 12:23:23 +08003057 mDispatcher->notifyMotion(&motionArgs);
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -10003058 motionArgs =
3059 generateMotionArgs(AMOTION_EVENT_ACTION_UP, AINPUT_SOURCE_TOUCHSCREEN, displayId);
Jackal Guof9696682018-10-05 12:23:23 +08003060 mDispatcher->notifyMotion(&motionArgs);
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -08003061 ASSERT_TRUE(mDispatcher->waitForIdle());
Jackal Guof9696682018-10-05 12:23:23 +08003062 if (expectToBeFiltered) {
Siarhei Vishniakou8935a802019-11-15 16:41:44 -08003063 mFakePolicy->assertFilterInputEventWasCalled(motionArgs);
Jackal Guof9696682018-10-05 12:23:23 +08003064 } else {
3065 mFakePolicy->assertFilterInputEventWasNotCalled();
3066 }
3067 }
3068
3069 void testNotifyKey(bool expectToBeFiltered) {
3070 NotifyKeyArgs keyArgs;
3071
3072 keyArgs = generateKeyArgs(AKEY_EVENT_ACTION_DOWN);
3073 mDispatcher->notifyKey(&keyArgs);
3074 keyArgs = generateKeyArgs(AKEY_EVENT_ACTION_UP);
3075 mDispatcher->notifyKey(&keyArgs);
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -08003076 ASSERT_TRUE(mDispatcher->waitForIdle());
Jackal Guof9696682018-10-05 12:23:23 +08003077
3078 if (expectToBeFiltered) {
Siarhei Vishniakou8935a802019-11-15 16:41:44 -08003079 mFakePolicy->assertFilterInputEventWasCalled(keyArgs);
Jackal Guof9696682018-10-05 12:23:23 +08003080 } else {
3081 mFakePolicy->assertFilterInputEventWasNotCalled();
3082 }
3083 }
3084};
3085
3086// Test InputFilter for MotionEvent
3087TEST_F(InputFilterTest, MotionEvent_InputFilter) {
3088 // Since the InputFilter is disabled by default, check if touch events aren't filtered.
3089 testNotifyMotion(ADISPLAY_ID_DEFAULT, /*expectToBeFiltered*/ false);
3090 testNotifyMotion(SECOND_DISPLAY_ID, /*expectToBeFiltered*/ false);
3091
3092 // Enable InputFilter
3093 mDispatcher->setInputFilterEnabled(true);
3094 // Test touch on both primary and second display, and check if both events are filtered.
3095 testNotifyMotion(ADISPLAY_ID_DEFAULT, /*expectToBeFiltered*/ true);
3096 testNotifyMotion(SECOND_DISPLAY_ID, /*expectToBeFiltered*/ true);
3097
3098 // Disable InputFilter
3099 mDispatcher->setInputFilterEnabled(false);
3100 // Test touch on both primary and second display, and check if both events aren't filtered.
3101 testNotifyMotion(ADISPLAY_ID_DEFAULT, /*expectToBeFiltered*/ false);
3102 testNotifyMotion(SECOND_DISPLAY_ID, /*expectToBeFiltered*/ false);
3103}
3104
3105// Test InputFilter for KeyEvent
3106TEST_F(InputFilterTest, KeyEvent_InputFilter) {
3107 // Since the InputFilter is disabled by default, check if key event aren't filtered.
3108 testNotifyKey(/*expectToBeFiltered*/ false);
3109
3110 // Enable InputFilter
3111 mDispatcher->setInputFilterEnabled(true);
3112 // Send a key event, and check if it is filtered.
3113 testNotifyKey(/*expectToBeFiltered*/ true);
3114
3115 // Disable InputFilter
3116 mDispatcher->setInputFilterEnabled(false);
3117 // Send a key event, and check if it isn't filtered.
3118 testNotifyKey(/*expectToBeFiltered*/ false);
3119}
3120
chaviwfd6d3512019-03-25 13:23:49 -07003121class InputDispatcherOnPointerDownOutsideFocus : public InputDispatcherTest {
Prabir Pradhan3608aad2019-10-02 17:08:26 -07003122 virtual void SetUp() override {
chaviwfd6d3512019-03-25 13:23:49 -07003123 InputDispatcherTest::SetUp();
3124
Chris Yea209fde2020-07-22 13:54:51 -07003125 std::shared_ptr<FakeApplicationHandle> application =
3126 std::make_shared<FakeApplicationHandle>();
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -10003127 mUnfocusedWindow =
3128 new FakeWindowHandle(application, mDispatcher, "Top", ADISPLAY_ID_DEFAULT);
chaviwfd6d3512019-03-25 13:23:49 -07003129 mUnfocusedWindow->setFrame(Rect(0, 0, 30, 30));
3130 // Adding FLAG_NOT_TOUCH_MODAL to ensure taps outside this window are not sent to this
3131 // window.
Michael Wright44753b12020-07-08 13:48:11 +01003132 mUnfocusedWindow->setFlags(InputWindowInfo::Flag::NOT_TOUCH_MODAL);
chaviwfd6d3512019-03-25 13:23:49 -07003133
Siarhei Vishniakoub9b15352019-11-26 13:19:26 -08003134 mFocusedWindow =
3135 new FakeWindowHandle(application, mDispatcher, "Second", ADISPLAY_ID_DEFAULT);
3136 mFocusedWindow->setFrame(Rect(50, 50, 100, 100));
Michael Wright44753b12020-07-08 13:48:11 +01003137 mFocusedWindow->setFlags(InputWindowInfo::Flag::NOT_TOUCH_MODAL);
chaviwfd6d3512019-03-25 13:23:49 -07003138
3139 // Set focused application.
3140 mDispatcher->setFocusedApplication(ADISPLAY_ID_DEFAULT, application);
Vishnu Nair47074b82020-08-14 11:54:47 -07003141 mFocusedWindow->setFocusable(true);
chaviwfd6d3512019-03-25 13:23:49 -07003142
3143 // Expect one focus window exist in display.
Arthur Hung72d8dc32020-03-28 00:48:39 +00003144 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {mUnfocusedWindow, mFocusedWindow}}});
Vishnu Nair958da932020-08-21 17:12:37 -07003145 setFocusedWindow(mFocusedWindow);
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01003146 mFocusedWindow->consumeFocusEvent(true);
chaviwfd6d3512019-03-25 13:23:49 -07003147 }
3148
Prabir Pradhan3608aad2019-10-02 17:08:26 -07003149 virtual void TearDown() override {
chaviwfd6d3512019-03-25 13:23:49 -07003150 InputDispatcherTest::TearDown();
3151
3152 mUnfocusedWindow.clear();
Siarhei Vishniakoub9b15352019-11-26 13:19:26 -08003153 mFocusedWindow.clear();
chaviwfd6d3512019-03-25 13:23:49 -07003154 }
3155
3156protected:
3157 sp<FakeWindowHandle> mUnfocusedWindow;
Siarhei Vishniakoub9b15352019-11-26 13:19:26 -08003158 sp<FakeWindowHandle> mFocusedWindow;
Siarhei Vishniakoufb9fcda2020-05-04 14:59:19 -07003159 static constexpr PointF FOCUSED_WINDOW_TOUCH_POINT = {60, 60};
chaviwfd6d3512019-03-25 13:23:49 -07003160};
3161
3162// Have two windows, one with focus. Inject MotionEvent with source TOUCHSCREEN and action
3163// DOWN on the window that doesn't have focus. Ensure the window that didn't have focus received
3164// the onPointerDownOutsideFocus callback.
3165TEST_F(InputDispatcherOnPointerDownOutsideFocus, OnPointerDownOutsideFocus_Success) {
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003166 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
Siarhei Vishniakoufb9fcda2020-05-04 14:59:19 -07003167 injectMotionDown(mDispatcher, AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT,
3168 {20, 20}))
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003169 << "Inject motion event should return InputEventInjectionResult::SUCCEEDED";
Siarhei Vishniakou03aee2a2020-04-13 20:44:54 -07003170 mUnfocusedWindow->consumeMotionDown();
chaviwfd6d3512019-03-25 13:23:49 -07003171
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -08003172 ASSERT_TRUE(mDispatcher->waitForIdle());
chaviwfd6d3512019-03-25 13:23:49 -07003173 mFakePolicy->assertOnPointerDownEquals(mUnfocusedWindow->getToken());
3174}
3175
3176// Have two windows, one with focus. Inject MotionEvent with source TRACKBALL and action
3177// DOWN on the window that doesn't have focus. Ensure no window received the
3178// onPointerDownOutsideFocus callback.
3179TEST_F(InputDispatcherOnPointerDownOutsideFocus, OnPointerDownOutsideFocus_NonPointerSource) {
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003180 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
Siarhei Vishniakoufb9fcda2020-05-04 14:59:19 -07003181 injectMotionDown(mDispatcher, AINPUT_SOURCE_TRACKBALL, ADISPLAY_ID_DEFAULT, {20, 20}))
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003182 << "Inject motion event should return InputEventInjectionResult::SUCCEEDED";
Siarhei Vishniakou03aee2a2020-04-13 20:44:54 -07003183 mFocusedWindow->consumeMotionDown();
chaviwfd6d3512019-03-25 13:23:49 -07003184
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -08003185 ASSERT_TRUE(mDispatcher->waitForIdle());
3186 mFakePolicy->assertOnPointerDownWasNotCalled();
chaviwfd6d3512019-03-25 13:23:49 -07003187}
3188
3189// Have two windows, one with focus. Inject KeyEvent with action DOWN on the window that doesn't
3190// have focus. Ensure no window received the onPointerDownOutsideFocus callback.
3191TEST_F(InputDispatcherOnPointerDownOutsideFocus, OnPointerDownOutsideFocus_NonMotionFailure) {
Prabir Pradhan93f342c2021-03-11 15:05:30 -08003192 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
3193 injectKeyDownNoRepeat(mDispatcher, ADISPLAY_ID_DEFAULT))
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003194 << "Inject key event should return InputEventInjectionResult::SUCCEEDED";
Siarhei Vishniakou03aee2a2020-04-13 20:44:54 -07003195 mFocusedWindow->consumeKeyDown(ADISPLAY_ID_DEFAULT);
chaviwfd6d3512019-03-25 13:23:49 -07003196
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -08003197 ASSERT_TRUE(mDispatcher->waitForIdle());
3198 mFakePolicy->assertOnPointerDownWasNotCalled();
chaviwfd6d3512019-03-25 13:23:49 -07003199}
3200
3201// Have two windows, one with focus. Inject MotionEvent with source TOUCHSCREEN and action
3202// DOWN on the window that already has focus. Ensure no window received the
3203// onPointerDownOutsideFocus callback.
Siarhei Vishniakou870ecec2020-12-09 08:07:46 -10003204TEST_F(InputDispatcherOnPointerDownOutsideFocus, OnPointerDownOutsideFocus_OnAlreadyFocusedWindow) {
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003205 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
Siarhei Vishniakoub9b15352019-11-26 13:19:26 -08003206 injectMotionDown(mDispatcher, AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT,
Siarhei Vishniakoufb9fcda2020-05-04 14:59:19 -07003207 FOCUSED_WINDOW_TOUCH_POINT))
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003208 << "Inject motion event should return InputEventInjectionResult::SUCCEEDED";
Siarhei Vishniakou03aee2a2020-04-13 20:44:54 -07003209 mFocusedWindow->consumeMotionDown();
chaviwfd6d3512019-03-25 13:23:49 -07003210
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -08003211 ASSERT_TRUE(mDispatcher->waitForIdle());
3212 mFakePolicy->assertOnPointerDownWasNotCalled();
chaviwfd6d3512019-03-25 13:23:49 -07003213}
3214
Prabir Pradhan47cf0a02021-03-11 20:30:57 -08003215// Have two windows, one with focus. Injecting a trusted DOWN MotionEvent with the flag
3216// NO_FOCUS_CHANGE on the unfocused window should not call the onPointerDownOutsideFocus callback.
3217TEST_F(InputDispatcherOnPointerDownOutsideFocus, NoFocusChangeFlag) {
3218 const MotionEvent event =
3219 MotionEventBuilder(AMOTION_EVENT_ACTION_DOWN, AINPUT_SOURCE_MOUSE)
3220 .eventTime(systemTime(SYSTEM_TIME_MONOTONIC))
3221 .pointer(PointerBuilder(/* id */ 0, AMOTION_EVENT_TOOL_TYPE_FINGER).x(20).y(20))
3222 .addFlag(AMOTION_EVENT_FLAG_NO_FOCUS_CHANGE)
3223 .build();
3224 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED, injectMotionEvent(mDispatcher, event))
3225 << "Inject motion event should return InputEventInjectionResult::SUCCEEDED";
3226 mUnfocusedWindow->consumeAnyMotionDown(ADISPLAY_ID_DEFAULT, AMOTION_EVENT_FLAG_NO_FOCUS_CHANGE);
3227
3228 ASSERT_TRUE(mDispatcher->waitForIdle());
3229 mFakePolicy->assertOnPointerDownWasNotCalled();
3230 // Ensure that the unfocused window did not receive any FOCUS events.
3231 mUnfocusedWindow->assertNoEvents();
3232}
3233
chaviwaf87b3e2019-10-01 16:59:28 -07003234// These tests ensures we can send touch events to a single client when there are multiple input
3235// windows that point to the same client token.
3236class InputDispatcherMultiWindowSameTokenTests : public InputDispatcherTest {
3237 virtual void SetUp() override {
3238 InputDispatcherTest::SetUp();
3239
Chris Yea209fde2020-07-22 13:54:51 -07003240 std::shared_ptr<FakeApplicationHandle> application =
3241 std::make_shared<FakeApplicationHandle>();
chaviwaf87b3e2019-10-01 16:59:28 -07003242 mWindow1 = new FakeWindowHandle(application, mDispatcher, "Fake Window 1",
3243 ADISPLAY_ID_DEFAULT);
3244 // Adding FLAG_NOT_TOUCH_MODAL otherwise all taps will go to the top most window.
3245 // We also need FLAG_SPLIT_TOUCH or we won't be able to get touches for both windows.
Michael Wright44753b12020-07-08 13:48:11 +01003246 mWindow1->setFlags(InputWindowInfo::Flag::NOT_TOUCH_MODAL |
3247 InputWindowInfo::Flag::SPLIT_TOUCH);
chaviwaf87b3e2019-10-01 16:59:28 -07003248 mWindow1->setFrame(Rect(0, 0, 100, 100));
3249
3250 mWindow2 = new FakeWindowHandle(application, mDispatcher, "Fake Window 2",
3251 ADISPLAY_ID_DEFAULT, mWindow1->getToken());
Michael Wright44753b12020-07-08 13:48:11 +01003252 mWindow2->setFlags(InputWindowInfo::Flag::NOT_TOUCH_MODAL |
3253 InputWindowInfo::Flag::SPLIT_TOUCH);
chaviwaf87b3e2019-10-01 16:59:28 -07003254 mWindow2->setFrame(Rect(100, 100, 200, 200));
3255
Arthur Hung72d8dc32020-03-28 00:48:39 +00003256 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {mWindow1, mWindow2}}});
chaviwaf87b3e2019-10-01 16:59:28 -07003257 }
3258
3259protected:
3260 sp<FakeWindowHandle> mWindow1;
3261 sp<FakeWindowHandle> mWindow2;
3262
3263 // Helper function to convert the point from screen coordinates into the window's space
3264 static PointF getPointInWindow(const InputWindowInfo* windowInfo, const PointF& point) {
chaviw1ff3d1e2020-07-01 15:53:47 -07003265 vec2 vals = windowInfo->transform.transform(point.x, point.y);
3266 return {vals.x, vals.y};
chaviwaf87b3e2019-10-01 16:59:28 -07003267 }
3268
3269 void consumeMotionEvent(const sp<FakeWindowHandle>& window, int32_t expectedAction,
3270 const std::vector<PointF>& points) {
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +01003271 const std::string name = window->getName();
chaviwaf87b3e2019-10-01 16:59:28 -07003272 InputEvent* event = window->consume();
3273
3274 ASSERT_NE(nullptr, event) << name.c_str()
3275 << ": consumer should have returned non-NULL event.";
3276
3277 ASSERT_EQ(AINPUT_EVENT_TYPE_MOTION, event->getType())
3278 << name.c_str() << "expected " << inputEventTypeToString(AINPUT_EVENT_TYPE_MOTION)
3279 << " event, got " << inputEventTypeToString(event->getType()) << " event";
3280
3281 const MotionEvent& motionEvent = static_cast<const MotionEvent&>(*event);
3282 EXPECT_EQ(expectedAction, motionEvent.getAction());
3283
3284 for (size_t i = 0; i < points.size(); i++) {
3285 float expectedX = points[i].x;
3286 float expectedY = points[i].y;
3287
3288 EXPECT_EQ(expectedX, motionEvent.getX(i))
3289 << "expected " << expectedX << " for x[" << i << "] coord of " << name.c_str()
3290 << ", got " << motionEvent.getX(i);
3291 EXPECT_EQ(expectedY, motionEvent.getY(i))
3292 << "expected " << expectedY << " for y[" << i << "] coord of " << name.c_str()
3293 << ", got " << motionEvent.getY(i);
3294 }
3295 }
chaviw9eaa22c2020-07-01 16:21:27 -07003296
3297 void touchAndAssertPositions(int32_t action, std::vector<PointF> touchedPoints,
3298 std::vector<PointF> expectedPoints) {
3299 NotifyMotionArgs motionArgs = generateMotionArgs(action, AINPUT_SOURCE_TOUCHSCREEN,
3300 ADISPLAY_ID_DEFAULT, touchedPoints);
3301 mDispatcher->notifyMotion(&motionArgs);
3302
3303 // Always consume from window1 since it's the window that has the InputReceiver
3304 consumeMotionEvent(mWindow1, action, expectedPoints);
3305 }
chaviwaf87b3e2019-10-01 16:59:28 -07003306};
3307
3308TEST_F(InputDispatcherMultiWindowSameTokenTests, SingleTouchSameScale) {
3309 // Touch Window 1
3310 PointF touchedPoint = {10, 10};
3311 PointF expectedPoint = getPointInWindow(mWindow1->getInfo(), touchedPoint);
chaviw9eaa22c2020-07-01 16:21:27 -07003312 touchAndAssertPositions(AMOTION_EVENT_ACTION_DOWN, {touchedPoint}, {expectedPoint});
chaviwaf87b3e2019-10-01 16:59:28 -07003313
3314 // Release touch on Window 1
chaviw9eaa22c2020-07-01 16:21:27 -07003315 touchAndAssertPositions(AMOTION_EVENT_ACTION_UP, {touchedPoint}, {expectedPoint});
chaviwaf87b3e2019-10-01 16:59:28 -07003316
3317 // Touch Window 2
3318 touchedPoint = {150, 150};
3319 expectedPoint = getPointInWindow(mWindow2->getInfo(), touchedPoint);
chaviw9eaa22c2020-07-01 16:21:27 -07003320 touchAndAssertPositions(AMOTION_EVENT_ACTION_DOWN, {touchedPoint}, {expectedPoint});
chaviwaf87b3e2019-10-01 16:59:28 -07003321}
3322
chaviw9eaa22c2020-07-01 16:21:27 -07003323TEST_F(InputDispatcherMultiWindowSameTokenTests, SingleTouchDifferentTransform) {
3324 // Set scale value for window2
chaviwaf87b3e2019-10-01 16:59:28 -07003325 mWindow2->setWindowScale(0.5f, 0.5f);
3326
3327 // Touch Window 1
3328 PointF touchedPoint = {10, 10};
3329 PointF expectedPoint = getPointInWindow(mWindow1->getInfo(), touchedPoint);
chaviw9eaa22c2020-07-01 16:21:27 -07003330 touchAndAssertPositions(AMOTION_EVENT_ACTION_DOWN, {touchedPoint}, {expectedPoint});
chaviwaf87b3e2019-10-01 16:59:28 -07003331 // Release touch on Window 1
chaviw9eaa22c2020-07-01 16:21:27 -07003332 touchAndAssertPositions(AMOTION_EVENT_ACTION_UP, {touchedPoint}, {expectedPoint});
chaviwaf87b3e2019-10-01 16:59:28 -07003333
3334 // Touch Window 2
3335 touchedPoint = {150, 150};
3336 expectedPoint = getPointInWindow(mWindow2->getInfo(), touchedPoint);
chaviw9eaa22c2020-07-01 16:21:27 -07003337 touchAndAssertPositions(AMOTION_EVENT_ACTION_DOWN, {touchedPoint}, {expectedPoint});
3338 touchAndAssertPositions(AMOTION_EVENT_ACTION_UP, {touchedPoint}, {expectedPoint});
chaviwaf87b3e2019-10-01 16:59:28 -07003339
chaviw9eaa22c2020-07-01 16:21:27 -07003340 // Update the transform so rotation is set
3341 mWindow2->setWindowTransform(0, -1, 1, 0);
3342 expectedPoint = getPointInWindow(mWindow2->getInfo(), touchedPoint);
3343 touchAndAssertPositions(AMOTION_EVENT_ACTION_DOWN, {touchedPoint}, {expectedPoint});
chaviwaf87b3e2019-10-01 16:59:28 -07003344}
3345
chaviw9eaa22c2020-07-01 16:21:27 -07003346TEST_F(InputDispatcherMultiWindowSameTokenTests, MultipleTouchDifferentTransform) {
Chavi Weingarten65f98b82020-01-16 18:56:50 +00003347 mWindow2->setWindowScale(0.5f, 0.5f);
3348
3349 // Touch Window 1
3350 std::vector<PointF> touchedPoints = {PointF{10, 10}};
3351 std::vector<PointF> expectedPoints = {getPointInWindow(mWindow1->getInfo(), touchedPoints[0])};
chaviw9eaa22c2020-07-01 16:21:27 -07003352 touchAndAssertPositions(AMOTION_EVENT_ACTION_DOWN, touchedPoints, expectedPoints);
Chavi Weingarten65f98b82020-01-16 18:56:50 +00003353
3354 // Touch Window 2
3355 int32_t actionPointerDown =
3356 AMOTION_EVENT_ACTION_POINTER_DOWN + (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);
chaviw9eaa22c2020-07-01 16:21:27 -07003357 touchedPoints.push_back(PointF{150, 150});
3358 expectedPoints.push_back(getPointInWindow(mWindow2->getInfo(), touchedPoints[1]));
3359 touchAndAssertPositions(actionPointerDown, touchedPoints, expectedPoints);
Chavi Weingarten65f98b82020-01-16 18:56:50 +00003360
chaviw9eaa22c2020-07-01 16:21:27 -07003361 // Release Window 2
3362 int32_t actionPointerUp =
3363 AMOTION_EVENT_ACTION_POINTER_UP + (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);
3364 touchAndAssertPositions(actionPointerUp, touchedPoints, expectedPoints);
3365 expectedPoints.pop_back();
Chavi Weingarten65f98b82020-01-16 18:56:50 +00003366
chaviw9eaa22c2020-07-01 16:21:27 -07003367 // Update the transform so rotation is set for Window 2
3368 mWindow2->setWindowTransform(0, -1, 1, 0);
3369 expectedPoints.push_back(getPointInWindow(mWindow2->getInfo(), touchedPoints[1]));
3370 touchAndAssertPositions(actionPointerDown, touchedPoints, expectedPoints);
Chavi Weingarten65f98b82020-01-16 18:56:50 +00003371}
3372
chaviw9eaa22c2020-07-01 16:21:27 -07003373TEST_F(InputDispatcherMultiWindowSameTokenTests, MultipleTouchMoveDifferentTransform) {
Chavi Weingarten65f98b82020-01-16 18:56:50 +00003374 mWindow2->setWindowScale(0.5f, 0.5f);
3375
3376 // Touch Window 1
3377 std::vector<PointF> touchedPoints = {PointF{10, 10}};
3378 std::vector<PointF> expectedPoints = {getPointInWindow(mWindow1->getInfo(), touchedPoints[0])};
chaviw9eaa22c2020-07-01 16:21:27 -07003379 touchAndAssertPositions(AMOTION_EVENT_ACTION_DOWN, touchedPoints, expectedPoints);
Chavi Weingarten65f98b82020-01-16 18:56:50 +00003380
3381 // Touch Window 2
3382 int32_t actionPointerDown =
3383 AMOTION_EVENT_ACTION_POINTER_DOWN + (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);
chaviw9eaa22c2020-07-01 16:21:27 -07003384 touchedPoints.push_back(PointF{150, 150});
3385 expectedPoints.push_back(getPointInWindow(mWindow2->getInfo(), touchedPoints[1]));
Chavi Weingarten65f98b82020-01-16 18:56:50 +00003386
chaviw9eaa22c2020-07-01 16:21:27 -07003387 touchAndAssertPositions(actionPointerDown, touchedPoints, expectedPoints);
Chavi Weingarten65f98b82020-01-16 18:56:50 +00003388
3389 // Move both windows
3390 touchedPoints = {{20, 20}, {175, 175}};
3391 expectedPoints = {getPointInWindow(mWindow1->getInfo(), touchedPoints[0]),
3392 getPointInWindow(mWindow2->getInfo(), touchedPoints[1])};
3393
chaviw9eaa22c2020-07-01 16:21:27 -07003394 touchAndAssertPositions(AMOTION_EVENT_ACTION_MOVE, touchedPoints, expectedPoints);
Chavi Weingarten65f98b82020-01-16 18:56:50 +00003395
chaviw9eaa22c2020-07-01 16:21:27 -07003396 // Release Window 2
3397 int32_t actionPointerUp =
3398 AMOTION_EVENT_ACTION_POINTER_UP + (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);
3399 touchAndAssertPositions(actionPointerUp, touchedPoints, expectedPoints);
3400 expectedPoints.pop_back();
3401
3402 // Touch Window 2
3403 mWindow2->setWindowTransform(0, -1, 1, 0);
3404 expectedPoints.push_back(getPointInWindow(mWindow2->getInfo(), touchedPoints[1]));
3405 touchAndAssertPositions(actionPointerDown, touchedPoints, expectedPoints);
3406
3407 // Move both windows
3408 touchedPoints = {{20, 20}, {175, 175}};
3409 expectedPoints = {getPointInWindow(mWindow1->getInfo(), touchedPoints[0]),
3410 getPointInWindow(mWindow2->getInfo(), touchedPoints[1])};
3411
3412 touchAndAssertPositions(AMOTION_EVENT_ACTION_MOVE, touchedPoints, expectedPoints);
Chavi Weingarten65f98b82020-01-16 18:56:50 +00003413}
3414
3415TEST_F(InputDispatcherMultiWindowSameTokenTests, MultipleWindowsFirstTouchWithScale) {
3416 mWindow1->setWindowScale(0.5f, 0.5f);
3417
3418 // Touch Window 1
3419 std::vector<PointF> touchedPoints = {PointF{10, 10}};
3420 std::vector<PointF> expectedPoints = {getPointInWindow(mWindow1->getInfo(), touchedPoints[0])};
chaviw9eaa22c2020-07-01 16:21:27 -07003421 touchAndAssertPositions(AMOTION_EVENT_ACTION_DOWN, touchedPoints, expectedPoints);
Chavi Weingarten65f98b82020-01-16 18:56:50 +00003422
3423 // Touch Window 2
3424 int32_t actionPointerDown =
3425 AMOTION_EVENT_ACTION_POINTER_DOWN + (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);
chaviw9eaa22c2020-07-01 16:21:27 -07003426 touchedPoints.push_back(PointF{150, 150});
3427 expectedPoints.push_back(getPointInWindow(mWindow2->getInfo(), touchedPoints[1]));
Chavi Weingarten65f98b82020-01-16 18:56:50 +00003428
chaviw9eaa22c2020-07-01 16:21:27 -07003429 touchAndAssertPositions(actionPointerDown, touchedPoints, expectedPoints);
Chavi Weingarten65f98b82020-01-16 18:56:50 +00003430
3431 // Move both windows
3432 touchedPoints = {{20, 20}, {175, 175}};
3433 expectedPoints = {getPointInWindow(mWindow1->getInfo(), touchedPoints[0]),
3434 getPointInWindow(mWindow2->getInfo(), touchedPoints[1])};
3435
chaviw9eaa22c2020-07-01 16:21:27 -07003436 touchAndAssertPositions(AMOTION_EVENT_ACTION_MOVE, touchedPoints, expectedPoints);
Chavi Weingarten65f98b82020-01-16 18:56:50 +00003437}
3438
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07003439class InputDispatcherSingleWindowAnr : public InputDispatcherTest {
3440 virtual void SetUp() override {
3441 InputDispatcherTest::SetUp();
3442
Chris Yea209fde2020-07-22 13:54:51 -07003443 mApplication = std::make_shared<FakeApplicationHandle>();
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07003444 mApplication->setDispatchingTimeout(20ms);
3445 mWindow =
3446 new FakeWindowHandle(mApplication, mDispatcher, "TestWindow", ADISPLAY_ID_DEFAULT);
3447 mWindow->setFrame(Rect(0, 0, 30, 30));
Siarhei Vishniakoua7d36fd2020-06-30 19:32:39 -05003448 mWindow->setDispatchingTimeout(30ms);
Vishnu Nair47074b82020-08-14 11:54:47 -07003449 mWindow->setFocusable(true);
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07003450 // Adding FLAG_NOT_TOUCH_MODAL to ensure taps outside this window are not sent to this
3451 // window.
Michael Wright44753b12020-07-08 13:48:11 +01003452 mWindow->setFlags(InputWindowInfo::Flag::NOT_TOUCH_MODAL);
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07003453
3454 // Set focused application.
3455 mDispatcher->setFocusedApplication(ADISPLAY_ID_DEFAULT, mApplication);
3456
3457 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {mWindow}}});
Vishnu Nair958da932020-08-21 17:12:37 -07003458 setFocusedWindow(mWindow);
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07003459 mWindow->consumeFocusEvent(true);
3460 }
3461
3462 virtual void TearDown() override {
3463 InputDispatcherTest::TearDown();
3464 mWindow.clear();
3465 }
3466
3467protected:
Chris Yea209fde2020-07-22 13:54:51 -07003468 std::shared_ptr<FakeApplicationHandle> mApplication;
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07003469 sp<FakeWindowHandle> mWindow;
3470 static constexpr PointF WINDOW_LOCATION = {20, 20};
3471
3472 void tapOnWindow() {
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003473 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07003474 injectMotionDown(mDispatcher, AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT,
3475 WINDOW_LOCATION));
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003476 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07003477 injectMotionUp(mDispatcher, AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT,
3478 WINDOW_LOCATION));
3479 }
3480};
3481
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003482// Send a tap and respond, which should not cause an ANR.
3483TEST_F(InputDispatcherSingleWindowAnr, WhenTouchIsConsumed_NoAnr) {
3484 tapOnWindow();
3485 mWindow->consumeMotionDown();
3486 mWindow->consumeMotionUp();
3487 ASSERT_TRUE(mDispatcher->waitForIdle());
3488 mFakePolicy->assertNotifyAnrWasNotCalled();
3489}
3490
3491// Send a regular key and respond, which should not cause an ANR.
3492TEST_F(InputDispatcherSingleWindowAnr, WhenKeyIsConsumed_NoAnr) {
Prabir Pradhan93f342c2021-03-11 15:05:30 -08003493 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED, injectKeyDownNoRepeat(mDispatcher));
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003494 mWindow->consumeKeyDown(ADISPLAY_ID_NONE);
3495 ASSERT_TRUE(mDispatcher->waitForIdle());
3496 mFakePolicy->assertNotifyAnrWasNotCalled();
3497}
3498
Siarhei Vishniakoue41c4512020-09-08 19:35:58 -05003499TEST_F(InputDispatcherSingleWindowAnr, WhenFocusedApplicationChanges_NoAnr) {
3500 mWindow->setFocusable(false);
3501 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {mWindow}}});
3502 mWindow->consumeFocusEvent(false);
3503
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003504 InputEventInjectionResult result =
Siarhei Vishniakoue41c4512020-09-08 19:35:58 -05003505 injectKey(mDispatcher, AKEY_EVENT_ACTION_DOWN, 0 /*repeatCount*/, ADISPLAY_ID_DEFAULT,
Prabir Pradhan93f342c2021-03-11 15:05:30 -08003506 InputEventInjectionSync::NONE, 10ms /*injectionTimeout*/,
3507 false /* allowKeyRepeat */);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003508 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED, result);
Siarhei Vishniakoue41c4512020-09-08 19:35:58 -05003509 // Key will not go to window because we have no focused window.
3510 // The 'no focused window' ANR timer should start instead.
3511
3512 // Now, the focused application goes away.
3513 mDispatcher->setFocusedApplication(ADISPLAY_ID_DEFAULT, nullptr);
3514 // The key should get dropped and there should be no ANR.
3515
3516 ASSERT_TRUE(mDispatcher->waitForIdle());
3517 mFakePolicy->assertNotifyAnrWasNotCalled();
3518}
3519
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07003520// Send an event to the app and have the app not respond right away.
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003521// When ANR is raised, policy will tell the dispatcher to cancel the events for that window.
3522// So InputDispatcher will enqueue ACTION_CANCEL event as well.
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07003523TEST_F(InputDispatcherSingleWindowAnr, OnPointerDown_BasicAnr) {
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003524 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07003525 injectMotionDown(mDispatcher, AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT,
3526 WINDOW_LOCATION));
3527
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07003528 std::optional<uint32_t> sequenceNum = mWindow->receiveEvent(); // ACTION_DOWN
3529 ASSERT_TRUE(sequenceNum);
3530 const std::chrono::duration timeout = mWindow->getDispatchingTimeout(DISPATCHING_TIMEOUT);
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00003531 mFakePolicy->assertNotifyWindowUnresponsiveWasCalled(timeout, mWindow->getToken());
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003532
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003533 mWindow->finishEvent(*sequenceNum);
3534 mWindow->consumeEvent(AINPUT_EVENT_TYPE_MOTION, AMOTION_EVENT_ACTION_CANCEL,
3535 ADISPLAY_ID_DEFAULT, 0 /*flags*/);
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07003536 ASSERT_TRUE(mDispatcher->waitForIdle());
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00003537 mFakePolicy->assertNotifyWindowResponsiveWasCalled(mWindow->getToken());
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07003538}
3539
3540// Send a key to the app and have the app not respond right away.
3541TEST_F(InputDispatcherSingleWindowAnr, OnKeyDown_BasicAnr) {
3542 // Inject a key, and don't respond - expect that ANR is called.
Prabir Pradhan93f342c2021-03-11 15:05:30 -08003543 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED, injectKeyDownNoRepeat(mDispatcher));
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07003544 std::optional<uint32_t> sequenceNum = mWindow->receiveEvent();
3545 ASSERT_TRUE(sequenceNum);
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07003546 const std::chrono::duration timeout = mWindow->getDispatchingTimeout(DISPATCHING_TIMEOUT);
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00003547 mFakePolicy->assertNotifyWindowUnresponsiveWasCalled(timeout, mWindow->getToken());
Siarhei Vishniakou4cb50ca2020-05-26 21:43:02 -07003548 ASSERT_TRUE(mDispatcher->waitForIdle());
3549}
3550
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003551// We have a focused application, but no focused window
3552TEST_F(InputDispatcherSingleWindowAnr, FocusedApplication_NoFocusedWindow) {
Vishnu Nair47074b82020-08-14 11:54:47 -07003553 mWindow->setFocusable(false);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003554 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {mWindow}}});
3555 mWindow->consumeFocusEvent(false);
3556
3557 // taps on the window work as normal
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003558 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003559 injectMotionDown(mDispatcher, AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT,
3560 WINDOW_LOCATION));
3561 ASSERT_NO_FATAL_FAILURE(mWindow->consumeMotionDown());
3562 mDispatcher->waitForIdle();
3563 mFakePolicy->assertNotifyAnrWasNotCalled();
3564
3565 // Once a focused event arrives, we get an ANR for this application
3566 // We specify the injection timeout to be smaller than the application timeout, to ensure that
3567 // injection times out (instead of failing).
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003568 const InputEventInjectionResult result =
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003569 injectKey(mDispatcher, AKEY_EVENT_ACTION_DOWN, 0 /* repeatCount */, ADISPLAY_ID_DEFAULT,
Prabir Pradhan93f342c2021-03-11 15:05:30 -08003570 InputEventInjectionSync::WAIT_FOR_RESULT, 10ms, false /* allowKeyRepeat */);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003571 ASSERT_EQ(InputEventInjectionResult::TIMED_OUT, result);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003572 const std::chrono::duration timeout = mApplication->getDispatchingTimeout(DISPATCHING_TIMEOUT);
Siarhei Vishniakou234129c2020-10-22 22:28:12 -05003573 mFakePolicy->assertNotifyNoFocusedWindowAnrWasCalled(timeout, mApplication);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003574 ASSERT_TRUE(mDispatcher->waitForIdle());
3575}
3576
3577// We have a focused application, but no focused window
Siarhei Vishniakou234129c2020-10-22 22:28:12 -05003578// Make sure that we don't notify policy twice about the same ANR.
3579TEST_F(InputDispatcherSingleWindowAnr, NoFocusedWindow_DoesNotSendDuplicateAnr) {
Vishnu Nair47074b82020-08-14 11:54:47 -07003580 mWindow->setFocusable(false);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003581 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {mWindow}}});
3582 mWindow->consumeFocusEvent(false);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003583
3584 // Once a focused event arrives, we get an ANR for this application
3585 // We specify the injection timeout to be smaller than the application timeout, to ensure that
3586 // injection times out (instead of failing).
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003587 const InputEventInjectionResult result =
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003588 injectKey(mDispatcher, AKEY_EVENT_ACTION_DOWN, 0 /* repeatCount */, ADISPLAY_ID_DEFAULT,
Prabir Pradhan93f342c2021-03-11 15:05:30 -08003589 InputEventInjectionSync::WAIT_FOR_RESULT, 10ms, false /* allowKeyRepeat */);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003590 ASSERT_EQ(InputEventInjectionResult::TIMED_OUT, result);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003591 const std::chrono::duration appTimeout =
3592 mApplication->getDispatchingTimeout(DISPATCHING_TIMEOUT);
Siarhei Vishniakou234129c2020-10-22 22:28:12 -05003593 mFakePolicy->assertNotifyNoFocusedWindowAnrWasCalled(appTimeout, mApplication);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003594
Siarhei Vishniakou234129c2020-10-22 22:28:12 -05003595 std::this_thread::sleep_for(appTimeout);
3596 // ANR should not be raised again. It is up to policy to do that if it desires.
3597 mFakePolicy->assertNotifyAnrWasNotCalled();
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003598
Siarhei Vishniakou234129c2020-10-22 22:28:12 -05003599 // If we now get a focused window, the ANR should stop, but the policy handles that via
3600 // 'notifyFocusChanged' callback. This is implemented in the policy so we can't test it here.
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003601 ASSERT_TRUE(mDispatcher->waitForIdle());
3602}
3603
3604// We have a focused application, but no focused window
3605TEST_F(InputDispatcherSingleWindowAnr, NoFocusedWindow_DropsFocusedEvents) {
Vishnu Nair47074b82020-08-14 11:54:47 -07003606 mWindow->setFocusable(false);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003607 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {mWindow}}});
3608 mWindow->consumeFocusEvent(false);
3609
3610 // Once a focused event arrives, we get an ANR for this application
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003611 const InputEventInjectionResult result =
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003612 injectKey(mDispatcher, AKEY_EVENT_ACTION_DOWN, 0 /* repeatCount */, ADISPLAY_ID_DEFAULT,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003613 InputEventInjectionSync::WAIT_FOR_RESULT, 10ms);
3614 ASSERT_EQ(InputEventInjectionResult::TIMED_OUT, result);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003615
3616 const std::chrono::duration timeout = mApplication->getDispatchingTimeout(DISPATCHING_TIMEOUT);
Siarhei Vishniakou234129c2020-10-22 22:28:12 -05003617 mFakePolicy->assertNotifyNoFocusedWindowAnrWasCalled(timeout, mApplication);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003618
3619 // Future focused events get dropped right away
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003620 ASSERT_EQ(InputEventInjectionResult::FAILED, injectKeyDown(mDispatcher));
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003621 ASSERT_TRUE(mDispatcher->waitForIdle());
3622 mWindow->assertNoEvents();
3623}
3624
3625/**
3626 * Ensure that the implementation is valid. Since we are using multiset to keep track of the
3627 * ANR timeouts, we are allowing entries with identical timestamps in the same connection.
3628 * If we process 1 of the events, but ANR on the second event with the same timestamp,
3629 * the ANR mechanism should still work.
3630 *
3631 * In this test, we are injecting DOWN and UP events with the same timestamps, and acknowledging the
3632 * DOWN event, while not responding on the second one.
3633 */
3634TEST_F(InputDispatcherSingleWindowAnr, Anr_HandlesEventsWithIdenticalTimestamps) {
3635 nsecs_t currentTime = systemTime(SYSTEM_TIME_MONOTONIC);
3636 injectMotionEvent(mDispatcher, AMOTION_EVENT_ACTION_DOWN, AINPUT_SOURCE_TOUCHSCREEN,
3637 ADISPLAY_ID_DEFAULT, WINDOW_LOCATION,
3638 {AMOTION_EVENT_INVALID_CURSOR_POSITION,
3639 AMOTION_EVENT_INVALID_CURSOR_POSITION},
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003640 500ms, InputEventInjectionSync::WAIT_FOR_RESULT, currentTime);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003641
3642 // Now send ACTION_UP, with identical timestamp
3643 injectMotionEvent(mDispatcher, AMOTION_EVENT_ACTION_UP, AINPUT_SOURCE_TOUCHSCREEN,
3644 ADISPLAY_ID_DEFAULT, WINDOW_LOCATION,
3645 {AMOTION_EVENT_INVALID_CURSOR_POSITION,
3646 AMOTION_EVENT_INVALID_CURSOR_POSITION},
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003647 500ms, InputEventInjectionSync::WAIT_FOR_RESULT, currentTime);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003648
3649 // We have now sent down and up. Let's consume first event and then ANR on the second.
3650 mWindow->consumeMotionDown(ADISPLAY_ID_DEFAULT);
3651 const std::chrono::duration timeout = mWindow->getDispatchingTimeout(DISPATCHING_TIMEOUT);
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00003652 mFakePolicy->assertNotifyWindowUnresponsiveWasCalled(timeout, mWindow->getToken());
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003653}
3654
3655// If an app is not responding to a key event, gesture monitors should continue to receive
3656// new motion events
3657TEST_F(InputDispatcherSingleWindowAnr, GestureMonitors_ReceiveEventsDuringAppAnrOnKey) {
3658 FakeMonitorReceiver monitor =
3659 FakeMonitorReceiver(mDispatcher, "Gesture monitor", ADISPLAY_ID_DEFAULT,
3660 true /*isGestureMonitor*/);
3661
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003662 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
3663 injectKeyDown(mDispatcher, ADISPLAY_ID_DEFAULT));
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003664 mWindow->consumeKeyDown(ADISPLAY_ID_DEFAULT);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003665 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED, injectKeyUp(mDispatcher, ADISPLAY_ID_DEFAULT));
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003666
3667 // Stuck on the ACTION_UP
3668 const std::chrono::duration timeout = mWindow->getDispatchingTimeout(DISPATCHING_TIMEOUT);
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00003669 mFakePolicy->assertNotifyWindowUnresponsiveWasCalled(timeout, mWindow->getToken());
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003670
3671 // New tap will go to the gesture monitor, but not to the window
3672 tapOnWindow();
3673 monitor.consumeMotionDown(ADISPLAY_ID_DEFAULT);
3674 monitor.consumeMotionUp(ADISPLAY_ID_DEFAULT);
3675
3676 mWindow->consumeKeyUp(ADISPLAY_ID_DEFAULT); // still the previous motion
3677 mDispatcher->waitForIdle();
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00003678 mFakePolicy->assertNotifyWindowResponsiveWasCalled(mWindow->getToken());
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003679 mWindow->assertNoEvents();
3680 monitor.assertNoEvents();
3681}
3682
3683// If an app is not responding to a motion event, gesture monitors should continue to receive
3684// new motion events
3685TEST_F(InputDispatcherSingleWindowAnr, GestureMonitors_ReceiveEventsDuringAppAnrOnMotion) {
3686 FakeMonitorReceiver monitor =
3687 FakeMonitorReceiver(mDispatcher, "Gesture monitor", ADISPLAY_ID_DEFAULT,
3688 true /*isGestureMonitor*/);
3689
3690 tapOnWindow();
3691 monitor.consumeMotionDown(ADISPLAY_ID_DEFAULT);
3692 monitor.consumeMotionUp(ADISPLAY_ID_DEFAULT);
3693
3694 mWindow->consumeMotionDown();
3695 // Stuck on the ACTION_UP
3696 const std::chrono::duration timeout = mWindow->getDispatchingTimeout(DISPATCHING_TIMEOUT);
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00003697 mFakePolicy->assertNotifyWindowUnresponsiveWasCalled(timeout, mWindow->getToken());
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003698
3699 // New tap will go to the gesture monitor, but not to the window
3700 tapOnWindow();
3701 monitor.consumeMotionDown(ADISPLAY_ID_DEFAULT);
3702 monitor.consumeMotionUp(ADISPLAY_ID_DEFAULT);
3703
3704 mWindow->consumeMotionUp(ADISPLAY_ID_DEFAULT); // still the previous motion
3705 mDispatcher->waitForIdle();
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00003706 mFakePolicy->assertNotifyWindowResponsiveWasCalled(mWindow->getToken());
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003707 mWindow->assertNoEvents();
3708 monitor.assertNoEvents();
3709}
3710
3711// If a window is unresponsive, then you get anr. if the window later catches up and starts to
3712// process events, you don't get an anr. When the window later becomes unresponsive again, you
3713// get an ANR again.
3714// 1. tap -> block on ACTION_UP -> receive ANR
3715// 2. consume all pending events (= queue becomes healthy again)
3716// 3. tap again -> block on ACTION_UP again -> receive ANR second time
3717TEST_F(InputDispatcherSingleWindowAnr, SameWindow_CanReceiveAnrTwice) {
3718 tapOnWindow();
3719
3720 mWindow->consumeMotionDown();
3721 // Block on ACTION_UP
3722 const std::chrono::duration timeout = mWindow->getDispatchingTimeout(DISPATCHING_TIMEOUT);
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00003723 mFakePolicy->assertNotifyWindowUnresponsiveWasCalled(timeout, mWindow->getToken());
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003724 mWindow->consumeMotionUp(); // Now the connection should be healthy again
3725 mDispatcher->waitForIdle();
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00003726 mFakePolicy->assertNotifyWindowResponsiveWasCalled(mWindow->getToken());
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003727 mWindow->assertNoEvents();
3728
3729 tapOnWindow();
3730 mWindow->consumeMotionDown();
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00003731 mFakePolicy->assertNotifyWindowUnresponsiveWasCalled(timeout, mWindow->getToken());
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003732 mWindow->consumeMotionUp();
3733
3734 mDispatcher->waitForIdle();
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00003735 mFakePolicy->assertNotifyWindowResponsiveWasCalled(mWindow->getToken());
Siarhei Vishniakou234129c2020-10-22 22:28:12 -05003736 mFakePolicy->assertNotifyAnrWasNotCalled();
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003737 mWindow->assertNoEvents();
3738}
3739
Siarhei Vishniakou234129c2020-10-22 22:28:12 -05003740// If a connection remains unresponsive for a while, make sure policy is only notified once about
3741// it.
3742TEST_F(InputDispatcherSingleWindowAnr, Policy_DoesNotGetDuplicateAnr) {
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003743 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003744 injectMotionDown(mDispatcher, AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT,
3745 WINDOW_LOCATION));
3746
3747 const std::chrono::duration windowTimeout = mWindow->getDispatchingTimeout(DISPATCHING_TIMEOUT);
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00003748 mFakePolicy->assertNotifyWindowUnresponsiveWasCalled(windowTimeout, mWindow->getToken());
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003749 std::this_thread::sleep_for(windowTimeout);
Siarhei Vishniakou234129c2020-10-22 22:28:12 -05003750 // 'notifyConnectionUnresponsive' should only be called once per connection
3751 mFakePolicy->assertNotifyAnrWasNotCalled();
3752 // When the ANR happened, dispatcher should abort the current event stream via ACTION_CANCEL
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003753 mWindow->consumeMotionDown();
3754 mWindow->consumeEvent(AINPUT_EVENT_TYPE_MOTION, AMOTION_EVENT_ACTION_CANCEL,
3755 ADISPLAY_ID_DEFAULT, 0 /*flags*/);
3756 mWindow->assertNoEvents();
Siarhei Vishniakou234129c2020-10-22 22:28:12 -05003757 mDispatcher->waitForIdle();
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00003758 mFakePolicy->assertNotifyWindowResponsiveWasCalled(mWindow->getToken());
Siarhei Vishniakou234129c2020-10-22 22:28:12 -05003759 mFakePolicy->assertNotifyAnrWasNotCalled();
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003760}
3761
3762/**
3763 * If a window is processing a motion event, and then a key event comes in, the key event should
3764 * not to to the focused window until the motion is processed.
3765 *
3766 * Warning!!!
3767 * This test depends on the value of android::inputdispatcher::KEY_WAITING_FOR_MOTION_TIMEOUT
3768 * and the injection timeout that we specify when injecting the key.
3769 * We must have the injection timeout (10ms) be smaller than
3770 * KEY_WAITING_FOR_MOTION_TIMEOUT (currently 500ms).
3771 *
3772 * If that value changes, this test should also change.
3773 */
3774TEST_F(InputDispatcherSingleWindowAnr, Key_StaysPendingWhileMotionIsProcessed) {
3775 mWindow->setDispatchingTimeout(2s); // Set a long ANR timeout to prevent it from triggering
3776 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {mWindow}}});
3777
3778 tapOnWindow();
3779 std::optional<uint32_t> downSequenceNum = mWindow->receiveEvent();
3780 ASSERT_TRUE(downSequenceNum);
3781 std::optional<uint32_t> upSequenceNum = mWindow->receiveEvent();
3782 ASSERT_TRUE(upSequenceNum);
3783 // Don't finish the events yet, and send a key
3784 // Injection will "succeed" because we will eventually give up and send the key to the focused
3785 // window even if motions are still being processed. But because the injection timeout is short,
3786 // we will receive INJECTION_TIMED_OUT as the result.
3787
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003788 InputEventInjectionResult result =
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003789 injectKey(mDispatcher, AKEY_EVENT_ACTION_DOWN, 0 /* repeatCount */, ADISPLAY_ID_DEFAULT,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003790 InputEventInjectionSync::WAIT_FOR_RESULT, 10ms);
3791 ASSERT_EQ(InputEventInjectionResult::TIMED_OUT, result);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003792 // Key will not be sent to the window, yet, because the window is still processing events
3793 // and the key remains pending, waiting for the touch events to be processed
3794 std::optional<uint32_t> keySequenceNum = mWindow->receiveEvent();
3795 ASSERT_FALSE(keySequenceNum);
3796
3797 std::this_thread::sleep_for(500ms);
3798 // if we wait long enough though, dispatcher will give up, and still send the key
3799 // to the focused window, even though we have not yet finished the motion event
3800 mWindow->consumeKeyDown(ADISPLAY_ID_DEFAULT);
3801 mWindow->finishEvent(*downSequenceNum);
3802 mWindow->finishEvent(*upSequenceNum);
3803}
3804
3805/**
3806 * If a window is processing a motion event, and then a key event comes in, the key event should
3807 * not go to the focused window until the motion is processed.
3808 * If then a new motion comes in, then the pending key event should be going to the currently
3809 * focused window right away.
3810 */
3811TEST_F(InputDispatcherSingleWindowAnr,
3812 PendingKey_IsDroppedWhileMotionIsProcessedAndNewTouchComesIn) {
3813 mWindow->setDispatchingTimeout(2s); // Set a long ANR timeout to prevent it from triggering
3814 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {mWindow}}});
3815
3816 tapOnWindow();
3817 std::optional<uint32_t> downSequenceNum = mWindow->receiveEvent();
3818 ASSERT_TRUE(downSequenceNum);
3819 std::optional<uint32_t> upSequenceNum = mWindow->receiveEvent();
3820 ASSERT_TRUE(upSequenceNum);
3821 // Don't finish the events yet, and send a key
3822 // Injection is async, so it will succeed
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003823 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003824 injectKey(mDispatcher, AKEY_EVENT_ACTION_DOWN, 0 /* repeatCount */,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003825 ADISPLAY_ID_DEFAULT, InputEventInjectionSync::NONE));
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003826 // At this point, key is still pending, and should not be sent to the application yet.
3827 std::optional<uint32_t> keySequenceNum = mWindow->receiveEvent();
3828 ASSERT_FALSE(keySequenceNum);
3829
3830 // Now tap down again. It should cause the pending key to go to the focused window right away.
3831 tapOnWindow();
3832 mWindow->consumeKeyDown(ADISPLAY_ID_DEFAULT); // it doesn't matter that we haven't ack'd
3833 // the other events yet. We can finish events in any order.
3834 mWindow->finishEvent(*downSequenceNum); // first tap's ACTION_DOWN
3835 mWindow->finishEvent(*upSequenceNum); // first tap's ACTION_UP
3836 mWindow->consumeMotionDown();
3837 mWindow->consumeMotionUp();
3838 mWindow->assertNoEvents();
3839}
3840
3841class InputDispatcherMultiWindowAnr : public InputDispatcherTest {
3842 virtual void SetUp() override {
3843 InputDispatcherTest::SetUp();
3844
Chris Yea209fde2020-07-22 13:54:51 -07003845 mApplication = std::make_shared<FakeApplicationHandle>();
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003846 mApplication->setDispatchingTimeout(10ms);
3847 mUnfocusedWindow =
3848 new FakeWindowHandle(mApplication, mDispatcher, "Unfocused", ADISPLAY_ID_DEFAULT);
3849 mUnfocusedWindow->setFrame(Rect(0, 0, 30, 30));
3850 // Adding FLAG_NOT_TOUCH_MODAL to ensure taps outside this window are not sent to this
3851 // window.
3852 // Adding FLAG_WATCH_OUTSIDE_TOUCH to receive ACTION_OUTSIDE when another window is tapped
Michael Wright44753b12020-07-08 13:48:11 +01003853 mUnfocusedWindow->setFlags(InputWindowInfo::Flag::NOT_TOUCH_MODAL |
3854 InputWindowInfo::Flag::WATCH_OUTSIDE_TOUCH |
3855 InputWindowInfo::Flag::SPLIT_TOUCH);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003856
3857 mFocusedWindow =
3858 new FakeWindowHandle(mApplication, mDispatcher, "Focused", ADISPLAY_ID_DEFAULT);
Siarhei Vishniakoua7d36fd2020-06-30 19:32:39 -05003859 mFocusedWindow->setDispatchingTimeout(30ms);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003860 mFocusedWindow->setFrame(Rect(50, 50, 100, 100));
Michael Wright44753b12020-07-08 13:48:11 +01003861 mFocusedWindow->setFlags(InputWindowInfo::Flag::NOT_TOUCH_MODAL |
3862 InputWindowInfo::Flag::SPLIT_TOUCH);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003863
3864 // Set focused application.
3865 mDispatcher->setFocusedApplication(ADISPLAY_ID_DEFAULT, mApplication);
Vishnu Nair47074b82020-08-14 11:54:47 -07003866 mFocusedWindow->setFocusable(true);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003867
3868 // Expect one focus window exist in display.
3869 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {mUnfocusedWindow, mFocusedWindow}}});
Vishnu Nair958da932020-08-21 17:12:37 -07003870 setFocusedWindow(mFocusedWindow);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003871 mFocusedWindow->consumeFocusEvent(true);
3872 }
3873
3874 virtual void TearDown() override {
3875 InputDispatcherTest::TearDown();
3876
3877 mUnfocusedWindow.clear();
3878 mFocusedWindow.clear();
3879 }
3880
3881protected:
Chris Yea209fde2020-07-22 13:54:51 -07003882 std::shared_ptr<FakeApplicationHandle> mApplication;
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003883 sp<FakeWindowHandle> mUnfocusedWindow;
3884 sp<FakeWindowHandle> mFocusedWindow;
3885 static constexpr PointF UNFOCUSED_WINDOW_LOCATION = {20, 20};
3886 static constexpr PointF FOCUSED_WINDOW_LOCATION = {75, 75};
3887 static constexpr PointF LOCATION_OUTSIDE_ALL_WINDOWS = {40, 40};
3888
3889 void tapOnFocusedWindow() { tap(FOCUSED_WINDOW_LOCATION); }
3890
3891 void tapOnUnfocusedWindow() { tap(UNFOCUSED_WINDOW_LOCATION); }
3892
3893private:
3894 void tap(const PointF& location) {
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003895 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003896 injectMotionDown(mDispatcher, AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT,
3897 location));
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003898 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003899 injectMotionUp(mDispatcher, AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT,
3900 location));
3901 }
3902};
3903
3904// If we have 2 windows that are both unresponsive, the one with the shortest timeout
3905// should be ANR'd first.
3906TEST_F(InputDispatcherMultiWindowAnr, TwoWindows_BothUnresponsive) {
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003907 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003908 injectMotionDown(mDispatcher, AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT,
3909 FOCUSED_WINDOW_LOCATION))
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003910 << "Inject motion event should return InputEventInjectionResult::SUCCEEDED";
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003911 mFocusedWindow->consumeMotionDown();
3912 mUnfocusedWindow->consumeEvent(AINPUT_EVENT_TYPE_MOTION, AMOTION_EVENT_ACTION_OUTSIDE,
3913 ADISPLAY_ID_DEFAULT, 0 /*flags*/);
3914 // We consumed all events, so no ANR
3915 ASSERT_TRUE(mDispatcher->waitForIdle());
3916 mFakePolicy->assertNotifyAnrWasNotCalled();
3917
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003918 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003919 injectMotionDown(mDispatcher, AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT,
3920 FOCUSED_WINDOW_LOCATION));
3921 std::optional<uint32_t> unfocusedSequenceNum = mUnfocusedWindow->receiveEvent();
3922 ASSERT_TRUE(unfocusedSequenceNum);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003923
3924 const std::chrono::duration timeout =
3925 mFocusedWindow->getDispatchingTimeout(DISPATCHING_TIMEOUT);
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00003926 mFakePolicy->assertNotifyWindowUnresponsiveWasCalled(timeout, mFocusedWindow->getToken());
Siarhei Vishniakou234129c2020-10-22 22:28:12 -05003927 // Because we injected two DOWN events in a row, CANCEL is enqueued for the first event
3928 // sequence to make it consistent
3929 mFocusedWindow->consumeMotionCancel();
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003930 mUnfocusedWindow->finishEvent(*unfocusedSequenceNum);
Siarhei Vishniakou234129c2020-10-22 22:28:12 -05003931 mFocusedWindow->consumeMotionDown();
3932 // This cancel is generated because the connection was unresponsive
3933 mFocusedWindow->consumeMotionCancel();
3934 mFocusedWindow->assertNoEvents();
3935 mUnfocusedWindow->assertNoEvents();
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003936 ASSERT_TRUE(mDispatcher->waitForIdle());
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00003937 mFakePolicy->assertNotifyWindowResponsiveWasCalled(mFocusedWindow->getToken());
Siarhei Vishniakou234129c2020-10-22 22:28:12 -05003938 mFakePolicy->assertNotifyAnrWasNotCalled();
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003939}
3940
3941// If we have 2 windows with identical timeouts that are both unresponsive,
3942// it doesn't matter which order they should have ANR.
3943// But we should receive ANR for both.
3944TEST_F(InputDispatcherMultiWindowAnr, TwoWindows_BothUnresponsiveWithSameTimeout) {
3945 // Set the timeout for unfocused window to match the focused window
3946 mUnfocusedWindow->setDispatchingTimeout(10ms);
3947 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {mUnfocusedWindow, mFocusedWindow}}});
3948
3949 tapOnFocusedWindow();
3950 // we should have ACTION_DOWN/ACTION_UP on focused window and ACTION_OUTSIDE on unfocused window
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00003951 sp<IBinder> anrConnectionToken1 = mFakePolicy->getUnresponsiveWindowToken(10ms);
3952 sp<IBinder> anrConnectionToken2 = mFakePolicy->getUnresponsiveWindowToken(0ms);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003953
3954 // We don't know which window will ANR first. But both of them should happen eventually.
Siarhei Vishniakou234129c2020-10-22 22:28:12 -05003955 ASSERT_TRUE(mFocusedWindow->getToken() == anrConnectionToken1 ||
3956 mFocusedWindow->getToken() == anrConnectionToken2);
3957 ASSERT_TRUE(mUnfocusedWindow->getToken() == anrConnectionToken1 ||
3958 mUnfocusedWindow->getToken() == anrConnectionToken2);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003959
3960 ASSERT_TRUE(mDispatcher->waitForIdle());
3961 mFakePolicy->assertNotifyAnrWasNotCalled();
Siarhei Vishniakou234129c2020-10-22 22:28:12 -05003962
3963 mFocusedWindow->consumeMotionDown();
3964 mFocusedWindow->consumeMotionUp();
3965 mUnfocusedWindow->consumeMotionOutside();
3966
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00003967 sp<IBinder> responsiveToken1 = mFakePolicy->getResponsiveWindowToken();
3968 sp<IBinder> responsiveToken2 = mFakePolicy->getResponsiveWindowToken();
Siarhei Vishniakou234129c2020-10-22 22:28:12 -05003969
3970 // Both applications should be marked as responsive, in any order
3971 ASSERT_TRUE(mFocusedWindow->getToken() == responsiveToken1 ||
3972 mFocusedWindow->getToken() == responsiveToken2);
3973 ASSERT_TRUE(mUnfocusedWindow->getToken() == responsiveToken1 ||
3974 mUnfocusedWindow->getToken() == responsiveToken2);
3975 mFakePolicy->assertNotifyAnrWasNotCalled();
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003976}
3977
3978// If a window is already not responding, the second tap on the same window should be ignored.
3979// We should also log an error to account for the dropped event (not tested here).
3980// At the same time, FLAG_WATCH_OUTSIDE_TOUCH targets should not receive any events.
3981TEST_F(InputDispatcherMultiWindowAnr, DuringAnr_SecondTapIsIgnored) {
3982 tapOnFocusedWindow();
3983 mUnfocusedWindow->consumeEvent(AINPUT_EVENT_TYPE_MOTION, AMOTION_EVENT_ACTION_OUTSIDE,
3984 ADISPLAY_ID_DEFAULT, 0 /*flags*/);
3985 // Receive the events, but don't respond
3986 std::optional<uint32_t> downEventSequenceNum = mFocusedWindow->receiveEvent(); // ACTION_DOWN
3987 ASSERT_TRUE(downEventSequenceNum);
3988 std::optional<uint32_t> upEventSequenceNum = mFocusedWindow->receiveEvent(); // ACTION_UP
3989 ASSERT_TRUE(upEventSequenceNum);
3990 const std::chrono::duration timeout =
3991 mFocusedWindow->getDispatchingTimeout(DISPATCHING_TIMEOUT);
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00003992 mFakePolicy->assertNotifyWindowUnresponsiveWasCalled(timeout, mFocusedWindow->getToken());
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003993
3994 // Tap once again
3995 // We cannot use "tapOnFocusedWindow" because it asserts the injection result to be success
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003996 ASSERT_EQ(InputEventInjectionResult::FAILED,
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07003997 injectMotionDown(mDispatcher, AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT,
3998 FOCUSED_WINDOW_LOCATION));
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08003999 ASSERT_EQ(InputEventInjectionResult::FAILED,
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07004000 injectMotionUp(mDispatcher, AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT,
4001 FOCUSED_WINDOW_LOCATION));
4002 // Unfocused window does not receive ACTION_OUTSIDE because the tapped window is not a
4003 // valid touch target
4004 mUnfocusedWindow->assertNoEvents();
4005
4006 // Consume the first tap
4007 mFocusedWindow->finishEvent(*downEventSequenceNum);
4008 mFocusedWindow->finishEvent(*upEventSequenceNum);
4009 ASSERT_TRUE(mDispatcher->waitForIdle());
4010 // The second tap did not go to the focused window
4011 mFocusedWindow->assertNoEvents();
Siarhei Vishniakou234129c2020-10-22 22:28:12 -05004012 // Since all events are finished, connection should be deemed healthy again
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00004013 mFakePolicy->assertNotifyWindowResponsiveWasCalled(mFocusedWindow->getToken());
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07004014 mFakePolicy->assertNotifyAnrWasNotCalled();
4015}
4016
4017// If you tap outside of all windows, there will not be ANR
4018TEST_F(InputDispatcherMultiWindowAnr, TapOutsideAllWindows_DoesNotAnr) {
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004019 ASSERT_EQ(InputEventInjectionResult::FAILED,
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07004020 injectMotionDown(mDispatcher, AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT,
4021 LOCATION_OUTSIDE_ALL_WINDOWS));
4022 ASSERT_TRUE(mDispatcher->waitForIdle());
4023 mFakePolicy->assertNotifyAnrWasNotCalled();
4024}
4025
4026// Since the focused window is paused, tapping on it should not produce any events
4027TEST_F(InputDispatcherMultiWindowAnr, Window_CanBePaused) {
4028 mFocusedWindow->setPaused(true);
4029 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {mUnfocusedWindow, mFocusedWindow}}});
4030
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004031 ASSERT_EQ(InputEventInjectionResult::FAILED,
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07004032 injectMotionDown(mDispatcher, AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT,
4033 FOCUSED_WINDOW_LOCATION));
4034
4035 std::this_thread::sleep_for(mFocusedWindow->getDispatchingTimeout(DISPATCHING_TIMEOUT));
4036 ASSERT_TRUE(mDispatcher->waitForIdle());
4037 // Should not ANR because the window is paused, and touches shouldn't go to it
4038 mFakePolicy->assertNotifyAnrWasNotCalled();
4039
4040 mFocusedWindow->assertNoEvents();
4041 mUnfocusedWindow->assertNoEvents();
4042}
4043
4044/**
4045 * If a window is processing a motion event, and then a key event comes in, the key event should
4046 * not to to the focused window until the motion is processed.
4047 * If a different window becomes focused at this time, the key should go to that window instead.
4048 *
4049 * Warning!!!
4050 * This test depends on the value of android::inputdispatcher::KEY_WAITING_FOR_MOTION_TIMEOUT
4051 * and the injection timeout that we specify when injecting the key.
4052 * We must have the injection timeout (10ms) be smaller than
4053 * KEY_WAITING_FOR_MOTION_TIMEOUT (currently 500ms).
4054 *
4055 * If that value changes, this test should also change.
4056 */
4057TEST_F(InputDispatcherMultiWindowAnr, PendingKey_GoesToNewlyFocusedWindow) {
4058 // Set a long ANR timeout to prevent it from triggering
4059 mFocusedWindow->setDispatchingTimeout(2s);
4060 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {mFocusedWindow, mUnfocusedWindow}}});
4061
4062 tapOnUnfocusedWindow();
4063 std::optional<uint32_t> downSequenceNum = mUnfocusedWindow->receiveEvent();
4064 ASSERT_TRUE(downSequenceNum);
4065 std::optional<uint32_t> upSequenceNum = mUnfocusedWindow->receiveEvent();
4066 ASSERT_TRUE(upSequenceNum);
4067 // Don't finish the events yet, and send a key
4068 // Injection will succeed because we will eventually give up and send the key to the focused
4069 // window even if motions are still being processed.
4070
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004071 InputEventInjectionResult result =
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07004072 injectKey(mDispatcher, AKEY_EVENT_ACTION_DOWN, 0 /*repeatCount*/, ADISPLAY_ID_DEFAULT,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004073 InputEventInjectionSync::NONE, 10ms /*injectionTimeout*/);
4074 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED, result);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07004075 // Key will not be sent to the window, yet, because the window is still processing events
4076 // and the key remains pending, waiting for the touch events to be processed
4077 std::optional<uint32_t> keySequenceNum = mFocusedWindow->receiveEvent();
4078 ASSERT_FALSE(keySequenceNum);
4079
4080 // Switch the focus to the "unfocused" window that we tapped. Expect the key to go there
Vishnu Nair47074b82020-08-14 11:54:47 -07004081 mFocusedWindow->setFocusable(false);
4082 mUnfocusedWindow->setFocusable(true);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07004083 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {mFocusedWindow, mUnfocusedWindow}}});
Vishnu Nair958da932020-08-21 17:12:37 -07004084 setFocusedWindow(mUnfocusedWindow);
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07004085
4086 // Focus events should precede the key events
4087 mUnfocusedWindow->consumeFocusEvent(true);
4088 mFocusedWindow->consumeFocusEvent(false);
4089
4090 // Finish the tap events, which should unblock dispatcher
4091 mUnfocusedWindow->finishEvent(*downSequenceNum);
4092 mUnfocusedWindow->finishEvent(*upSequenceNum);
4093
4094 // Now that all queues are cleared and no backlog in the connections, the key event
4095 // can finally go to the newly focused "mUnfocusedWindow".
4096 mUnfocusedWindow->consumeKeyDown(ADISPLAY_ID_DEFAULT);
4097 mFocusedWindow->assertNoEvents();
4098 mUnfocusedWindow->assertNoEvents();
Siarhei Vishniakou234129c2020-10-22 22:28:12 -05004099 mFakePolicy->assertNotifyAnrWasNotCalled();
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07004100}
4101
4102// When the touch stream is split across 2 windows, and one of them does not respond,
4103// then ANR should be raised and the touch should be canceled for the unresponsive window.
4104// The other window should not be affected by that.
4105TEST_F(InputDispatcherMultiWindowAnr, SplitTouch_SingleWindowAnr) {
4106 // Touch Window 1
4107 NotifyMotionArgs motionArgs =
4108 generateMotionArgs(AMOTION_EVENT_ACTION_DOWN, AINPUT_SOURCE_TOUCHSCREEN,
4109 ADISPLAY_ID_DEFAULT, {FOCUSED_WINDOW_LOCATION});
4110 mDispatcher->notifyMotion(&motionArgs);
4111 mUnfocusedWindow->consumeEvent(AINPUT_EVENT_TYPE_MOTION, AMOTION_EVENT_ACTION_OUTSIDE,
4112 ADISPLAY_ID_DEFAULT, 0 /*flags*/);
4113
4114 // Touch Window 2
4115 int32_t actionPointerDown =
4116 AMOTION_EVENT_ACTION_POINTER_DOWN + (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);
4117
4118 motionArgs =
4119 generateMotionArgs(actionPointerDown, AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT,
4120 {FOCUSED_WINDOW_LOCATION, UNFOCUSED_WINDOW_LOCATION});
4121 mDispatcher->notifyMotion(&motionArgs);
4122
4123 const std::chrono::duration timeout =
4124 mFocusedWindow->getDispatchingTimeout(DISPATCHING_TIMEOUT);
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00004125 mFakePolicy->assertNotifyWindowUnresponsiveWasCalled(timeout, mFocusedWindow->getToken());
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07004126
4127 mUnfocusedWindow->consumeMotionDown();
4128 mFocusedWindow->consumeMotionDown();
4129 // Focused window may or may not receive ACTION_MOVE
4130 // But it should definitely receive ACTION_CANCEL due to the ANR
4131 InputEvent* event;
4132 std::optional<int32_t> moveOrCancelSequenceNum = mFocusedWindow->receiveEvent(&event);
4133 ASSERT_TRUE(moveOrCancelSequenceNum);
4134 mFocusedWindow->finishEvent(*moveOrCancelSequenceNum);
4135 ASSERT_NE(nullptr, event);
4136 ASSERT_EQ(event->getType(), AINPUT_EVENT_TYPE_MOTION);
4137 MotionEvent& motionEvent = static_cast<MotionEvent&>(*event);
4138 if (motionEvent.getAction() == AMOTION_EVENT_ACTION_MOVE) {
4139 mFocusedWindow->consumeMotionCancel();
4140 } else {
4141 ASSERT_EQ(AMOTION_EVENT_ACTION_CANCEL, motionEvent.getAction());
4142 }
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07004143 ASSERT_TRUE(mDispatcher->waitForIdle());
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +00004144 mFakePolicy->assertNotifyWindowResponsiveWasCalled(mFocusedWindow->getToken());
Siarhei Vishniakou234129c2020-10-22 22:28:12 -05004145
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07004146 mUnfocusedWindow->assertNoEvents();
4147 mFocusedWindow->assertNoEvents();
Siarhei Vishniakou234129c2020-10-22 22:28:12 -05004148 mFakePolicy->assertNotifyAnrWasNotCalled();
Siarhei Vishniakoud44dddf2020-03-25 16:16:40 -07004149}
4150
Siarhei Vishniakouf56b2692020-09-08 19:43:33 -05004151/**
4152 * If we have no focused window, and a key comes in, we start the ANR timer.
4153 * The focused application should add a focused window before the timer runs out to prevent ANR.
4154 *
4155 * If the user touches another application during this time, the key should be dropped.
4156 * Next, if a new focused window comes in, without toggling the focused application,
4157 * then no ANR should occur.
4158 *
4159 * Normally, we would expect the new focused window to be accompanied by 'setFocusedApplication',
4160 * but in some cases the policy may not update the focused application.
4161 */
4162TEST_F(InputDispatcherMultiWindowAnr, FocusedWindowWithoutSetFocusedApplication_NoAnr) {
4163 std::shared_ptr<FakeApplicationHandle> focusedApplication =
4164 std::make_shared<FakeApplicationHandle>();
4165 focusedApplication->setDispatchingTimeout(60ms);
4166 mDispatcher->setFocusedApplication(ADISPLAY_ID_DEFAULT, focusedApplication);
4167 // The application that owns 'mFocusedWindow' and 'mUnfocusedWindow' is not focused.
4168 mFocusedWindow->setFocusable(false);
4169
4170 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {mFocusedWindow, mUnfocusedWindow}}});
4171 mFocusedWindow->consumeFocusEvent(false);
4172
4173 // Send a key. The ANR timer should start because there is no focused window.
4174 // 'focusedApplication' will get blamed if this timer completes.
4175 // Key will not be sent anywhere because we have no focused window. It will remain pending.
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004176 InputEventInjectionResult result =
Siarhei Vishniakouf56b2692020-09-08 19:43:33 -05004177 injectKey(mDispatcher, AKEY_EVENT_ACTION_DOWN, 0 /*repeatCount*/, ADISPLAY_ID_DEFAULT,
Prabir Pradhan93f342c2021-03-11 15:05:30 -08004178 InputEventInjectionSync::NONE, 10ms /*injectionTimeout*/,
4179 false /* allowKeyRepeat */);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004180 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED, result);
Siarhei Vishniakouf56b2692020-09-08 19:43:33 -05004181
4182 // Wait until dispatcher starts the "no focused window" timer. If we don't wait here,
4183 // then the injected touches won't cause the focused event to get dropped.
4184 // The dispatcher only checks for whether the queue should be pruned upon queueing.
4185 // If we inject the touch right away and the ANR timer hasn't started, the touch event would
4186 // simply be added to the queue without 'shouldPruneInboundQueueLocked' returning 'true'.
4187 // For this test, it means that the key would get delivered to the window once it becomes
4188 // focused.
4189 std::this_thread::sleep_for(10ms);
4190
4191 // Touch unfocused window. This should force the pending key to get dropped.
4192 NotifyMotionArgs motionArgs =
4193 generateMotionArgs(AMOTION_EVENT_ACTION_DOWN, AINPUT_SOURCE_TOUCHSCREEN,
4194 ADISPLAY_ID_DEFAULT, {UNFOCUSED_WINDOW_LOCATION});
4195 mDispatcher->notifyMotion(&motionArgs);
4196
4197 // We do not consume the motion right away, because that would require dispatcher to first
4198 // process (== drop) the key event, and by that time, ANR will be raised.
4199 // Set the focused window first.
4200 mFocusedWindow->setFocusable(true);
4201 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {mFocusedWindow, mUnfocusedWindow}}});
4202 setFocusedWindow(mFocusedWindow);
4203 mFocusedWindow->consumeFocusEvent(true);
4204 // We do not call "setFocusedApplication" here, even though the newly focused window belongs
4205 // to another application. This could be a bug / behaviour in the policy.
4206
4207 mUnfocusedWindow->consumeMotionDown();
4208
4209 ASSERT_TRUE(mDispatcher->waitForIdle());
4210 // Should not ANR because we actually have a focused window. It was just added too slowly.
4211 ASSERT_NO_FATAL_FAILURE(mFakePolicy->assertNotifyAnrWasNotCalled());
4212}
4213
Siarhei Vishniakoua2862a02020-07-20 16:36:46 -05004214// These tests ensure we cannot send touch events to a window that's positioned behind a window
4215// that has feature NO_INPUT_CHANNEL.
4216// Layout:
4217// Top (closest to user)
4218// mNoInputWindow (above all windows)
4219// mBottomWindow
4220// Bottom (furthest from user)
4221class InputDispatcherMultiWindowOcclusionTests : public InputDispatcherTest {
4222 virtual void SetUp() override {
4223 InputDispatcherTest::SetUp();
4224
4225 mApplication = std::make_shared<FakeApplicationHandle>();
4226 mNoInputWindow = new FakeWindowHandle(mApplication, mDispatcher,
4227 "Window without input channel", ADISPLAY_ID_DEFAULT,
4228 std::make_optional<sp<IBinder>>(nullptr) /*token*/);
4229
4230 mNoInputWindow->setInputFeatures(InputWindowInfo::Feature::NO_INPUT_CHANNEL);
4231 mNoInputWindow->setFrame(Rect(0, 0, 100, 100));
4232 // It's perfectly valid for this window to not have an associated input channel
4233
4234 mBottomWindow = new FakeWindowHandle(mApplication, mDispatcher, "Bottom window",
4235 ADISPLAY_ID_DEFAULT);
4236 mBottomWindow->setFrame(Rect(0, 0, 100, 100));
4237
4238 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {mNoInputWindow, mBottomWindow}}});
4239 }
4240
4241protected:
4242 std::shared_ptr<FakeApplicationHandle> mApplication;
4243 sp<FakeWindowHandle> mNoInputWindow;
4244 sp<FakeWindowHandle> mBottomWindow;
4245};
4246
4247TEST_F(InputDispatcherMultiWindowOcclusionTests, NoInputChannelFeature_DropsTouches) {
4248 PointF touchedPoint = {10, 10};
4249
4250 NotifyMotionArgs motionArgs =
4251 generateMotionArgs(AMOTION_EVENT_ACTION_DOWN, AINPUT_SOURCE_TOUCHSCREEN,
4252 ADISPLAY_ID_DEFAULT, {touchedPoint});
4253 mDispatcher->notifyMotion(&motionArgs);
4254
4255 mNoInputWindow->assertNoEvents();
4256 // Even though the window 'mNoInputWindow' positioned above 'mBottomWindow' does not have
4257 // an input channel, it is not marked as FLAG_NOT_TOUCHABLE,
4258 // and therefore should prevent mBottomWindow from receiving touches
4259 mBottomWindow->assertNoEvents();
4260}
4261
4262/**
4263 * If a window has feature NO_INPUT_CHANNEL, and somehow (by mistake) still has an input channel,
4264 * ensure that this window does not receive any touches, and blocks touches to windows underneath.
4265 */
4266TEST_F(InputDispatcherMultiWindowOcclusionTests,
4267 NoInputChannelFeature_DropsTouchesWithValidChannel) {
4268 mNoInputWindow = new FakeWindowHandle(mApplication, mDispatcher,
4269 "Window with input channel and NO_INPUT_CHANNEL",
4270 ADISPLAY_ID_DEFAULT);
4271
4272 mNoInputWindow->setInputFeatures(InputWindowInfo::Feature::NO_INPUT_CHANNEL);
4273 mNoInputWindow->setFrame(Rect(0, 0, 100, 100));
4274 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {mNoInputWindow, mBottomWindow}}});
4275
4276 PointF touchedPoint = {10, 10};
4277
4278 NotifyMotionArgs motionArgs =
4279 generateMotionArgs(AMOTION_EVENT_ACTION_DOWN, AINPUT_SOURCE_TOUCHSCREEN,
4280 ADISPLAY_ID_DEFAULT, {touchedPoint});
4281 mDispatcher->notifyMotion(&motionArgs);
4282
4283 mNoInputWindow->assertNoEvents();
4284 mBottomWindow->assertNoEvents();
4285}
4286
Vishnu Nair958da932020-08-21 17:12:37 -07004287class InputDispatcherMirrorWindowFocusTests : public InputDispatcherTest {
4288protected:
4289 std::shared_ptr<FakeApplicationHandle> mApp;
4290 sp<FakeWindowHandle> mWindow;
4291 sp<FakeWindowHandle> mMirror;
4292
4293 virtual void SetUp() override {
4294 InputDispatcherTest::SetUp();
4295 mApp = std::make_shared<FakeApplicationHandle>();
4296 mWindow = new FakeWindowHandle(mApp, mDispatcher, "TestWindow", ADISPLAY_ID_DEFAULT);
4297 mMirror = new FakeWindowHandle(mApp, mDispatcher, "TestWindowMirror", ADISPLAY_ID_DEFAULT,
4298 mWindow->getToken());
4299 mDispatcher->setFocusedApplication(ADISPLAY_ID_DEFAULT, mApp);
4300 mWindow->setFocusable(true);
4301 mMirror->setFocusable(true);
4302 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {mWindow, mMirror}}});
4303 }
4304};
4305
4306TEST_F(InputDispatcherMirrorWindowFocusTests, CanGetFocus) {
4307 // Request focus on a mirrored window
4308 setFocusedWindow(mMirror);
4309
4310 // window gets focused
4311 mWindow->consumeFocusEvent(true);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004312 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED, injectKeyDown(mDispatcher))
4313 << "Inject key event should return InputEventInjectionResult::SUCCEEDED";
Vishnu Nair958da932020-08-21 17:12:37 -07004314 mWindow->consumeKeyDown(ADISPLAY_ID_NONE);
4315}
4316
4317// A focused & mirrored window remains focused only if the window and its mirror are both
4318// focusable.
4319TEST_F(InputDispatcherMirrorWindowFocusTests, FocusedIfAllWindowsFocusable) {
4320 setFocusedWindow(mMirror);
4321
4322 // window gets focused
4323 mWindow->consumeFocusEvent(true);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004324 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED, injectKeyDown(mDispatcher))
4325 << "Inject key event should return InputEventInjectionResult::SUCCEEDED";
Vishnu Nair958da932020-08-21 17:12:37 -07004326 mWindow->consumeKeyDown(ADISPLAY_ID_NONE);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004327 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED, injectKeyUp(mDispatcher))
4328 << "Inject key event should return InputEventInjectionResult::SUCCEEDED";
Vishnu Nair958da932020-08-21 17:12:37 -07004329 mWindow->consumeKeyUp(ADISPLAY_ID_NONE);
4330
4331 mMirror->setFocusable(false);
4332 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {mWindow, mMirror}}});
4333
4334 // window loses focus since one of the windows associated with the token in not focusable
4335 mWindow->consumeFocusEvent(false);
4336
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004337 ASSERT_EQ(InputEventInjectionResult::TIMED_OUT, injectKeyDown(mDispatcher))
4338 << "Inject key event should return InputEventInjectionResult::TIMED_OUT";
Vishnu Nair958da932020-08-21 17:12:37 -07004339 mWindow->assertNoEvents();
4340}
4341
4342// A focused & mirrored window remains focused until the window and its mirror both become
4343// invisible.
4344TEST_F(InputDispatcherMirrorWindowFocusTests, FocusedIfAnyWindowVisible) {
4345 setFocusedWindow(mMirror);
4346
4347 // window gets focused
4348 mWindow->consumeFocusEvent(true);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004349 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED, injectKeyDown(mDispatcher))
4350 << "Inject key event should return InputEventInjectionResult::SUCCEEDED";
Vishnu Nair958da932020-08-21 17:12:37 -07004351 mWindow->consumeKeyDown(ADISPLAY_ID_NONE);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004352 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED, injectKeyUp(mDispatcher))
4353 << "Inject key event should return InputEventInjectionResult::SUCCEEDED";
Vishnu Nair958da932020-08-21 17:12:37 -07004354 mWindow->consumeKeyUp(ADISPLAY_ID_NONE);
4355
4356 mMirror->setVisible(false);
4357 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {mWindow, mMirror}}});
4358
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004359 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED, injectKeyDown(mDispatcher))
4360 << "Inject key event should return InputEventInjectionResult::SUCCEEDED";
Vishnu Nair958da932020-08-21 17:12:37 -07004361 mWindow->consumeKeyDown(ADISPLAY_ID_NONE);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004362 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED, injectKeyUp(mDispatcher))
4363 << "Inject key event should return InputEventInjectionResult::SUCCEEDED";
Vishnu Nair958da932020-08-21 17:12:37 -07004364 mWindow->consumeKeyUp(ADISPLAY_ID_NONE);
4365
4366 mWindow->setVisible(false);
4367 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {mWindow, mMirror}}});
4368
4369 // window loses focus only after all windows associated with the token become invisible.
4370 mWindow->consumeFocusEvent(false);
4371
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004372 ASSERT_EQ(InputEventInjectionResult::TIMED_OUT, injectKeyDown(mDispatcher))
4373 << "Inject key event should return InputEventInjectionResult::TIMED_OUT";
Vishnu Nair958da932020-08-21 17:12:37 -07004374 mWindow->assertNoEvents();
4375}
4376
4377// A focused & mirrored window remains focused until both windows are removed.
4378TEST_F(InputDispatcherMirrorWindowFocusTests, FocusedWhileWindowsAlive) {
4379 setFocusedWindow(mMirror);
4380
4381 // window gets focused
4382 mWindow->consumeFocusEvent(true);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004383 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED, injectKeyDown(mDispatcher))
4384 << "Inject key event should return InputEventInjectionResult::SUCCEEDED";
Vishnu Nair958da932020-08-21 17:12:37 -07004385 mWindow->consumeKeyDown(ADISPLAY_ID_NONE);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004386 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED, injectKeyUp(mDispatcher))
4387 << "Inject key event should return InputEventInjectionResult::SUCCEEDED";
Vishnu Nair958da932020-08-21 17:12:37 -07004388 mWindow->consumeKeyUp(ADISPLAY_ID_NONE);
4389
4390 // single window is removed but the window token remains focused
4391 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {mMirror}}});
4392
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004393 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED, injectKeyDown(mDispatcher))
4394 << "Inject key event should return InputEventInjectionResult::SUCCEEDED";
Vishnu Nair958da932020-08-21 17:12:37 -07004395 mWindow->consumeKeyDown(ADISPLAY_ID_NONE);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004396 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED, injectKeyUp(mDispatcher))
4397 << "Inject key event should return InputEventInjectionResult::SUCCEEDED";
Vishnu Nair958da932020-08-21 17:12:37 -07004398 mWindow->consumeKeyUp(ADISPLAY_ID_NONE);
4399
4400 // Both windows are removed
4401 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {}}});
4402 mWindow->consumeFocusEvent(false);
4403
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004404 ASSERT_EQ(InputEventInjectionResult::TIMED_OUT, injectKeyDown(mDispatcher))
4405 << "Inject key event should return InputEventInjectionResult::TIMED_OUT";
Vishnu Nair958da932020-08-21 17:12:37 -07004406 mWindow->assertNoEvents();
4407}
4408
4409// Focus request can be pending until one window becomes visible.
4410TEST_F(InputDispatcherMirrorWindowFocusTests, DeferFocusWhenInvisible) {
4411 // Request focus on an invisible mirror.
4412 mWindow->setVisible(false);
4413 mMirror->setVisible(false);
4414 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {mWindow, mMirror}}});
4415 setFocusedWindow(mMirror);
4416
4417 // Injected key goes to pending queue.
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004418 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
Vishnu Nair958da932020-08-21 17:12:37 -07004419 injectKey(mDispatcher, AKEY_EVENT_ACTION_DOWN, 0 /* repeatCount */,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -08004420 ADISPLAY_ID_DEFAULT, InputEventInjectionSync::NONE));
Vishnu Nair958da932020-08-21 17:12:37 -07004421
4422 mMirror->setVisible(true);
4423 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {mWindow, mMirror}}});
4424
4425 // window gets focused
4426 mWindow->consumeFocusEvent(true);
4427 // window gets the pending key event
4428 mWindow->consumeKeyDown(ADISPLAY_ID_DEFAULT);
4429}
Prabir Pradhan99987712020-11-10 18:43:05 -08004430
4431class InputDispatcherPointerCaptureTests : public InputDispatcherTest {
4432protected:
4433 std::shared_ptr<FakeApplicationHandle> mApp;
4434 sp<FakeWindowHandle> mWindow;
4435 sp<FakeWindowHandle> mSecondWindow;
4436
4437 void SetUp() override {
4438 InputDispatcherTest::SetUp();
4439 mApp = std::make_shared<FakeApplicationHandle>();
4440 mWindow = new FakeWindowHandle(mApp, mDispatcher, "TestWindow", ADISPLAY_ID_DEFAULT);
4441 mWindow->setFocusable(true);
4442 mSecondWindow = new FakeWindowHandle(mApp, mDispatcher, "TestWindow2", ADISPLAY_ID_DEFAULT);
4443 mSecondWindow->setFocusable(true);
4444
4445 mDispatcher->setFocusedApplication(ADISPLAY_ID_DEFAULT, mApp);
4446 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {mWindow, mSecondWindow}}});
4447
4448 setFocusedWindow(mWindow);
4449 mWindow->consumeFocusEvent(true);
4450 }
4451
4452 void notifyPointerCaptureChanged(bool enabled) {
4453 const NotifyPointerCaptureChangedArgs args = generatePointerCaptureChangedArgs(enabled);
4454 mDispatcher->notifyPointerCaptureChanged(&args);
4455 }
4456
4457 void requestAndVerifyPointerCapture(const sp<FakeWindowHandle>& window, bool enabled) {
4458 mDispatcher->requestPointerCapture(window->getToken(), enabled);
4459 mFakePolicy->waitForSetPointerCapture(enabled);
4460 notifyPointerCaptureChanged(enabled);
4461 window->consumeCaptureEvent(enabled);
4462 }
4463};
4464
4465TEST_F(InputDispatcherPointerCaptureTests, EnablePointerCaptureWhenFocused) {
4466 // Ensure that capture cannot be obtained for unfocused windows.
4467 mDispatcher->requestPointerCapture(mSecondWindow->getToken(), true);
4468 mFakePolicy->assertSetPointerCaptureNotCalled();
4469 mSecondWindow->assertNoEvents();
4470
4471 // Ensure that capture can be enabled from the focus window.
4472 requestAndVerifyPointerCapture(mWindow, true);
4473
4474 // Ensure that capture cannot be disabled from a window that does not have capture.
4475 mDispatcher->requestPointerCapture(mSecondWindow->getToken(), false);
4476 mFakePolicy->assertSetPointerCaptureNotCalled();
4477
4478 // Ensure that capture can be disabled from the window with capture.
4479 requestAndVerifyPointerCapture(mWindow, false);
4480}
4481
4482TEST_F(InputDispatcherPointerCaptureTests, DisablesPointerCaptureAfterWindowLosesFocus) {
4483 requestAndVerifyPointerCapture(mWindow, true);
4484
4485 setFocusedWindow(mSecondWindow);
4486
4487 // Ensure that the capture disabled event was sent first.
4488 mWindow->consumeCaptureEvent(false);
4489 mWindow->consumeFocusEvent(false);
4490 mSecondWindow->consumeFocusEvent(true);
4491 mFakePolicy->waitForSetPointerCapture(false);
4492
4493 // Ensure that additional state changes from InputReader are not sent to the window.
4494 notifyPointerCaptureChanged(false);
4495 notifyPointerCaptureChanged(true);
4496 notifyPointerCaptureChanged(false);
4497 mWindow->assertNoEvents();
4498 mSecondWindow->assertNoEvents();
4499 mFakePolicy->assertSetPointerCaptureNotCalled();
4500}
4501
4502TEST_F(InputDispatcherPointerCaptureTests, UnexpectedStateChangeDisablesPointerCapture) {
4503 requestAndVerifyPointerCapture(mWindow, true);
4504
4505 // InputReader unexpectedly disables and enables pointer capture.
4506 notifyPointerCaptureChanged(false);
4507 notifyPointerCaptureChanged(true);
4508
4509 // Ensure that Pointer Capture is disabled.
Prabir Pradhan7d030382020-12-21 07:58:35 -08004510 mFakePolicy->waitForSetPointerCapture(false);
Prabir Pradhan99987712020-11-10 18:43:05 -08004511 mWindow->consumeCaptureEvent(false);
4512 mWindow->assertNoEvents();
4513}
4514
Prabir Pradhan167e6d92021-02-04 16:18:17 -08004515TEST_F(InputDispatcherPointerCaptureTests, OutOfOrderRequests) {
4516 requestAndVerifyPointerCapture(mWindow, true);
4517
4518 // The first window loses focus.
4519 setFocusedWindow(mSecondWindow);
4520 mFakePolicy->waitForSetPointerCapture(false);
4521 mWindow->consumeCaptureEvent(false);
4522
4523 // Request Pointer Capture from the second window before the notification from InputReader
4524 // arrives.
4525 mDispatcher->requestPointerCapture(mSecondWindow->getToken(), true);
4526 mFakePolicy->waitForSetPointerCapture(true);
4527
4528 // InputReader notifies Pointer Capture was disabled (because of the focus change).
4529 notifyPointerCaptureChanged(false);
4530
4531 // InputReader notifies Pointer Capture was enabled (because of mSecondWindow's request).
4532 notifyPointerCaptureChanged(true);
4533
4534 mSecondWindow->consumeFocusEvent(true);
4535 mSecondWindow->consumeCaptureEvent(true);
4536}
4537
Bernardo Rufinoc3b7b8c2021-01-29 17:38:07 +00004538class InputDispatcherUntrustedTouchesTest : public InputDispatcherTest {
4539protected:
4540 constexpr static const float MAXIMUM_OBSCURING_OPACITY = 0.8;
Bernardo Rufino7393d172021-02-26 13:56:11 +00004541
4542 constexpr static const float OPACITY_ABOVE_THRESHOLD = 0.9;
4543 static_assert(OPACITY_ABOVE_THRESHOLD > MAXIMUM_OBSCURING_OPACITY);
4544
4545 constexpr static const float OPACITY_BELOW_THRESHOLD = 0.7;
4546 static_assert(OPACITY_BELOW_THRESHOLD < MAXIMUM_OBSCURING_OPACITY);
4547
4548 // When combined twice, ie 1 - (1 - 0.5)*(1 - 0.5) = 0.75 < 8, is still below the threshold
4549 constexpr static const float OPACITY_FAR_BELOW_THRESHOLD = 0.5;
4550 static_assert(OPACITY_FAR_BELOW_THRESHOLD < MAXIMUM_OBSCURING_OPACITY);
4551 static_assert(1 - (1 - OPACITY_FAR_BELOW_THRESHOLD) * (1 - OPACITY_FAR_BELOW_THRESHOLD) <
4552 MAXIMUM_OBSCURING_OPACITY);
4553
Bernardo Rufino6d52e542021-02-15 18:38:10 +00004554 static const int32_t TOUCHED_APP_UID = 10001;
Bernardo Rufinoc3b7b8c2021-01-29 17:38:07 +00004555 static const int32_t APP_B_UID = 10002;
Bernardo Rufino1d0d1f22021-02-12 15:08:43 +00004556 static const int32_t APP_C_UID = 10003;
Bernardo Rufinoc3b7b8c2021-01-29 17:38:07 +00004557
4558 sp<FakeWindowHandle> mTouchWindow;
4559
4560 virtual void SetUp() override {
4561 InputDispatcherTest::SetUp();
Bernardo Rufino6d52e542021-02-15 18:38:10 +00004562 mTouchWindow = getWindow(TOUCHED_APP_UID, "Touched");
Bernardo Rufinoc3b7b8c2021-01-29 17:38:07 +00004563 mDispatcher->setBlockUntrustedTouchesMode(android::os::BlockUntrustedTouchesMode::BLOCK);
4564 mDispatcher->setMaximumObscuringOpacityForTouch(MAXIMUM_OBSCURING_OPACITY);
4565 }
4566
4567 virtual void TearDown() override {
4568 InputDispatcherTest::TearDown();
4569 mTouchWindow.clear();
4570 }
4571
4572 sp<FakeWindowHandle> getOccludingWindow(int32_t uid, std::string name,
Bernardo Rufino1d0d1f22021-02-12 15:08:43 +00004573 os::TouchOcclusionMode mode, float alpha = 1.0f) {
Bernardo Rufinoc3b7b8c2021-01-29 17:38:07 +00004574 sp<FakeWindowHandle> window = getWindow(uid, name);
4575 window->setFlags(InputWindowInfo::Flag::NOT_TOUCHABLE);
4576 window->setTouchOcclusionMode(mode);
Bernardo Rufino1d0d1f22021-02-12 15:08:43 +00004577 window->setAlpha(alpha);
Bernardo Rufinoc3b7b8c2021-01-29 17:38:07 +00004578 return window;
4579 }
4580
4581 sp<FakeWindowHandle> getWindow(int32_t uid, std::string name) {
4582 std::shared_ptr<FakeApplicationHandle> app = std::make_shared<FakeApplicationHandle>();
4583 sp<FakeWindowHandle> window =
4584 new FakeWindowHandle(app, mDispatcher, name, ADISPLAY_ID_DEFAULT);
4585 // Generate an arbitrary PID based on the UID
4586 window->setOwnerInfo(1777 + (uid % 10000), uid);
4587 return window;
4588 }
4589
4590 void touch(const std::vector<PointF>& points = {PointF{100, 200}}) {
4591 NotifyMotionArgs args =
4592 generateMotionArgs(AMOTION_EVENT_ACTION_DOWN, AINPUT_SOURCE_TOUCHSCREEN,
4593 ADISPLAY_ID_DEFAULT, points);
4594 mDispatcher->notifyMotion(&args);
4595 }
4596};
4597
4598TEST_F(InputDispatcherUntrustedTouchesTest, WindowWithBlockUntrustedOcclusionMode_BlocksTouch) {
Bernardo Rufino1d0d1f22021-02-12 15:08:43 +00004599 const sp<FakeWindowHandle>& w =
Bernardo Rufinoc3b7b8c2021-01-29 17:38:07 +00004600 getOccludingWindow(APP_B_UID, "B", TouchOcclusionMode::BLOCK_UNTRUSTED);
Bernardo Rufino1d0d1f22021-02-12 15:08:43 +00004601 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {w, mTouchWindow}}});
Bernardo Rufinoc3b7b8c2021-01-29 17:38:07 +00004602
4603 touch();
4604
4605 mTouchWindow->assertNoEvents();
4606}
4607
Bernardo Rufinoa43a5a42021-02-17 12:21:14 +00004608TEST_F(InputDispatcherUntrustedTouchesTest,
Bernardo Rufino7393d172021-02-26 13:56:11 +00004609 WindowWithBlockUntrustedOcclusionModeWithOpacityBelowThreshold_BlocksTouch) {
4610 const sp<FakeWindowHandle>& w =
4611 getOccludingWindow(APP_B_UID, "B", TouchOcclusionMode::BLOCK_UNTRUSTED, 0.7f);
4612 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {w, mTouchWindow}}});
4613
4614 touch();
4615
4616 mTouchWindow->assertNoEvents();
4617}
4618
4619TEST_F(InputDispatcherUntrustedTouchesTest,
Bernardo Rufinoa43a5a42021-02-17 12:21:14 +00004620 WindowWithBlockUntrustedOcclusionMode_DoesNotReceiveTouch) {
4621 const sp<FakeWindowHandle>& w =
4622 getOccludingWindow(APP_B_UID, "B", TouchOcclusionMode::BLOCK_UNTRUSTED);
4623 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {w, mTouchWindow}}});
4624
4625 touch();
4626
4627 w->assertNoEvents();
4628}
4629
Bernardo Rufinoc3b7b8c2021-01-29 17:38:07 +00004630TEST_F(InputDispatcherUntrustedTouchesTest, WindowWithAllowOcclusionMode_AllowsTouch) {
Bernardo Rufino1d0d1f22021-02-12 15:08:43 +00004631 const sp<FakeWindowHandle>& w = getOccludingWindow(APP_B_UID, "B", TouchOcclusionMode::ALLOW);
4632 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {w, mTouchWindow}}});
Bernardo Rufinoc3b7b8c2021-01-29 17:38:07 +00004633
4634 touch();
4635
4636 mTouchWindow->consumeAnyMotionDown();
4637}
4638
4639TEST_F(InputDispatcherUntrustedTouchesTest, TouchOutsideOccludingWindow_AllowsTouch) {
Bernardo Rufino1d0d1f22021-02-12 15:08:43 +00004640 const sp<FakeWindowHandle>& w =
Bernardo Rufinoc3b7b8c2021-01-29 17:38:07 +00004641 getOccludingWindow(APP_B_UID, "B", TouchOcclusionMode::BLOCK_UNTRUSTED);
Bernardo Rufino1d0d1f22021-02-12 15:08:43 +00004642 w->setFrame(Rect(0, 0, 50, 50));
4643 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {w, mTouchWindow}}});
Bernardo Rufinoc3b7b8c2021-01-29 17:38:07 +00004644
4645 touch({PointF{100, 100}});
4646
4647 mTouchWindow->consumeAnyMotionDown();
4648}
4649
4650TEST_F(InputDispatcherUntrustedTouchesTest, WindowFromSameUid_AllowsTouch) {
Bernardo Rufino1d0d1f22021-02-12 15:08:43 +00004651 const sp<FakeWindowHandle>& w =
Bernardo Rufino6d52e542021-02-15 18:38:10 +00004652 getOccludingWindow(TOUCHED_APP_UID, "A", TouchOcclusionMode::BLOCK_UNTRUSTED);
Bernardo Rufino1d0d1f22021-02-12 15:08:43 +00004653 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {w, mTouchWindow}}});
4654
4655 touch();
4656
4657 mTouchWindow->consumeAnyMotionDown();
4658}
4659
4660TEST_F(InputDispatcherUntrustedTouchesTest, WindowWithZeroOpacity_AllowsTouch) {
4661 const sp<FakeWindowHandle>& w =
4662 getOccludingWindow(APP_B_UID, "B", TouchOcclusionMode::BLOCK_UNTRUSTED, 0.0f);
4663 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {w, mTouchWindow}}});
Bernardo Rufinoc3b7b8c2021-01-29 17:38:07 +00004664
4665 touch();
4666
4667 mTouchWindow->consumeAnyMotionDown();
4668}
4669
Bernardo Rufinoa43a5a42021-02-17 12:21:14 +00004670TEST_F(InputDispatcherUntrustedTouchesTest, WindowWithZeroOpacity_DoesNotReceiveTouch) {
4671 const sp<FakeWindowHandle>& w =
4672 getOccludingWindow(APP_B_UID, "B", TouchOcclusionMode::BLOCK_UNTRUSTED, 0.0f);
4673 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {w, mTouchWindow}}});
4674
4675 touch();
4676
4677 w->assertNoEvents();
4678}
4679
4680/**
4681 * This is important to make sure apps can't indirectly learn the position of touches (outside vs
4682 * inside) while letting them pass-through. Note that even though touch passes through the occluding
4683 * window, the occluding window will still receive ACTION_OUTSIDE event.
4684 */
4685TEST_F(InputDispatcherUntrustedTouchesTest,
4686 WindowWithZeroOpacityAndWatchOutside_ReceivesOutsideEvent) {
4687 const sp<FakeWindowHandle>& w =
4688 getOccludingWindow(APP_B_UID, "B", TouchOcclusionMode::BLOCK_UNTRUSTED, 0.0f);
4689 w->addFlags(InputWindowInfo::Flag::WATCH_OUTSIDE_TOUCH);
4690 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {w, mTouchWindow}}});
4691
4692 touch();
4693
4694 w->consumeMotionOutside();
4695}
4696
4697TEST_F(InputDispatcherUntrustedTouchesTest, OutsideEvent_HasZeroCoordinates) {
4698 const sp<FakeWindowHandle>& w =
4699 getOccludingWindow(APP_B_UID, "B", TouchOcclusionMode::BLOCK_UNTRUSTED, 0.0f);
4700 w->addFlags(InputWindowInfo::Flag::WATCH_OUTSIDE_TOUCH);
4701 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {w, mTouchWindow}}});
4702
4703 touch();
4704
4705 InputEvent* event = w->consume();
4706 ASSERT_EQ(AINPUT_EVENT_TYPE_MOTION, event->getType());
4707 MotionEvent& motionEvent = static_cast<MotionEvent&>(*event);
4708 EXPECT_EQ(0.0f, motionEvent.getRawPointerCoords(0)->getX());
4709 EXPECT_EQ(0.0f, motionEvent.getRawPointerCoords(0)->getY());
4710}
4711
Bernardo Rufinoc3b7b8c2021-01-29 17:38:07 +00004712TEST_F(InputDispatcherUntrustedTouchesTest, WindowWithOpacityBelowThreshold_AllowsTouch) {
Bernardo Rufino1d0d1f22021-02-12 15:08:43 +00004713 const sp<FakeWindowHandle>& w =
Bernardo Rufino7393d172021-02-26 13:56:11 +00004714 getOccludingWindow(APP_B_UID, "B", TouchOcclusionMode::USE_OPACITY,
4715 OPACITY_BELOW_THRESHOLD);
Bernardo Rufino1d0d1f22021-02-12 15:08:43 +00004716 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {w, mTouchWindow}}});
4717
4718 touch();
4719
4720 mTouchWindow->consumeAnyMotionDown();
4721}
4722
4723TEST_F(InputDispatcherUntrustedTouchesTest, WindowWithOpacityAtThreshold_AllowsTouch) {
4724 const sp<FakeWindowHandle>& w =
4725 getOccludingWindow(APP_B_UID, "B", TouchOcclusionMode::USE_OPACITY,
4726 MAXIMUM_OBSCURING_OPACITY);
4727 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {w, mTouchWindow}}});
Bernardo Rufinoc3b7b8c2021-01-29 17:38:07 +00004728
4729 touch();
4730
4731 mTouchWindow->consumeAnyMotionDown();
4732}
4733
4734TEST_F(InputDispatcherUntrustedTouchesTest, WindowWithOpacityAboveThreshold_BlocksTouch) {
Bernardo Rufino1d0d1f22021-02-12 15:08:43 +00004735 const sp<FakeWindowHandle>& w =
Bernardo Rufino7393d172021-02-26 13:56:11 +00004736 getOccludingWindow(APP_B_UID, "B", TouchOcclusionMode::USE_OPACITY,
4737 OPACITY_ABOVE_THRESHOLD);
Bernardo Rufino1d0d1f22021-02-12 15:08:43 +00004738 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {w, mTouchWindow}}});
4739
4740 touch();
4741
4742 mTouchWindow->assertNoEvents();
4743}
4744
4745TEST_F(InputDispatcherUntrustedTouchesTest, WindowsWithCombinedOpacityAboveThreshold_BlocksTouch) {
4746 // Resulting opacity = 1 - (1 - 0.7)*(1 - 0.7) = .91
4747 const sp<FakeWindowHandle>& w1 =
Bernardo Rufino7393d172021-02-26 13:56:11 +00004748 getOccludingWindow(APP_B_UID, "B1", TouchOcclusionMode::USE_OPACITY,
4749 OPACITY_BELOW_THRESHOLD);
Bernardo Rufino1d0d1f22021-02-12 15:08:43 +00004750 const sp<FakeWindowHandle>& w2 =
Bernardo Rufino7393d172021-02-26 13:56:11 +00004751 getOccludingWindow(APP_B_UID, "B2", TouchOcclusionMode::USE_OPACITY,
4752 OPACITY_BELOW_THRESHOLD);
Bernardo Rufino1d0d1f22021-02-12 15:08:43 +00004753 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {w1, w2, mTouchWindow}}});
4754
4755 touch();
4756
4757 mTouchWindow->assertNoEvents();
4758}
4759
4760TEST_F(InputDispatcherUntrustedTouchesTest, WindowsWithCombinedOpacityBelowThreshold_AllowsTouch) {
4761 // Resulting opacity = 1 - (1 - 0.5)*(1 - 0.5) = .75
4762 const sp<FakeWindowHandle>& w1 =
Bernardo Rufino7393d172021-02-26 13:56:11 +00004763 getOccludingWindow(APP_B_UID, "B1", TouchOcclusionMode::USE_OPACITY,
4764 OPACITY_FAR_BELOW_THRESHOLD);
Bernardo Rufino1d0d1f22021-02-12 15:08:43 +00004765 const sp<FakeWindowHandle>& w2 =
Bernardo Rufino7393d172021-02-26 13:56:11 +00004766 getOccludingWindow(APP_B_UID, "B2", TouchOcclusionMode::USE_OPACITY,
4767 OPACITY_FAR_BELOW_THRESHOLD);
Bernardo Rufino1d0d1f22021-02-12 15:08:43 +00004768 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {w1, w2, mTouchWindow}}});
4769
4770 touch();
4771
4772 mTouchWindow->consumeAnyMotionDown();
4773}
4774
4775TEST_F(InputDispatcherUntrustedTouchesTest,
4776 WindowsFromDifferentAppsEachBelowThreshold_AllowsTouch) {
4777 const sp<FakeWindowHandle>& wB =
Bernardo Rufino7393d172021-02-26 13:56:11 +00004778 getOccludingWindow(APP_B_UID, "B", TouchOcclusionMode::USE_OPACITY,
4779 OPACITY_BELOW_THRESHOLD);
Bernardo Rufino1d0d1f22021-02-12 15:08:43 +00004780 const sp<FakeWindowHandle>& wC =
Bernardo Rufino7393d172021-02-26 13:56:11 +00004781 getOccludingWindow(APP_C_UID, "C", TouchOcclusionMode::USE_OPACITY,
4782 OPACITY_BELOW_THRESHOLD);
Bernardo Rufino1d0d1f22021-02-12 15:08:43 +00004783 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {wB, wC, mTouchWindow}}});
4784
4785 touch();
4786
4787 mTouchWindow->consumeAnyMotionDown();
4788}
4789
4790TEST_F(InputDispatcherUntrustedTouchesTest, WindowsFromDifferentAppsOneAboveThreshold_BlocksTouch) {
4791 const sp<FakeWindowHandle>& wB =
Bernardo Rufino7393d172021-02-26 13:56:11 +00004792 getOccludingWindow(APP_B_UID, "B", TouchOcclusionMode::USE_OPACITY,
4793 OPACITY_BELOW_THRESHOLD);
Bernardo Rufino1d0d1f22021-02-12 15:08:43 +00004794 const sp<FakeWindowHandle>& wC =
Bernardo Rufino7393d172021-02-26 13:56:11 +00004795 getOccludingWindow(APP_C_UID, "C", TouchOcclusionMode::USE_OPACITY,
4796 OPACITY_ABOVE_THRESHOLD);
Bernardo Rufino1d0d1f22021-02-12 15:08:43 +00004797 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {wB, wC, mTouchWindow}}});
Bernardo Rufinoc3b7b8c2021-01-29 17:38:07 +00004798
4799 touch();
4800
4801 mTouchWindow->assertNoEvents();
4802}
4803
Bernardo Rufino6d52e542021-02-15 18:38:10 +00004804TEST_F(InputDispatcherUntrustedTouchesTest,
4805 WindowWithOpacityAboveThresholdAndSelfWindow_BlocksTouch) {
4806 const sp<FakeWindowHandle>& wA =
Bernardo Rufino7393d172021-02-26 13:56:11 +00004807 getOccludingWindow(TOUCHED_APP_UID, "T", TouchOcclusionMode::USE_OPACITY,
4808 OPACITY_BELOW_THRESHOLD);
Bernardo Rufino6d52e542021-02-15 18:38:10 +00004809 const sp<FakeWindowHandle>& wB =
Bernardo Rufino7393d172021-02-26 13:56:11 +00004810 getOccludingWindow(APP_B_UID, "B", TouchOcclusionMode::USE_OPACITY,
4811 OPACITY_ABOVE_THRESHOLD);
Bernardo Rufino6d52e542021-02-15 18:38:10 +00004812 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {wA, wB, mTouchWindow}}});
4813
4814 touch();
4815
4816 mTouchWindow->assertNoEvents();
4817}
4818
4819TEST_F(InputDispatcherUntrustedTouchesTest,
4820 WindowWithOpacityBelowThresholdAndSelfWindow_AllowsTouch) {
4821 const sp<FakeWindowHandle>& wA =
Bernardo Rufino7393d172021-02-26 13:56:11 +00004822 getOccludingWindow(TOUCHED_APP_UID, "T", TouchOcclusionMode::USE_OPACITY,
4823 OPACITY_ABOVE_THRESHOLD);
Bernardo Rufino6d52e542021-02-15 18:38:10 +00004824 const sp<FakeWindowHandle>& wB =
Bernardo Rufino7393d172021-02-26 13:56:11 +00004825 getOccludingWindow(APP_B_UID, "B", TouchOcclusionMode::USE_OPACITY,
4826 OPACITY_BELOW_THRESHOLD);
Bernardo Rufino6d52e542021-02-15 18:38:10 +00004827 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {wA, wB, mTouchWindow}}});
4828
4829 touch();
4830
4831 mTouchWindow->consumeAnyMotionDown();
4832}
4833
4834TEST_F(InputDispatcherUntrustedTouchesTest, SelfWindowWithOpacityAboveThreshold_AllowsTouch) {
4835 const sp<FakeWindowHandle>& w =
Bernardo Rufino7393d172021-02-26 13:56:11 +00004836 getOccludingWindow(TOUCHED_APP_UID, "T", TouchOcclusionMode::USE_OPACITY,
4837 OPACITY_ABOVE_THRESHOLD);
Bernardo Rufino6d52e542021-02-15 18:38:10 +00004838 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {w, mTouchWindow}}});
4839
4840 touch();
4841
4842 mTouchWindow->consumeAnyMotionDown();
4843}
4844
4845TEST_F(InputDispatcherUntrustedTouchesTest, SelfWindowWithBlockUntrustedMode_AllowsTouch) {
4846 const sp<FakeWindowHandle>& w =
4847 getOccludingWindow(TOUCHED_APP_UID, "T", TouchOcclusionMode::BLOCK_UNTRUSTED);
4848 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {w, mTouchWindow}}});
4849
4850 touch();
4851
4852 mTouchWindow->consumeAnyMotionDown();
4853}
4854
Bernardo Rufinoccd3dd62021-02-15 18:47:42 +00004855TEST_F(InputDispatcherUntrustedTouchesTest,
4856 OpacityThresholdIs0AndWindowAboveThreshold_BlocksTouch) {
4857 mDispatcher->setMaximumObscuringOpacityForTouch(0.0f);
4858 const sp<FakeWindowHandle>& w =
4859 getOccludingWindow(APP_B_UID, "B", TouchOcclusionMode::USE_OPACITY, 0.1f);
4860 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {w, mTouchWindow}}});
4861
4862 touch();
4863
4864 mTouchWindow->assertNoEvents();
4865}
4866
4867TEST_F(InputDispatcherUntrustedTouchesTest, OpacityThresholdIs0AndWindowAtThreshold_AllowsTouch) {
4868 mDispatcher->setMaximumObscuringOpacityForTouch(0.0f);
4869 const sp<FakeWindowHandle>& w =
4870 getOccludingWindow(APP_B_UID, "B", TouchOcclusionMode::USE_OPACITY, 0.0f);
4871 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {w, mTouchWindow}}});
4872
4873 touch();
4874
4875 mTouchWindow->consumeAnyMotionDown();
4876}
4877
4878TEST_F(InputDispatcherUntrustedTouchesTest,
4879 OpacityThresholdIs1AndWindowBelowThreshold_AllowsTouch) {
4880 mDispatcher->setMaximumObscuringOpacityForTouch(1.0f);
4881 const sp<FakeWindowHandle>& w =
Bernardo Rufino7393d172021-02-26 13:56:11 +00004882 getOccludingWindow(APP_B_UID, "B", TouchOcclusionMode::USE_OPACITY,
4883 OPACITY_ABOVE_THRESHOLD);
4884 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {w, mTouchWindow}}});
4885
4886 touch();
4887
4888 mTouchWindow->consumeAnyMotionDown();
4889}
4890
4891TEST_F(InputDispatcherUntrustedTouchesTest,
4892 WindowWithBlockUntrustedModeAndWindowWithOpacityBelowFromSameApp_BlocksTouch) {
4893 const sp<FakeWindowHandle>& w1 =
4894 getOccludingWindow(APP_B_UID, "B", TouchOcclusionMode::BLOCK_UNTRUSTED,
4895 OPACITY_BELOW_THRESHOLD);
4896 const sp<FakeWindowHandle>& w2 =
4897 getOccludingWindow(APP_B_UID, "B", TouchOcclusionMode::USE_OPACITY,
4898 OPACITY_BELOW_THRESHOLD);
4899 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {w1, w2, mTouchWindow}}});
4900
4901 touch();
4902
4903 mTouchWindow->assertNoEvents();
4904}
4905
4906/**
4907 * Window B of BLOCK_UNTRUSTED occlusion mode is enough to block the touch, we're testing that the
4908 * addition of another window (C) of USE_OPACITY occlusion mode and opacity below the threshold
4909 * (which alone would result in allowing touches) does not affect the blocking behavior.
4910 */
4911TEST_F(InputDispatcherUntrustedTouchesTest,
4912 WindowWithBlockUntrustedModeAndWindowWithOpacityBelowFromDifferentApps_BlocksTouch) {
4913 const sp<FakeWindowHandle>& wB =
4914 getOccludingWindow(APP_B_UID, "B", TouchOcclusionMode::BLOCK_UNTRUSTED,
4915 OPACITY_BELOW_THRESHOLD);
4916 const sp<FakeWindowHandle>& wC =
4917 getOccludingWindow(APP_C_UID, "C", TouchOcclusionMode::USE_OPACITY,
4918 OPACITY_BELOW_THRESHOLD);
4919 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {wB, wC, mTouchWindow}}});
4920
4921 touch();
4922
4923 mTouchWindow->assertNoEvents();
4924}
4925
4926/**
4927 * This test is testing that a window from a different UID but with same application token doesn't
4928 * block the touch. Apps can share the application token for close UI collaboration for example.
4929 */
4930TEST_F(InputDispatcherUntrustedTouchesTest,
4931 WindowWithSameApplicationTokenFromDifferentApp_AllowsTouch) {
4932 const sp<FakeWindowHandle>& w =
4933 getOccludingWindow(APP_B_UID, "B", TouchOcclusionMode::BLOCK_UNTRUSTED);
4934 w->setApplicationToken(mTouchWindow->getApplicationToken());
Bernardo Rufinoccd3dd62021-02-15 18:47:42 +00004935 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {w, mTouchWindow}}});
4936
4937 touch();
4938
4939 mTouchWindow->consumeAnyMotionDown();
4940}
4941
arthurhungb89ccb02020-12-30 16:19:01 +08004942class InputDispatcherDragTests : public InputDispatcherTest {
4943protected:
4944 std::shared_ptr<FakeApplicationHandle> mApp;
4945 sp<FakeWindowHandle> mWindow;
4946 sp<FakeWindowHandle> mSecondWindow;
4947 sp<FakeWindowHandle> mDragWindow;
4948
4949 void SetUp() override {
4950 InputDispatcherTest::SetUp();
4951 mApp = std::make_shared<FakeApplicationHandle>();
4952 mWindow = new FakeWindowHandle(mApp, mDispatcher, "TestWindow", ADISPLAY_ID_DEFAULT);
4953 mWindow->setFrame(Rect(0, 0, 100, 100));
4954 mWindow->setFlags(InputWindowInfo::Flag::NOT_TOUCH_MODAL);
4955
4956 mSecondWindow = new FakeWindowHandle(mApp, mDispatcher, "TestWindow2", ADISPLAY_ID_DEFAULT);
4957 mSecondWindow->setFrame(Rect(100, 0, 200, 100));
4958 mSecondWindow->setFlags(InputWindowInfo::Flag::NOT_TOUCH_MODAL);
4959
4960 mDispatcher->setFocusedApplication(ADISPLAY_ID_DEFAULT, mApp);
4961 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {mWindow, mSecondWindow}}});
4962 }
4963
4964 // Start performing drag, we will create a drag window and transfer touch to it.
4965 void performDrag() {
4966 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
4967 injectMotionDown(mDispatcher, AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT,
4968 {50, 50}))
4969 << "Inject motion event should return InputEventInjectionResult::SUCCEEDED";
4970
4971 // Window should receive motion event.
4972 mWindow->consumeMotionDown(ADISPLAY_ID_DEFAULT);
4973
4974 // The drag window covers the entire display
4975 mDragWindow = new FakeWindowHandle(mApp, mDispatcher, "DragWindow", ADISPLAY_ID_DEFAULT);
4976 mDispatcher->setInputWindows(
4977 {{ADISPLAY_ID_DEFAULT, {mDragWindow, mWindow, mSecondWindow}}});
4978
4979 // Transfer touch focus to the drag window
4980 mDispatcher->transferTouchFocus(mWindow->getToken(), mDragWindow->getToken(),
4981 true /* isDragDrop */);
4982 mWindow->consumeMotionCancel();
4983 mDragWindow->consumeMotionDown();
4984 }
arthurhung6d4bed92021-03-17 11:59:33 +08004985
4986 // Start performing drag, we will create a drag window and transfer touch to it.
4987 void performStylusDrag() {
4988 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
4989 injectMotionEvent(mDispatcher,
4990 MotionEventBuilder(AMOTION_EVENT_ACTION_DOWN,
4991 AINPUT_SOURCE_STYLUS)
4992 .buttonState(AMOTION_EVENT_BUTTON_STYLUS_PRIMARY)
4993 .pointer(PointerBuilder(0,
4994 AMOTION_EVENT_TOOL_TYPE_STYLUS)
4995 .x(50)
4996 .y(50))
4997 .build()));
4998 mWindow->consumeMotionDown(ADISPLAY_ID_DEFAULT);
4999
5000 // The drag window covers the entire display
5001 mDragWindow = new FakeWindowHandle(mApp, mDispatcher, "DragWindow", ADISPLAY_ID_DEFAULT);
5002 mDispatcher->setInputWindows(
5003 {{ADISPLAY_ID_DEFAULT, {mDragWindow, mWindow, mSecondWindow}}});
5004
5005 // Transfer touch focus to the drag window
5006 mDispatcher->transferTouchFocus(mWindow->getToken(), mDragWindow->getToken(),
5007 true /* isDragDrop */);
5008 mWindow->consumeMotionCancel();
5009 mDragWindow->consumeMotionDown();
5010 }
arthurhungb89ccb02020-12-30 16:19:01 +08005011};
5012
5013TEST_F(InputDispatcherDragTests, DragEnterAndDragExit) {
5014 performDrag();
5015
5016 // Move on window.
5017 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
5018 injectMotionEvent(mDispatcher, AMOTION_EVENT_ACTION_MOVE, AINPUT_SOURCE_TOUCHSCREEN,
5019 ADISPLAY_ID_DEFAULT, {50, 50}))
5020 << "Inject motion event should return InputEventInjectionResult::SUCCEEDED";
5021 mDragWindow->consumeMotionMove(ADISPLAY_ID_DEFAULT);
5022 mWindow->consumeDragEvent(false, 50, 50);
5023 mSecondWindow->assertNoEvents();
5024
5025 // Move to another window.
5026 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
5027 injectMotionEvent(mDispatcher, AMOTION_EVENT_ACTION_MOVE, AINPUT_SOURCE_TOUCHSCREEN,
5028 ADISPLAY_ID_DEFAULT, {150, 50}))
5029 << "Inject motion event should return InputEventInjectionResult::SUCCEEDED";
5030 mDragWindow->consumeMotionMove(ADISPLAY_ID_DEFAULT);
5031 mWindow->consumeDragEvent(true, 150, 50);
5032 mSecondWindow->consumeDragEvent(false, 50, 50);
5033
5034 // Move back to original window.
5035 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
5036 injectMotionEvent(mDispatcher, AMOTION_EVENT_ACTION_MOVE, AINPUT_SOURCE_TOUCHSCREEN,
5037 ADISPLAY_ID_DEFAULT, {50, 50}))
5038 << "Inject motion event should return InputEventInjectionResult::SUCCEEDED";
5039 mDragWindow->consumeMotionMove(ADISPLAY_ID_DEFAULT);
5040 mWindow->consumeDragEvent(false, 50, 50);
5041 mSecondWindow->consumeDragEvent(true, -50, 50);
5042
5043 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
5044 injectMotionUp(mDispatcher, AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT, {50, 50}))
5045 << "Inject motion event should return InputEventInjectionResult::SUCCEEDED";
5046 mDragWindow->consumeMotionUp(ADISPLAY_ID_DEFAULT);
5047 mWindow->assertNoEvents();
5048 mSecondWindow->assertNoEvents();
5049}
5050
arthurhungf452d0b2021-01-06 00:19:52 +08005051TEST_F(InputDispatcherDragTests, DragAndDrop) {
5052 performDrag();
5053
5054 // Move on window.
5055 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
5056 injectMotionEvent(mDispatcher, AMOTION_EVENT_ACTION_MOVE, AINPUT_SOURCE_TOUCHSCREEN,
5057 ADISPLAY_ID_DEFAULT, {50, 50}))
5058 << "Inject motion event should return InputEventInjectionResult::SUCCEEDED";
5059 mDragWindow->consumeMotionMove(ADISPLAY_ID_DEFAULT);
5060 mWindow->consumeDragEvent(false, 50, 50);
5061 mSecondWindow->assertNoEvents();
5062
5063 // Move to another window.
5064 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
5065 injectMotionEvent(mDispatcher, AMOTION_EVENT_ACTION_MOVE, AINPUT_SOURCE_TOUCHSCREEN,
5066 ADISPLAY_ID_DEFAULT, {150, 50}))
5067 << "Inject motion event should return InputEventInjectionResult::SUCCEEDED";
5068 mDragWindow->consumeMotionMove(ADISPLAY_ID_DEFAULT);
5069 mWindow->consumeDragEvent(true, 150, 50);
5070 mSecondWindow->consumeDragEvent(false, 50, 50);
5071
5072 // drop to another window.
5073 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
5074 injectMotionUp(mDispatcher, AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT,
5075 {150, 50}))
5076 << "Inject motion event should return InputEventInjectionResult::SUCCEEDED";
5077 mDragWindow->consumeMotionUp(ADISPLAY_ID_DEFAULT);
5078 mFakePolicy->assertDropTargetEquals(mSecondWindow->getToken());
5079 mWindow->assertNoEvents();
5080 mSecondWindow->assertNoEvents();
5081}
5082
arthurhung6d4bed92021-03-17 11:59:33 +08005083TEST_F(InputDispatcherDragTests, StylusDragAndDrop) {
5084 performStylusDrag();
5085
5086 // Move on window and keep button pressed.
5087 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
5088 injectMotionEvent(mDispatcher,
5089 MotionEventBuilder(AMOTION_EVENT_ACTION_MOVE, AINPUT_SOURCE_STYLUS)
5090 .buttonState(AMOTION_EVENT_BUTTON_STYLUS_PRIMARY)
5091 .pointer(PointerBuilder(0, AMOTION_EVENT_TOOL_TYPE_STYLUS)
5092 .x(50)
5093 .y(50))
5094 .build()))
5095 << "Inject motion event should return InputEventInjectionResult::SUCCEEDED";
5096 mDragWindow->consumeMotionMove(ADISPLAY_ID_DEFAULT);
5097 mWindow->consumeDragEvent(false, 50, 50);
5098 mSecondWindow->assertNoEvents();
5099
5100 // Move to another window and release button, expect to drop item.
5101 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
5102 injectMotionEvent(mDispatcher,
5103 MotionEventBuilder(AMOTION_EVENT_ACTION_MOVE, AINPUT_SOURCE_STYLUS)
5104 .buttonState(0)
5105 .pointer(PointerBuilder(0, AMOTION_EVENT_TOOL_TYPE_STYLUS)
5106 .x(150)
5107 .y(50))
5108 .build()))
5109 << "Inject motion event should return InputEventInjectionResult::SUCCEEDED";
5110 mDragWindow->consumeMotionMove(ADISPLAY_ID_DEFAULT);
5111 mWindow->assertNoEvents();
5112 mSecondWindow->assertNoEvents();
5113 mFakePolicy->assertDropTargetEquals(mSecondWindow->getToken());
5114
5115 // nothing to the window.
5116 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
5117 injectMotionEvent(mDispatcher,
5118 MotionEventBuilder(AMOTION_EVENT_ACTION_UP, AINPUT_SOURCE_STYLUS)
5119 .buttonState(0)
5120 .pointer(PointerBuilder(0, AMOTION_EVENT_TOOL_TYPE_STYLUS)
5121 .x(150)
5122 .y(50))
5123 .build()))
5124 << "Inject motion event should return InputEventInjectionResult::SUCCEEDED";
5125 mDragWindow->consumeMotionUp(ADISPLAY_ID_DEFAULT);
5126 mWindow->assertNoEvents();
5127 mSecondWindow->assertNoEvents();
5128}
5129
Arthur Hung6d0571e2021-04-09 20:18:16 +08005130TEST_F(InputDispatcherDragTests, DragAndDrop_InvalidWindow) {
5131 performDrag();
5132
5133 // Set second window invisible.
5134 mSecondWindow->setVisible(false);
5135 mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {mDragWindow, mWindow, mSecondWindow}}});
5136
5137 // Move on window.
5138 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
5139 injectMotionEvent(mDispatcher, AMOTION_EVENT_ACTION_MOVE, AINPUT_SOURCE_TOUCHSCREEN,
5140 ADISPLAY_ID_DEFAULT, {50, 50}))
5141 << "Inject motion event should return InputEventInjectionResult::SUCCEEDED";
5142 mDragWindow->consumeMotionMove(ADISPLAY_ID_DEFAULT);
5143 mWindow->consumeDragEvent(false, 50, 50);
5144 mSecondWindow->assertNoEvents();
5145
5146 // Move to another window.
5147 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
5148 injectMotionEvent(mDispatcher, AMOTION_EVENT_ACTION_MOVE, AINPUT_SOURCE_TOUCHSCREEN,
5149 ADISPLAY_ID_DEFAULT, {150, 50}))
5150 << "Inject motion event should return InputEventInjectionResult::SUCCEEDED";
5151 mDragWindow->consumeMotionMove(ADISPLAY_ID_DEFAULT);
5152 mWindow->consumeDragEvent(true, 150, 50);
5153 mSecondWindow->assertNoEvents();
5154
5155 // drop to another window.
5156 ASSERT_EQ(InputEventInjectionResult::SUCCEEDED,
5157 injectMotionUp(mDispatcher, AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT,
5158 {150, 50}))
5159 << "Inject motion event should return InputEventInjectionResult::SUCCEEDED";
5160 mDragWindow->consumeMotionUp(ADISPLAY_ID_DEFAULT);
5161 mFakePolicy->assertDropTargetEquals(nullptr);
5162 mWindow->assertNoEvents();
5163 mSecondWindow->assertNoEvents();
5164}
5165
Garfield Tane84e6f92019-08-29 17:28:41 -07005166} // namespace android::inputdispatcher