blob: 5d0dde8e6439d32b2107e2042a8633660e3a033a [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
93 void notifyConfigurationChanged(const NotifyConfigurationChangedArgs* args) override;
94 void notifyKey(const NotifyKeyArgs* args) override;
95 void notifyMotion(const NotifyMotionArgs* args) override;
96 void notifySwitch(const NotifySwitchArgs* args) override;
97 void notifySensor(const NotifySensorArgs* args) override;
98 void notifyVibratorState(const NotifyVibratorStateArgs* args) override;
99 void notifyDeviceReset(const NotifyDeviceResetArgs* args) override;
100 void notifyPointerCaptureChanged(const NotifyPointerCaptureChangedArgs* args) override;
101
102 void notifyInputDevicesChanged(const std::vector<InputDeviceInfo>& inputDevices) override;
103 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);
Siarhei Vishniakouba0a8752021-09-14 14:43:25 -0700126};
127
128class SlotState {
129public:
130 /**
131 * Update the state using the new information provided in the NotifyMotionArgs
132 */
133 void update(const NotifyMotionArgs& args);
134 std::optional<size_t> getSlotForPointerId(int32_t pointerId) const;
135 std::string dump() const;
136
137private:
138 // Process a pointer with the provided action, and return the slot associated with it
139 void processPointerId(int32_t pointerId, int32_t action);
140 // The map from tracking id to slot state. Since the PalmRejectionFilter works close to the
141 // evdev level, the only way to tell it about UP or CANCEL events is by sending tracking id = -1
142 // to the appropriate touch slot. So we need to reconstruct the original slot.
143 // The two collections below must always be in-sync.
144 // Use std::map instead of std::unordered_map because we rely on these collections being
145 // ordered. It also has better space efficiency than unordered_map because we only have a few
146 // pointers most of the time.
147 std::map<int32_t /*pointerId*/, size_t /*slot*/> mSlotsByPointerId;
148 std::map<size_t /*slot*/, int32_t /*pointerId */> mPointerIdsBySlot;
149
150 size_t findUnusedSlot() const;
151};
152
153/**
154 * Convert an Android event to a linux-like 'InProgressTouchEvdev'. The provided SlotState's
155 * are used to figure out which slot does each pointer belong to.
156 */
157std::vector<::ui::InProgressTouchEvdev> getTouches(const NotifyMotionArgs& args,
158 const AndroidPalmFilterDeviceInfo& deviceInfo,
159 const SlotState& oldSlotState,
160 const SlotState& newSlotState);
161
162class PalmRejector {
163public:
164 explicit PalmRejector(const AndroidPalmFilterDeviceInfo& info,
165 std::unique_ptr<::ui::PalmDetectionFilter> filter = nullptr);
166 std::vector<NotifyMotionArgs> processMotion(const NotifyMotionArgs& args);
167
168 // Get the device info of this device, for comparison purposes
Siarhei Vishniakou88151b82022-08-11 00:53:38 +0000169 const AndroidPalmFilterDeviceInfo& getPalmFilterDeviceInfo() const;
Siarhei Vishniakouba0a8752021-09-14 14:43:25 -0700170 std::string dump() const;
171
172private:
173 PalmRejector(const PalmRejector&) = delete;
174 PalmRejector& operator=(const PalmRejector&) = delete;
175
Siarhei Vishniakoue491fb52022-08-11 01:51:24 +0000176 /**
177 * Update the slot state and send this event to the palm rejection model for palm detection.
178 * Return the pointer ids that should be suppressed.
179 *
180 * This function is not const because it has side-effects. It will update the slot state using
181 * the incoming args! Also, it will call Filter(..), which has side-effects.
182 */
183 std::set<int32_t> detectPalmPointers(const NotifyMotionArgs& args);
Siarhei Vishniakouba0a8752021-09-14 14:43:25 -0700184 std::unique_ptr<::ui::SharedPalmDetectionFilterState> mSharedPalmState;
185 AndroidPalmFilterDeviceInfo mDeviceInfo;
186 std::unique_ptr<::ui::PalmDetectionFilter> mPalmDetectionFilter;
187 std::set<int32_t> mSuppressedPointerIds;
188
189 // Used to help convert an Android touch stream to Linux input stream.
190 SlotState mSlotState;
191};
192
193} // namespace android