blob: c76fec7280f089a23530729e15cbf7cad7fd6df4 [file] [log] [blame]
Harry Cutts79cc9fa2022-10-28 15:32:39 +00001/*
2 * Copyright 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#include "../Macros.h"
18
Harry Cuttsa34de522023-06-06 15:52:54 +000019#include <algorithm>
Harry Cuttsbb24e272023-03-21 10:49:47 +000020#include <chrono>
Harry Cuttsa34de522023-06-06 15:52:54 +000021#include <iterator>
Harry Cuttsd35a24b2023-01-30 15:09:30 +000022#include <limits>
Harry Cuttsa34de522023-06-06 15:52:54 +000023#include <map>
Harry Cuttsedf6ce72023-01-04 12:15:53 +000024#include <optional>
25
Harry Cuttsbb24e272023-03-21 10:49:47 +000026#include <android-base/stringprintf.h>
Harry Cutts74235542022-11-24 15:52:53 +000027#include <android/input.h>
Harry Cutts8c7cb592023-08-23 17:20:13 +000028#include <com_android_input_flags.h>
Harry Cutts2b67ff12023-03-13 11:32:06 +000029#include <ftl/enum.h>
Harry Cuttsea73eaa2023-01-16 17:55:46 +000030#include <input/PrintTools.h>
Harry Cutts4fb941a2022-12-14 19:14:04 +000031#include <linux/input-event-codes.h>
Harry Cutts74235542022-11-24 15:52:53 +000032#include <log/log_main.h>
Harry Cuttsa34de522023-06-06 15:52:54 +000033#include <stats_pull_atom_callback.h>
34#include <statslog.h>
Harry Cutts74235542022-11-24 15:52:53 +000035#include "TouchCursorInputMapperCommon.h"
Harry Cutts79cc9fa2022-10-28 15:32:39 +000036#include "TouchpadInputMapper.h"
Harry Cutts3952c832023-08-22 15:26:56 +000037#include "gestures/HardwareProperties.h"
Harry Cutts8c7cb592023-08-23 17:20:13 +000038#include "gestures/TimerProvider.h"
Harry Cuttsedf6ce72023-01-04 12:15:53 +000039#include "ui/Rotation.h"
Harry Cutts79cc9fa2022-10-28 15:32:39 +000040
Harry Cutts8c7cb592023-08-23 17:20:13 +000041namespace input_flags = com::android::input::flags;
42
Harry Cutts79cc9fa2022-10-28 15:32:39 +000043namespace android {
44
Harry Cutts1f48a442022-11-15 17:38:36 +000045namespace {
46
Harry Cuttsc5025372023-02-21 16:04:45 +000047/**
48 * Log details of each gesture output by the gestures library.
49 * Enable this via "adb shell setprop log.tag.TouchpadInputMapperGestures DEBUG" (requires
50 * restarting the shell)
51 */
52const bool DEBUG_TOUCHPAD_GESTURES =
53 __android_log_is_loggable(ANDROID_LOG_DEBUG, "TouchpadInputMapperGestures",
54 ANDROID_LOG_INFO);
55
Harry Cuttsd35a24b2023-01-30 15:09:30 +000056// Describes a segment of the acceleration curve.
57struct CurveSegment {
58 // The maximum pointer speed which this segment should apply. The last segment in a curve should
59 // always set this to infinity.
60 double maxPointerSpeedMmPerS;
61 double slope;
62 double intercept;
63};
64
65const std::vector<CurveSegment> segments = {
Wenxin Fenge5d6d042023-07-06 17:40:45 -070066 {32.002, 3.19, 0},
67 {52.83, 4.79, -51.254},
68 {119.124, 7.28, -182.737},
69 {std::numeric_limits<double>::infinity(), 15.04, -1107.556},
Harry Cuttsd35a24b2023-01-30 15:09:30 +000070};
71
Wenxin Fenge5d6d042023-07-06 17:40:45 -070072const std::vector<double> sensitivityFactors = {1, 2, 4, 6, 7, 8, 9, 10,
73 11, 12, 13, 14, 16, 18, 20};
Harry Cuttsd35a24b2023-01-30 15:09:30 +000074
75std::vector<double> createAccelerationCurveForSensitivity(int32_t sensitivity,
76 size_t propertySize) {
77 LOG_ALWAYS_FATAL_IF(propertySize < 4 * segments.size());
78 std::vector<double> output(propertySize, 0);
79
80 // The Gestures library uses functions of the following form to define curve segments, where a,
81 // b, and c can be specified by us:
82 // output_speed(input_speed_mm) = a * input_speed_mm ^ 2 + b * input_speed_mm + c
83 //
84 // (a, b, and c are also called sqr_, mul_, and int_ in the Gestures library code.)
85 //
86 // We are trying to implement the following function, where slope and intercept are the
87 // parameters specified in the `segments` array above:
88 // gain(input_speed_mm) =
89 // 0.64 * (sensitivityFactor / 10) * (slope + intercept / input_speed_mm)
90 // Where "gain" is a multiplier applied to the input speed to produce the output speed:
91 // output_speed(input_speed_mm) = input_speed_mm * gain(input_speed_mm)
92 //
93 // To put our function in the library's form, we substitute it into the function above:
94 // output_speed(input_speed_mm) =
95 // input_speed_mm * (0.64 * (sensitivityFactor / 10) *
96 // (slope + 25.4 * intercept / input_speed_mm))
97 // then expand the brackets so that input_speed_mm cancels out for the intercept term:
98 // gain(input_speed_mm) =
99 // 0.64 * (sensitivityFactor / 10) * slope * input_speed_mm +
100 // 0.64 * (sensitivityFactor / 10) * intercept
101 //
102 // This gives us the following parameters for the Gestures library function form:
103 // a = 0
104 // b = 0.64 * (sensitivityFactor / 10) * slope
105 // c = 0.64 * (sensitivityFactor / 10) * intercept
106
107 double commonFactor = 0.64 * sensitivityFactors[sensitivity + 7] / 10;
108
109 size_t i = 0;
110 for (CurveSegment seg : segments) {
111 // The library's curve format consists of four doubles per segment:
112 // * maximum pointer speed for the segment (mm/s)
113 // * multiplier for the x² term (a.k.a. "a" or "sqr")
114 // * multiplier for the x term (a.k.a. "b" or "mul")
115 // * the intercept (a.k.a. "c" or "int")
116 // (see struct CurveSegment in the library's AccelFilterInterpreter)
117 output[i + 0] = seg.maxPointerSpeedMmPerS;
118 output[i + 1] = 0;
119 output[i + 2] = commonFactor * seg.slope;
120 output[i + 3] = commonFactor * seg.intercept;
121 i += 4;
122 }
123
124 return output;
125}
126
Harry Cutts74235542022-11-24 15:52:53 +0000127void gestureInterpreterCallback(void* clientData, const Gesture* gesture) {
128 TouchpadInputMapper* mapper = static_cast<TouchpadInputMapper*>(clientData);
129 mapper->consumeGesture(gesture);
130}
131
Prabir Pradhan67d09ca2023-09-08 20:28:55 +0000132int32_t linuxBusToInputDeviceBusEnum(int32_t linuxBus, bool isUsiStylus) {
133 if (isUsiStylus) {
134 // This is a stylus connected over the Universal Stylus Initiative (USI) protocol.
135 // For metrics purposes, we treat this protocol as a separate bus.
136 return util::INPUT_DEVICE_USAGE_REPORTED__DEVICE_BUS__USI;
137 }
138
Harry Cuttsa34de522023-06-06 15:52:54 +0000139 // When adding cases to this switch, also add them to the copy of this method in
140 // InputDeviceMetricsCollector.cpp.
141 // TODO(b/286394420): deduplicate this method with the one in InputDeviceMetricsCollector.cpp.
142 switch (linuxBus) {
143 case BUS_USB:
144 return util::INPUT_DEVICE_USAGE_REPORTED__DEVICE_BUS__USB;
145 case BUS_BLUETOOTH:
146 return util::INPUT_DEVICE_USAGE_REPORTED__DEVICE_BUS__BLUETOOTH;
147 default:
148 return util::INPUT_DEVICE_USAGE_REPORTED__DEVICE_BUS__OTHER;
149 }
150}
151
152class MetricsAccumulator {
153public:
154 static MetricsAccumulator& getInstance() {
155 static MetricsAccumulator sAccumulator;
156 return sAccumulator;
157 }
158
159 void recordFinger(const TouchpadInputMapper::MetricsIdentifier& id) { mCounters[id].fingers++; }
160
161 void recordPalm(const TouchpadInputMapper::MetricsIdentifier& id) { mCounters[id].palms++; }
162
163 // Checks whether a Gesture struct is for the end of a gesture that we log metrics for, and
164 // records it if so.
165 void processGesture(const TouchpadInputMapper::MetricsIdentifier& id, const Gesture& gesture) {
166 switch (gesture.type) {
167 case kGestureTypeFling:
168 if (gesture.details.fling.fling_state == GESTURES_FLING_START) {
169 // Indicates the end of a two-finger scroll gesture.
170 mCounters[id].twoFingerSwipeGestures++;
171 }
172 break;
173 case kGestureTypeSwipeLift:
174 mCounters[id].threeFingerSwipeGestures++;
175 break;
176 case kGestureTypeFourFingerSwipeLift:
177 mCounters[id].fourFingerSwipeGestures++;
178 break;
179 case kGestureTypePinch:
180 if (gesture.details.pinch.zoom_state == GESTURES_ZOOM_END) {
181 mCounters[id].pinchGestures++;
182 }
183 break;
184 default:
185 // We're not interested in any other gestures.
186 break;
187 }
188 }
189
190private:
191 MetricsAccumulator() {
192 AStatsManager_setPullAtomCallback(android::util::TOUCHPAD_USAGE, /*metadata=*/nullptr,
193 MetricsAccumulator::pullAtomCallback, /*cookie=*/nullptr);
194 }
195
196 ~MetricsAccumulator() { AStatsManager_clearPullAtomCallback(android::util::TOUCHPAD_USAGE); }
197
198 static AStatsManager_PullAtomCallbackReturn pullAtomCallback(int32_t atomTag,
199 AStatsEventList* outEventList,
200 void* cookie) {
201 LOG_ALWAYS_FATAL_IF(atomTag != android::util::TOUCHPAD_USAGE);
202 MetricsAccumulator& accumulator = MetricsAccumulator::getInstance();
203 accumulator.produceAtoms(outEventList);
204 accumulator.resetCounters();
205 return AStatsManager_PULL_SUCCESS;
206 }
207
208 void produceAtoms(AStatsEventList* outEventList) const {
209 for (auto& [id, counters] : mCounters) {
210 auto [busId, vendorId, productId, versionId] = id;
211 addAStatsEvent(outEventList, android::util::TOUCHPAD_USAGE, vendorId, productId,
Prabir Pradhan67d09ca2023-09-08 20:28:55 +0000212 versionId, linuxBusToInputDeviceBusEnum(busId, /*isUsi=*/false),
213 counters.fingers, counters.palms, counters.twoFingerSwipeGestures,
Harry Cuttsa34de522023-06-06 15:52:54 +0000214 counters.threeFingerSwipeGestures, counters.fourFingerSwipeGestures,
215 counters.pinchGestures);
216 }
217 }
218
219 void resetCounters() { mCounters.clear(); }
220
221 // Stores the counters for a specific touchpad model. Fields have the same meanings as those of
222 // the TouchpadUsage atom; see that definition for detailed documentation.
223 struct Counters {
224 int32_t fingers = 0;
225 int32_t palms = 0;
226
227 int32_t twoFingerSwipeGestures = 0;
228 int32_t threeFingerSwipeGestures = 0;
229 int32_t fourFingerSwipeGestures = 0;
230 int32_t pinchGestures = 0;
231 };
232
233 // Metrics are aggregated by device model and version, so if two devices of the same model and
234 // version are connected at once, they will have the same counters.
235 std::map<TouchpadInputMapper::MetricsIdentifier, Counters> mCounters;
236};
237
Harry Cutts1f48a442022-11-15 17:38:36 +0000238} // namespace
239
Arpit Singh8e6fb252023-04-06 11:49:17 +0000240TouchpadInputMapper::TouchpadInputMapper(InputDeviceContext& deviceContext,
241 const InputReaderConfiguration& readerConfig)
242 : InputMapper(deviceContext, readerConfig),
Harry Cutts1f48a442022-11-15 17:38:36 +0000243 mGestureInterpreter(NewGestureInterpreter(), DeleteGestureInterpreter),
Harry Cutts74235542022-11-24 15:52:53 +0000244 mPointerController(getContext()->getPointerController(getDeviceId())),
Harry Cutts8c7cb592023-08-23 17:20:13 +0000245 mTimerProvider(*getContext()),
Harry Cuttsbb24e272023-03-21 10:49:47 +0000246 mStateConverter(deviceContext, mMotionAccumulator),
247 mGestureConverter(*getContext(), deviceContext, getDeviceId()),
Harry Cuttsa34de522023-06-06 15:52:54 +0000248 mCapturedEventConverter(*getContext(), deviceContext, mMotionAccumulator, getDeviceId()),
249 mMetricsId(metricsIdFromInputDeviceIdentifier(deviceContext.getDeviceIdentifier())) {
Harry Cuttsbb24e272023-03-21 10:49:47 +0000250 RawAbsoluteAxisInfo slotAxisInfo;
251 deviceContext.getAbsoluteAxisInfo(ABS_MT_SLOT, &slotAxisInfo);
252 if (!slotAxisInfo.valid || slotAxisInfo.maxValue <= 0) {
253 ALOGW("Touchpad \"%s\" doesn't have a valid ABS_MT_SLOT axis, and probably won't work "
254 "properly.",
255 deviceContext.getName().c_str());
256 }
257 mMotionAccumulator.configure(deviceContext, slotAxisInfo.maxValue + 1, true);
258
Harry Cutts1f48a442022-11-15 17:38:36 +0000259 mGestureInterpreter->Initialize(GESTURES_DEVCLASS_TOUCHPAD);
260 mGestureInterpreter->SetHardwareProperties(createHardwareProperties(deviceContext));
Harry Cutts74235542022-11-24 15:52:53 +0000261 // Even though we don't explicitly delete copy/move semantics, it's safe to
Harry Cutts1b217912023-01-03 17:13:19 +0000262 // give away pointers to TouchpadInputMapper and its members here because
Harry Cutts74235542022-11-24 15:52:53 +0000263 // 1) mGestureInterpreter's lifecycle is determined by TouchpadInputMapper, and
264 // 2) TouchpadInputMapper is stored as a unique_ptr and not moved.
Harry Cutts1b217912023-01-03 17:13:19 +0000265 mGestureInterpreter->SetPropProvider(const_cast<GesturesPropProvider*>(&gesturePropProvider),
266 &mPropertyProvider);
Harry Cutts8c7cb592023-08-23 17:20:13 +0000267 if (input_flags::enable_gestures_library_timer_provider()) {
268 mGestureInterpreter->SetTimerProvider(const_cast<GesturesTimerProvider*>(
269 &kGestureTimerProvider),
270 &mTimerProvider);
271 }
Harry Cutts74235542022-11-24 15:52:53 +0000272 mGestureInterpreter->SetCallback(gestureInterpreterCallback, this);
Harry Cutts1f48a442022-11-15 17:38:36 +0000273}
Harry Cutts79cc9fa2022-10-28 15:32:39 +0000274
Harry Cutts74235542022-11-24 15:52:53 +0000275TouchpadInputMapper::~TouchpadInputMapper() {
276 if (mPointerController != nullptr) {
277 mPointerController->fade(PointerControllerInterface::Transition::IMMEDIATE);
278 }
Harry Cutts1b217912023-01-03 17:13:19 +0000279
Harry Cutts8c7cb592023-08-23 17:20:13 +0000280 // The gesture interpreter's destructor will try to free its property and timer providers,
281 // calling PropertyProvider::freeProperty and TimerProvider::freeTimer using a raw pointers.
282 // Depending on the declaration order in TouchpadInputMapper.h, those providers may have already
283 // been freed, causing allocation errors or use-after-free bugs. Depending on declaration order
284 // to avoid this seems rather fragile, so explicitly clear the providers here to ensure all the
285 // freeProperty and freeTimer calls happen before the providers are destructed.
Harry Cutts1b217912023-01-03 17:13:19 +0000286 mGestureInterpreter->SetPropProvider(nullptr, nullptr);
Harry Cutts8c7cb592023-08-23 17:20:13 +0000287 mGestureInterpreter->SetTimerProvider(nullptr, nullptr);
Harry Cutts74235542022-11-24 15:52:53 +0000288}
289
Harry Cutts79cc9fa2022-10-28 15:32:39 +0000290uint32_t TouchpadInputMapper::getSources() const {
291 return AINPUT_SOURCE_MOUSE | AINPUT_SOURCE_TOUCHPAD;
292}
293
Harry Cuttsd02ea102023-03-17 18:21:30 +0000294void TouchpadInputMapper::populateDeviceInfo(InputDeviceInfo& info) {
Harry Cutts8cd2abd2023-03-15 16:35:56 +0000295 InputMapper::populateDeviceInfo(info);
Harry Cuttsbb24e272023-03-21 10:49:47 +0000296 if (mPointerCaptured) {
297 mCapturedEventConverter.populateMotionRanges(info);
298 } else {
299 mGestureConverter.populateMotionRanges(info);
300 }
Harry Cutts8cd2abd2023-03-15 16:35:56 +0000301}
302
Harry Cuttsea73eaa2023-01-16 17:55:46 +0000303void TouchpadInputMapper::dump(std::string& dump) {
304 dump += INDENT2 "Touchpad Input Mapper:\n";
Harry Cuttsbb24e272023-03-21 10:49:47 +0000305 if (mResettingInterpreter) {
306 dump += INDENT3 "Currently resetting gesture interpreter\n";
307 }
308 dump += StringPrintf(INDENT3 "Pointer captured: %s\n", toString(mPointerCaptured));
Harry Cuttsea73eaa2023-01-16 17:55:46 +0000309 dump += INDENT3 "Gesture converter:\n";
310 dump += addLinePrefix(mGestureConverter.dump(), INDENT4);
311 dump += INDENT3 "Gesture properties:\n";
312 dump += addLinePrefix(mPropertyProvider.dump(), INDENT4);
Harry Cutts8c7cb592023-08-23 17:20:13 +0000313 if (input_flags::enable_gestures_library_timer_provider()) {
314 dump += INDENT3 "Timer provider:\n";
315 dump += addLinePrefix(mTimerProvider.dump(), INDENT4);
316 } else {
317 dump += INDENT3 "Timer provider: disabled by flag\n";
318 }
Harry Cuttsbb24e272023-03-21 10:49:47 +0000319 dump += INDENT3 "Captured event converter:\n";
320 dump += addLinePrefix(mCapturedEventConverter.dump(), INDENT4);
Josep del Riod0746382023-07-29 13:18:25 +0000321 dump += StringPrintf(INDENT3 "DisplayId: %s\n", toString(mDisplayId).c_str());
Harry Cuttsea73eaa2023-01-16 17:55:46 +0000322}
323
Arpit Singh4be4eef2023-03-28 14:26:01 +0000324std::list<NotifyArgs> TouchpadInputMapper::reconfigure(nsecs_t when,
Arpit Singhed6c3de2023-04-05 19:24:37 +0000325 const InputReaderConfiguration& config,
Prabir Pradhan4bf6d452023-04-18 21:26:56 +0000326 ConfigurationChanges changes) {
327 if (!changes.any()) {
Harry Cutts2b67ff12023-03-13 11:32:06 +0000328 // First time configuration
329 mPropertyProvider.loadPropertiesFromIdcFile(getDeviceContext().getConfiguration());
330 }
331
Prabir Pradhan4bf6d452023-04-18 21:26:56 +0000332 if (!changes.any() || changes.test(InputReaderConfiguration::Change::DISPLAY_INFO)) {
Josep del Riod0746382023-07-29 13:18:25 +0000333 mDisplayId = ADISPLAY_ID_NONE;
334 if (auto viewport = mDeviceContext.getAssociatedViewport(); viewport) {
335 // This InputDevice is associated with a viewport.
336 // Only generate events for the associated display.
337 const bool mismatchedPointerDisplay =
338 (viewport->displayId != mPointerController->getDisplayId());
339 if (mismatchedPointerDisplay) {
340 ALOGW("Touchpad \"%s\" associated viewport display does not match pointer "
341 "controller",
342 mDeviceContext.getName().c_str());
343 }
344 mDisplayId = mismatchedPointerDisplay ? std::nullopt
345 : std::make_optional(viewport->displayId);
346 } else {
347 // The InputDevice is not associated with a viewport, but it controls the mouse pointer.
348 mDisplayId = mPointerController->getDisplayId();
349 }
350
Harry Cuttsedf6ce72023-01-04 12:15:53 +0000351 ui::Rotation orientation = ui::ROTATION_0;
Josep del Riod0746382023-07-29 13:18:25 +0000352 if (mDisplayId.has_value()) {
353 if (auto viewport = config.getDisplayViewportById(*mDisplayId); viewport) {
Harry Cuttsedf6ce72023-01-04 12:15:53 +0000354 orientation = getInverseRotation(viewport->orientation);
355 }
356 }
Josep del Riod0746382023-07-29 13:18:25 +0000357 mGestureConverter.setDisplayId(mDisplayId);
Harry Cuttsedf6ce72023-01-04 12:15:53 +0000358 mGestureConverter.setOrientation(orientation);
359 }
Prabir Pradhan4bf6d452023-04-18 21:26:56 +0000360 if (!changes.any() || changes.test(InputReaderConfiguration::Change::TOUCHPAD_SETTINGS)) {
Harry Cuttsd35a24b2023-01-30 15:09:30 +0000361 mPropertyProvider.getProperty("Use Custom Touchpad Pointer Accel Curve")
362 .setBoolValues({true});
363 GesturesProp accelCurveProp = mPropertyProvider.getProperty("Pointer Accel Curve");
364 accelCurveProp.setRealValues(
Arpit Singhed6c3de2023-04-05 19:24:37 +0000365 createAccelerationCurveForSensitivity(config.touchpadPointerSpeed,
Harry Cuttsd35a24b2023-01-30 15:09:30 +0000366 accelCurveProp.getCount()));
Wenxin Feng1ca50662023-05-03 14:00:12 -0700367 mPropertyProvider.getProperty("Use Custom Touchpad Scroll Accel Curve")
368 .setBoolValues({true});
369 GesturesProp scrollCurveProp = mPropertyProvider.getProperty("Scroll Accel Curve");
370 scrollCurveProp.setRealValues(
371 createAccelerationCurveForSensitivity(config.touchpadPointerSpeed,
372 scrollCurveProp.getCount()));
373 mPropertyProvider.getProperty("Scroll X Out Scale").setRealValues({1.0});
374 mPropertyProvider.getProperty("Scroll Y Out Scale").setRealValues({1.0});
Harry Cuttsa546ba82023-01-13 17:21:00 +0000375 mPropertyProvider.getProperty("Invert Scrolling")
Arpit Singhed6c3de2023-04-05 19:24:37 +0000376 .setBoolValues({config.touchpadNaturalScrollingEnabled});
Harry Cuttsa546ba82023-01-13 17:21:00 +0000377 mPropertyProvider.getProperty("Tap Enable")
Arpit Singhed6c3de2023-04-05 19:24:37 +0000378 .setBoolValues({config.touchpadTapToClickEnabled});
Harry Cuttsa546ba82023-01-13 17:21:00 +0000379 mPropertyProvider.getProperty("Button Right Click Zone Enable")
Arpit Singhed6c3de2023-04-05 19:24:37 +0000380 .setBoolValues({config.touchpadRightClickZoneEnabled});
Harry Cuttsa546ba82023-01-13 17:21:00 +0000381 }
Harry Cuttsbb24e272023-03-21 10:49:47 +0000382 std::list<NotifyArgs> out;
383 if ((!changes.any() && config.pointerCaptureRequest.enable) ||
384 changes.test(InputReaderConfiguration::Change::POINTER_CAPTURE)) {
385 mPointerCaptured = config.pointerCaptureRequest.enable;
386 // The motion ranges are going to change, so bump the generation to clear the cached ones.
387 bumpGeneration();
388 if (mPointerCaptured) {
389 // The touchpad is being captured, so we need to tidy up any fake fingers etc. that are
390 // still being reported for a gesture in progress.
391 out += reset(when);
392 mPointerController->fade(PointerControllerInterface::Transition::IMMEDIATE);
393 } else {
394 // We're transitioning from captured to uncaptured.
395 mCapturedEventConverter.reset();
396 }
397 if (changes.any()) {
398 out.push_back(NotifyDeviceResetArgs(getContext()->getNextId(), when, getDeviceId()));
399 }
400 }
401 return out;
Harry Cuttsedf6ce72023-01-04 12:15:53 +0000402}
403
Harry Cutts1f48a442022-11-15 17:38:36 +0000404std::list<NotifyArgs> TouchpadInputMapper::reset(nsecs_t when) {
Harry Cutts47db1c72022-12-13 19:20:47 +0000405 mStateConverter.reset();
Harry Cuttsbb24e272023-03-21 10:49:47 +0000406 resetGestureInterpreter(when);
Harry Cuttse9b71422023-03-14 16:54:44 +0000407 std::list<NotifyArgs> out = mGestureConverter.reset(when);
408 out += InputMapper::reset(when);
409 return out;
Harry Cutts1f48a442022-11-15 17:38:36 +0000410}
411
Harry Cuttsbb24e272023-03-21 10:49:47 +0000412void TouchpadInputMapper::resetGestureInterpreter(nsecs_t when) {
413 // The GestureInterpreter has no official reset method, but sending a HardwareState with no
414 // fingers down or buttons pressed should get it into a clean state.
415 HardwareState state;
416 state.timestamp = std::chrono::duration<stime_t>(std::chrono::nanoseconds(when)).count();
417 mResettingInterpreter = true;
418 mGestureInterpreter->PushHardwareState(&state);
419 mResettingInterpreter = false;
420}
421
Harry Cutts79cc9fa2022-10-28 15:32:39 +0000422std::list<NotifyArgs> TouchpadInputMapper::process(const RawEvent* rawEvent) {
Harry Cuttsbb24e272023-03-21 10:49:47 +0000423 if (mPointerCaptured) {
424 return mCapturedEventConverter.process(*rawEvent);
425 }
Harry Cutts47db1c72022-12-13 19:20:47 +0000426 std::optional<SelfContainedHardwareState> state = mStateConverter.processRawEvent(rawEvent);
427 if (state) {
Harry Cuttsa34de522023-06-06 15:52:54 +0000428 updatePalmDetectionMetrics();
Harry Cutts47db1c72022-12-13 19:20:47 +0000429 return sendHardwareState(rawEvent->when, rawEvent->readTime, *state);
430 } else {
431 return {};
Harry Cutts1f48a442022-11-15 17:38:36 +0000432 }
Harry Cutts79cc9fa2022-10-28 15:32:39 +0000433}
434
Harry Cuttsa34de522023-06-06 15:52:54 +0000435void TouchpadInputMapper::updatePalmDetectionMetrics() {
436 std::set<int32_t> currentTrackingIds;
437 for (size_t i = 0; i < mMotionAccumulator.getSlotCount(); i++) {
438 const MultiTouchMotionAccumulator::Slot& slot = mMotionAccumulator.getSlot(i);
439 if (!slot.isInUse()) {
440 continue;
441 }
442 currentTrackingIds.insert(slot.getTrackingId());
443 if (slot.getToolType() == ToolType::PALM) {
444 mPalmTrackingIds.insert(slot.getTrackingId());
445 }
446 }
447 std::vector<int32_t> liftedTouches;
448 std::set_difference(mLastFrameTrackingIds.begin(), mLastFrameTrackingIds.end(),
449 currentTrackingIds.begin(), currentTrackingIds.end(),
450 std::inserter(liftedTouches, liftedTouches.begin()));
451 for (int32_t trackingId : liftedTouches) {
452 if (mPalmTrackingIds.erase(trackingId) > 0) {
453 MetricsAccumulator::getInstance().recordPalm(mMetricsId);
454 } else {
455 MetricsAccumulator::getInstance().recordFinger(mMetricsId);
456 }
457 }
458 mLastFrameTrackingIds = currentTrackingIds;
459}
460
Harry Cutts47db1c72022-12-13 19:20:47 +0000461std::list<NotifyArgs> TouchpadInputMapper::sendHardwareState(nsecs_t when, nsecs_t readTime,
462 SelfContainedHardwareState schs) {
Harry Cutts287e19f2023-02-27 17:09:24 +0000463 ALOGD_IF(DEBUG_TOUCHPAD_GESTURES, "New hardware state: %s", schs.state.String().c_str());
Harry Cutts47db1c72022-12-13 19:20:47 +0000464 mGestureInterpreter->PushHardwareState(&schs.state);
Harry Cutts47db1c72022-12-13 19:20:47 +0000465 return processGestures(when, readTime);
Harry Cutts74235542022-11-24 15:52:53 +0000466}
467
Harry Cutts8c7cb592023-08-23 17:20:13 +0000468std::list<NotifyArgs> TouchpadInputMapper::timeoutExpired(nsecs_t when) {
469 if (!input_flags::enable_gestures_library_timer_provider()) {
470 return {};
471 }
472 mTimerProvider.triggerCallbacks(when);
473 return processGestures(when, when);
474}
475
Harry Cutts74235542022-11-24 15:52:53 +0000476void TouchpadInputMapper::consumeGesture(const Gesture* gesture) {
Harry Cuttsc5025372023-02-21 16:04:45 +0000477 ALOGD_IF(DEBUG_TOUCHPAD_GESTURES, "Gesture ready: %s", gesture->String().c_str());
Harry Cuttsbb24e272023-03-21 10:49:47 +0000478 if (mResettingInterpreter) {
479 // We already handle tidying up fake fingers etc. in GestureConverter::reset, so we should
480 // ignore any gestures produced from the interpreter while we're resetting it.
481 return;
482 }
Harry Cutts74235542022-11-24 15:52:53 +0000483 mGesturesToProcess.push_back(*gesture);
484}
485
486std::list<NotifyArgs> TouchpadInputMapper::processGestures(nsecs_t when, nsecs_t readTime) {
487 std::list<NotifyArgs> out = {};
Josep del Riod0746382023-07-29 13:18:25 +0000488 if (mDisplayId) {
489 MetricsAccumulator& metricsAccumulator = MetricsAccumulator::getInstance();
490 for (Gesture& gesture : mGesturesToProcess) {
491 out += mGestureConverter.handleGesture(when, readTime, gesture);
492 metricsAccumulator.processGesture(mMetricsId, gesture);
493 }
Harry Cutts74235542022-11-24 15:52:53 +0000494 }
495 mGesturesToProcess.clear();
496 return out;
497}
498
Josep del Riod0746382023-07-29 13:18:25 +0000499std::optional<int32_t> TouchpadInputMapper::getAssociatedDisplayId() {
500 return mDisplayId;
501}
502
Harry Cutts79cc9fa2022-10-28 15:32:39 +0000503} // namespace android