blob: 3bc5240eb6f7059a42fe6e591e18e8d22dd727c4 [file] [log] [blame]
Siarhei Vishniakouba0a8752021-09-14 14:43:25 -07001/*
2 * Copyright (C) 2022 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
17#pragma once
18
19#include <map>
20#include <set>
21
Siarhei Vishniakoua91d8572022-05-17 05:03:42 -070022#include <android-base/thread_annotations.h>
Siarhei Vishniakouba0a8752021-09-14 14:43:25 -070023#include "include/UnwantedInteractionBlockerInterface.h"
24#include "ui/events/ozone/evdev/touch_filter/neural_stylus_palm_detection_filter_util.h"
25#include "ui/events/ozone/evdev/touch_filter/palm_detection_filter.h"
26
Siarhei Vishniakou814ace32022-03-04 15:12:16 -080027#include "PreferStylusOverTouchBlocker.h"
28
Siarhei Vishniakouba0a8752021-09-14 14:43:25 -070029namespace android {
30
31// --- Functions for manipulation of event streams
32
33struct AndroidPalmFilterDeviceInfo : ::ui::PalmFilterDeviceInfo {
34 // Additional fields from 'TouchEventConverterEvdev', added here for convenience
35 int32_t touch_major_res = 1; // info.GetAbsInfoByCode(ABS_MT_TOUCH_MAJOR).resolution;
36 int32_t touch_minor_res = 1; // info.GetAbsInfoByCode(ABS_MT_TOUCH_MINOR).resolution;
37
38 auto operator<=>(const AndroidPalmFilterDeviceInfo&) const = default;
39};
40
41std::optional<AndroidPalmFilterDeviceInfo> createPalmFilterDeviceInfo(
42 const InputDeviceInfo& deviceInfo);
43
44static constexpr int32_t ACTION_UNKNOWN = -1;
45
Siarhei Vishniakou65735832022-08-09 19:18:37 +000046/**
47 * Remove the data for the provided pointers from the args. The pointers are identified by their
48 * pointerId, not by the index inside the array.
49 * Return the new NotifyMotionArgs struct that has the remaining pointers.
50 * The only fields that may be different in the returned args from the provided args are:
51 * - action
52 * - pointerCount
53 * - pointerProperties
54 * - pointerCoords
55 * Action might change because it contains a pointer index. If another pointer is removed, the
56 * active pointer index would be shifted.
57 *
58 * If the active pointer id is removed (for example, for events like
59 * POINTER_UP or POINTER_DOWN), then the action is set to ACTION_UNKNOWN. It is up to the caller
60 * to set the action appropriately after the call.
61 *
62 * @param args the args from which the pointers should be removed
63 * @param pointerIds the pointer ids of the pointers that should be removed
64 */
Siarhei Vishniakouba0a8752021-09-14 14:43:25 -070065NotifyMotionArgs removePointerIds(const NotifyMotionArgs& args,
66 const std::set<int32_t>& pointerIds);
67
68std::vector<NotifyMotionArgs> cancelSuppressedPointers(
69 const NotifyMotionArgs& args, const std::set<int32_t>& oldSuppressedPointerIds,
70 const std::set<int32_t>& newSuppressedPointerIds);
71
72std::string toString(const ::ui::InProgressTouchEvdev& touch);
73
74// --- Main classes and interfaces ---
75
76class PalmRejector;
77
78// --- Implementations ---
79
80/**
81 * Implementation of the UnwantedInteractionBlockerInterface.
82 * Represents a separate stage of input processing. All of the input events go through this stage.
83 * Acts as a passthrough for all input events except for motion events.
84 *
85 * The events of motion type are sent to PalmRejectors. PalmRejectors detect unwanted touches,
86 * and emit input streams with the bad pointers removed.
87 */
88class UnwantedInteractionBlocker : public UnwantedInteractionBlockerInterface {
89public:
90 explicit UnwantedInteractionBlocker(InputListenerInterface& listener);
91 explicit UnwantedInteractionBlocker(InputListenerInterface& listener, bool enablePalmRejection);
92
Prabir Pradhane3da4bb2023-04-05 23:51:23 +000093 void notifyInputDevicesChanged(const NotifyInputDevicesChangedArgs& args) override;
Siarhei Vishniakouba0a8752021-09-14 14:43:25 -070094 void notifyConfigurationChanged(const NotifyConfigurationChangedArgs* args) override;
95 void notifyKey(const NotifyKeyArgs* args) override;
96 void notifyMotion(const NotifyMotionArgs* args) override;
97 void notifySwitch(const NotifySwitchArgs* args) override;
98 void notifySensor(const NotifySensorArgs* args) override;
99 void notifyVibratorState(const NotifyVibratorStateArgs* args) override;
100 void notifyDeviceReset(const NotifyDeviceResetArgs* args) override;
101 void notifyPointerCaptureChanged(const NotifyPointerCaptureChangedArgs* args) override;
102
Siarhei Vishniakouba0a8752021-09-14 14:43:25 -0700103 void dump(std::string& dump) override;
104 void monitor() override;
105
106 ~UnwantedInteractionBlocker();
107
108private:
Siarhei Vishniakoua91d8572022-05-17 05:03:42 -0700109 std::mutex mLock;
Siarhei Vishniakouba0a8752021-09-14 14:43:25 -0700110 // The next stage to pass input events to
Siarhei Vishniakoua91d8572022-05-17 05:03:42 -0700111
112 QueuedInputListener mQueuedListener;
Siarhei Vishniakouba0a8752021-09-14 14:43:25 -0700113 const bool mEnablePalmRejection;
114
Siarhei Vishniakou814ace32022-03-04 15:12:16 -0800115 // When stylus is down, ignore touch
Siarhei Vishniakoua91d8572022-05-17 05:03:42 -0700116 PreferStylusOverTouchBlocker mPreferStylusOverTouchBlocker GUARDED_BY(mLock);
Siarhei Vishniakou814ace32022-03-04 15:12:16 -0800117
Siarhei Vishniakouba0a8752021-09-14 14:43:25 -0700118 // Detect and reject unwanted palms on screen
119 // Use a separate palm rejector for every touch device.
Siarhei Vishniakoua91d8572022-05-17 05:03:42 -0700120 std::map<int32_t /*deviceId*/, PalmRejector> mPalmRejectors GUARDED_BY(mLock);
Siarhei Vishniakou814ace32022-03-04 15:12:16 -0800121 // TODO(b/210159205): delete this when simultaneous stylus and touch is supported
Siarhei Vishniakoua91d8572022-05-17 05:03:42 -0700122 void notifyMotionLocked(const NotifyMotionArgs* args) REQUIRES(mLock);
Siarhei Vishniakoud5fe5182022-07-20 23:28:40 +0000123
124 // Call this function for outbound events so that they can be logged when logging is enabled.
125 void enqueueOutboundMotionLocked(const NotifyMotionArgs& args) REQUIRES(mLock);
Prabir Pradhane3da4bb2023-04-05 23:51:23 +0000126
127 void onInputDevicesChanged(const std::vector<InputDeviceInfo>& inputDevices);
Siarhei Vishniakouba0a8752021-09-14 14:43:25 -0700128};
129
130class SlotState {
131public:
132 /**
133 * Update the state using the new information provided in the NotifyMotionArgs
134 */
135 void update(const NotifyMotionArgs& args);
136 std::optional<size_t> getSlotForPointerId(int32_t pointerId) const;
137 std::string dump() const;
138
139private:
140 // Process a pointer with the provided action, and return the slot associated with it
141 void processPointerId(int32_t pointerId, int32_t action);
142 // The map from tracking id to slot state. Since the PalmRejectionFilter works close to the
143 // evdev level, the only way to tell it about UP or CANCEL events is by sending tracking id = -1
144 // to the appropriate touch slot. So we need to reconstruct the original slot.
145 // The two collections below must always be in-sync.
146 // Use std::map instead of std::unordered_map because we rely on these collections being
147 // ordered. It also has better space efficiency than unordered_map because we only have a few
148 // pointers most of the time.
149 std::map<int32_t /*pointerId*/, size_t /*slot*/> mSlotsByPointerId;
150 std::map<size_t /*slot*/, int32_t /*pointerId */> mPointerIdsBySlot;
151
152 size_t findUnusedSlot() const;
153};
154
155/**
156 * Convert an Android event to a linux-like 'InProgressTouchEvdev'. The provided SlotState's
157 * are used to figure out which slot does each pointer belong to.
158 */
159std::vector<::ui::InProgressTouchEvdev> getTouches(const NotifyMotionArgs& args,
160 const AndroidPalmFilterDeviceInfo& deviceInfo,
161 const SlotState& oldSlotState,
162 const SlotState& newSlotState);
163
164class PalmRejector {
165public:
166 explicit PalmRejector(const AndroidPalmFilterDeviceInfo& info,
167 std::unique_ptr<::ui::PalmDetectionFilter> filter = nullptr);
168 std::vector<NotifyMotionArgs> processMotion(const NotifyMotionArgs& args);
169
170 // Get the device info of this device, for comparison purposes
Siarhei Vishniakou88151b82022-08-11 00:53:38 +0000171 const AndroidPalmFilterDeviceInfo& getPalmFilterDeviceInfo() const;
Siarhei Vishniakouba0a8752021-09-14 14:43:25 -0700172 std::string dump() const;
173
174private:
175 PalmRejector(const PalmRejector&) = delete;
176 PalmRejector& operator=(const PalmRejector&) = delete;
177
Siarhei Vishniakoue491fb52022-08-11 01:51:24 +0000178 /**
179 * Update the slot state and send this event to the palm rejection model for palm detection.
180 * Return the pointer ids that should be suppressed.
181 *
182 * This function is not const because it has side-effects. It will update the slot state using
183 * the incoming args! Also, it will call Filter(..), which has side-effects.
184 */
185 std::set<int32_t> detectPalmPointers(const NotifyMotionArgs& args);
Siarhei Vishniakouba0a8752021-09-14 14:43:25 -0700186 std::unique_ptr<::ui::SharedPalmDetectionFilterState> mSharedPalmState;
187 AndroidPalmFilterDeviceInfo mDeviceInfo;
188 std::unique_ptr<::ui::PalmDetectionFilter> mPalmDetectionFilter;
189 std::set<int32_t> mSuppressedPointerIds;
190
191 // Used to help convert an Android touch stream to Linux input stream.
192 SlotState mSlotState;
193};
194
195} // namespace android