1 //
2 // Copyright 2010 The Android Open Source Project
3 //
4 // Provides a shared memory transport for input events.
5 //
6 #define LOG_TAG "InputTransport"
7
8 //#define LOG_NDEBUG 0
9
10 // Log debug messages about channel messages (send message, receive message)
11 #define DEBUG_CHANNEL_MESSAGES 0
12
13 // Log debug messages whenever InputChannel objects are created/destroyed
14 static constexpr bool DEBUG_CHANNEL_LIFECYCLE = false;
15
16 // Log debug messages about transport actions
17 static constexpr bool DEBUG_TRANSPORT_ACTIONS = false;
18
19 // Log debug messages about touch event resampling
20 #define DEBUG_RESAMPLING 0
21
22 #include <errno.h>
23 #include <fcntl.h>
24 #include <inttypes.h>
25 #include <math.h>
26 #include <sys/socket.h>
27 #include <sys/types.h>
28 #include <unistd.h>
29
30 #include <android-base/stringprintf.h>
31 #include <binder/Parcel.h>
32 #include <cutils/properties.h>
33 #include <ftl/enum.h>
34 #include <log/log.h>
35 #include <utils/Trace.h>
36
37 #include <input/InputTransport.h>
38
39 using android::base::StringPrintf;
40
41 namespace android {
42
43 // Socket buffer size. The default is typically about 128KB, which is much larger than
44 // we really need. So we make it smaller. It just needs to be big enough to hold
45 // a few dozen large multi-finger motion events in the case where an application gets
46 // behind processing touches.
47 static const size_t SOCKET_BUFFER_SIZE = 32 * 1024;
48
49 // Nanoseconds per milliseconds.
50 static const nsecs_t NANOS_PER_MS = 1000000;
51
52 // Latency added during resampling. A few milliseconds doesn't hurt much but
53 // reduces the impact of mispredicted touch positions.
54 static const nsecs_t RESAMPLE_LATENCY = 5 * NANOS_PER_MS;
55
56 // Minimum time difference between consecutive samples before attempting to resample.
57 static const nsecs_t RESAMPLE_MIN_DELTA = 2 * NANOS_PER_MS;
58
59 // Maximum time difference between consecutive samples before attempting to resample
60 // by extrapolation.
61 static const nsecs_t RESAMPLE_MAX_DELTA = 20 * NANOS_PER_MS;
62
63 // Maximum time to predict forward from the last known state, to avoid predicting too
64 // far into the future. This time is further bounded by 50% of the last time delta.
65 static const nsecs_t RESAMPLE_MAX_PREDICTION = 8 * NANOS_PER_MS;
66
67 /**
68 * System property for enabling / disabling touch resampling.
69 * Resampling extrapolates / interpolates the reported touch event coordinates to better
70 * align them to the VSYNC signal, thus resulting in smoother scrolling performance.
71 * Resampling is not needed (and should be disabled) on hardware that already
72 * has touch events triggered by VSYNC.
73 * Set to "1" to enable resampling (default).
74 * Set to "0" to disable resampling.
75 * Resampling is enabled by default.
76 */
77 static const char* PROPERTY_RESAMPLING_ENABLED = "ro.input.resampling";
78
79 template<typename T>
min(const T & a,const T & b)80 inline static T min(const T& a, const T& b) {
81 return a < b ? a : b;
82 }
83
lerp(float a,float b,float alpha)84 inline static float lerp(float a, float b, float alpha) {
85 return a + alpha * (b - a);
86 }
87
isPointerEvent(int32_t source)88 inline static bool isPointerEvent(int32_t source) {
89 return (source & AINPUT_SOURCE_CLASS_POINTER) == AINPUT_SOURCE_CLASS_POINTER;
90 }
91
toString(bool value)92 inline static const char* toString(bool value) {
93 return value ? "true" : "false";
94 }
95
96 // --- InputMessage ---
97
isValid(size_t actualSize) const98 bool InputMessage::isValid(size_t actualSize) const {
99 if (size() != actualSize) {
100 ALOGE("Received message of incorrect size %zu (expected %zu)", actualSize, size());
101 return false;
102 }
103
104 switch (header.type) {
105 case Type::KEY:
106 return true;
107 case Type::MOTION: {
108 const bool valid =
109 body.motion.pointerCount > 0 && body.motion.pointerCount <= MAX_POINTERS;
110 if (!valid) {
111 ALOGE("Received invalid MOTION: pointerCount = %" PRIu32, body.motion.pointerCount);
112 }
113 return valid;
114 }
115 case Type::FINISHED:
116 case Type::FOCUS:
117 case Type::CAPTURE:
118 case Type::DRAG:
119 case Type::TOUCH_MODE:
120 return true;
121 case Type::TIMELINE: {
122 const nsecs_t gpuCompletedTime =
123 body.timeline.graphicsTimeline[GraphicsTimeline::GPU_COMPLETED_TIME];
124 const nsecs_t presentTime =
125 body.timeline.graphicsTimeline[GraphicsTimeline::PRESENT_TIME];
126 const bool valid = presentTime > gpuCompletedTime;
127 if (!valid) {
128 ALOGE("Received invalid TIMELINE: gpuCompletedTime = %" PRId64
129 " presentTime = %" PRId64,
130 gpuCompletedTime, presentTime);
131 }
132 return valid;
133 }
134 }
135 ALOGE("Invalid message type: %" PRIu32, header.type);
136 return false;
137 }
138
size() const139 size_t InputMessage::size() const {
140 switch (header.type) {
141 case Type::KEY:
142 return sizeof(Header) + body.key.size();
143 case Type::MOTION:
144 return sizeof(Header) + body.motion.size();
145 case Type::FINISHED:
146 return sizeof(Header) + body.finished.size();
147 case Type::FOCUS:
148 return sizeof(Header) + body.focus.size();
149 case Type::CAPTURE:
150 return sizeof(Header) + body.capture.size();
151 case Type::DRAG:
152 return sizeof(Header) + body.drag.size();
153 case Type::TIMELINE:
154 return sizeof(Header) + body.timeline.size();
155 case Type::TOUCH_MODE:
156 return sizeof(Header) + body.touchMode.size();
157 }
158 return sizeof(Header);
159 }
160
161 /**
162 * There could be non-zero bytes in-between InputMessage fields. Force-initialize the entire
163 * memory to zero, then only copy the valid bytes on a per-field basis.
164 */
getSanitizedCopy(InputMessage * msg) const165 void InputMessage::getSanitizedCopy(InputMessage* msg) const {
166 memset(msg, 0, sizeof(*msg));
167
168 // Write the header
169 msg->header.type = header.type;
170 msg->header.seq = header.seq;
171
172 // Write the body
173 switch(header.type) {
174 case InputMessage::Type::KEY: {
175 // int32_t eventId
176 msg->body.key.eventId = body.key.eventId;
177 // nsecs_t eventTime
178 msg->body.key.eventTime = body.key.eventTime;
179 // int32_t deviceId
180 msg->body.key.deviceId = body.key.deviceId;
181 // int32_t source
182 msg->body.key.source = body.key.source;
183 // int32_t displayId
184 msg->body.key.displayId = body.key.displayId;
185 // std::array<uint8_t, 32> hmac
186 msg->body.key.hmac = body.key.hmac;
187 // int32_t action
188 msg->body.key.action = body.key.action;
189 // int32_t flags
190 msg->body.key.flags = body.key.flags;
191 // int32_t keyCode
192 msg->body.key.keyCode = body.key.keyCode;
193 // int32_t scanCode
194 msg->body.key.scanCode = body.key.scanCode;
195 // int32_t metaState
196 msg->body.key.metaState = body.key.metaState;
197 // int32_t repeatCount
198 msg->body.key.repeatCount = body.key.repeatCount;
199 // nsecs_t downTime
200 msg->body.key.downTime = body.key.downTime;
201 break;
202 }
203 case InputMessage::Type::MOTION: {
204 // int32_t eventId
205 msg->body.motion.eventId = body.motion.eventId;
206 // uint32_t pointerCount
207 msg->body.motion.pointerCount = body.motion.pointerCount;
208 // nsecs_t eventTime
209 msg->body.motion.eventTime = body.motion.eventTime;
210 // int32_t deviceId
211 msg->body.motion.deviceId = body.motion.deviceId;
212 // int32_t source
213 msg->body.motion.source = body.motion.source;
214 // int32_t displayId
215 msg->body.motion.displayId = body.motion.displayId;
216 // std::array<uint8_t, 32> hmac
217 msg->body.motion.hmac = body.motion.hmac;
218 // int32_t action
219 msg->body.motion.action = body.motion.action;
220 // int32_t actionButton
221 msg->body.motion.actionButton = body.motion.actionButton;
222 // int32_t flags
223 msg->body.motion.flags = body.motion.flags;
224 // int32_t metaState
225 msg->body.motion.metaState = body.motion.metaState;
226 // int32_t buttonState
227 msg->body.motion.buttonState = body.motion.buttonState;
228 // MotionClassification classification
229 msg->body.motion.classification = body.motion.classification;
230 // int32_t edgeFlags
231 msg->body.motion.edgeFlags = body.motion.edgeFlags;
232 // nsecs_t downTime
233 msg->body.motion.downTime = body.motion.downTime;
234
235 msg->body.motion.dsdx = body.motion.dsdx;
236 msg->body.motion.dtdx = body.motion.dtdx;
237 msg->body.motion.dtdy = body.motion.dtdy;
238 msg->body.motion.dsdy = body.motion.dsdy;
239 msg->body.motion.tx = body.motion.tx;
240 msg->body.motion.ty = body.motion.ty;
241
242 // float xPrecision
243 msg->body.motion.xPrecision = body.motion.xPrecision;
244 // float yPrecision
245 msg->body.motion.yPrecision = body.motion.yPrecision;
246 // float xCursorPosition
247 msg->body.motion.xCursorPosition = body.motion.xCursorPosition;
248 // float yCursorPosition
249 msg->body.motion.yCursorPosition = body.motion.yCursorPosition;
250
251 msg->body.motion.dsdxRaw = body.motion.dsdxRaw;
252 msg->body.motion.dtdxRaw = body.motion.dtdxRaw;
253 msg->body.motion.dtdyRaw = body.motion.dtdyRaw;
254 msg->body.motion.dsdyRaw = body.motion.dsdyRaw;
255 msg->body.motion.txRaw = body.motion.txRaw;
256 msg->body.motion.tyRaw = body.motion.tyRaw;
257
258 //struct Pointer pointers[MAX_POINTERS]
259 for (size_t i = 0; i < body.motion.pointerCount; i++) {
260 // PointerProperties properties
261 msg->body.motion.pointers[i].properties.id = body.motion.pointers[i].properties.id;
262 msg->body.motion.pointers[i].properties.toolType =
263 body.motion.pointers[i].properties.toolType,
264 // PointerCoords coords
265 msg->body.motion.pointers[i].coords.bits = body.motion.pointers[i].coords.bits;
266 const uint32_t count = BitSet64::count(body.motion.pointers[i].coords.bits);
267 memcpy(&msg->body.motion.pointers[i].coords.values[0],
268 &body.motion.pointers[i].coords.values[0],
269 count * (sizeof(body.motion.pointers[i].coords.values[0])));
270 }
271 break;
272 }
273 case InputMessage::Type::FINISHED: {
274 msg->body.finished.handled = body.finished.handled;
275 msg->body.finished.consumeTime = body.finished.consumeTime;
276 break;
277 }
278 case InputMessage::Type::FOCUS: {
279 msg->body.focus.eventId = body.focus.eventId;
280 msg->body.focus.hasFocus = body.focus.hasFocus;
281 break;
282 }
283 case InputMessage::Type::CAPTURE: {
284 msg->body.capture.eventId = body.capture.eventId;
285 msg->body.capture.pointerCaptureEnabled = body.capture.pointerCaptureEnabled;
286 break;
287 }
288 case InputMessage::Type::DRAG: {
289 msg->body.drag.eventId = body.drag.eventId;
290 msg->body.drag.x = body.drag.x;
291 msg->body.drag.y = body.drag.y;
292 msg->body.drag.isExiting = body.drag.isExiting;
293 break;
294 }
295 case InputMessage::Type::TIMELINE: {
296 msg->body.timeline.eventId = body.timeline.eventId;
297 msg->body.timeline.graphicsTimeline = body.timeline.graphicsTimeline;
298 break;
299 }
300 case InputMessage::Type::TOUCH_MODE: {
301 msg->body.touchMode.eventId = body.touchMode.eventId;
302 msg->body.touchMode.isInTouchMode = body.touchMode.isInTouchMode;
303 }
304 }
305 }
306
307 // --- InputChannel ---
308
create(const std::string & name,android::base::unique_fd fd,sp<IBinder> token)309 std::unique_ptr<InputChannel> InputChannel::create(const std::string& name,
310 android::base::unique_fd fd, sp<IBinder> token) {
311 const int result = fcntl(fd, F_SETFL, O_NONBLOCK);
312 if (result != 0) {
313 LOG_ALWAYS_FATAL("channel '%s' ~ Could not make socket non-blocking: %s", name.c_str(),
314 strerror(errno));
315 return nullptr;
316 }
317 // using 'new' to access a non-public constructor
318 return std::unique_ptr<InputChannel>(new InputChannel(name, std::move(fd), token));
319 }
320
InputChannel(const std::string name,android::base::unique_fd fd,sp<IBinder> token)321 InputChannel::InputChannel(const std::string name, android::base::unique_fd fd, sp<IBinder> token)
322 : mName(std::move(name)), mFd(std::move(fd)), mToken(std::move(token)) {
323 if (DEBUG_CHANNEL_LIFECYCLE) {
324 ALOGD("Input channel constructed: name='%s', fd=%d", getName().c_str(), getFd().get());
325 }
326 }
327
~InputChannel()328 InputChannel::~InputChannel() {
329 if (DEBUG_CHANNEL_LIFECYCLE) {
330 ALOGD("Input channel destroyed: name='%s', fd=%d", getName().c_str(), getFd().get());
331 }
332 }
333
openInputChannelPair(const std::string & name,std::unique_ptr<InputChannel> & outServerChannel,std::unique_ptr<InputChannel> & outClientChannel)334 status_t InputChannel::openInputChannelPair(const std::string& name,
335 std::unique_ptr<InputChannel>& outServerChannel,
336 std::unique_ptr<InputChannel>& outClientChannel) {
337 int sockets[2];
338 if (socketpair(AF_UNIX, SOCK_SEQPACKET, 0, sockets)) {
339 status_t result = -errno;
340 ALOGE("channel '%s' ~ Could not create socket pair. errno=%s(%d)", name.c_str(),
341 strerror(errno), errno);
342 outServerChannel.reset();
343 outClientChannel.reset();
344 return result;
345 }
346
347 int bufferSize = SOCKET_BUFFER_SIZE;
348 setsockopt(sockets[0], SOL_SOCKET, SO_SNDBUF, &bufferSize, sizeof(bufferSize));
349 setsockopt(sockets[0], SOL_SOCKET, SO_RCVBUF, &bufferSize, sizeof(bufferSize));
350 setsockopt(sockets[1], SOL_SOCKET, SO_SNDBUF, &bufferSize, sizeof(bufferSize));
351 setsockopt(sockets[1], SOL_SOCKET, SO_RCVBUF, &bufferSize, sizeof(bufferSize));
352
353 sp<IBinder> token = new BBinder();
354
355 std::string serverChannelName = name + " (server)";
356 android::base::unique_fd serverFd(sockets[0]);
357 outServerChannel = InputChannel::create(serverChannelName, std::move(serverFd), token);
358
359 std::string clientChannelName = name + " (client)";
360 android::base::unique_fd clientFd(sockets[1]);
361 outClientChannel = InputChannel::create(clientChannelName, std::move(clientFd), token);
362 return OK;
363 }
364
sendMessage(const InputMessage * msg)365 status_t InputChannel::sendMessage(const InputMessage* msg) {
366 const size_t msgLength = msg->size();
367 InputMessage cleanMsg;
368 msg->getSanitizedCopy(&cleanMsg);
369 ssize_t nWrite;
370 do {
371 nWrite = ::send(getFd(), &cleanMsg, msgLength, MSG_DONTWAIT | MSG_NOSIGNAL);
372 } while (nWrite == -1 && errno == EINTR);
373
374 if (nWrite < 0) {
375 int error = errno;
376 #if DEBUG_CHANNEL_MESSAGES
377 ALOGD("channel '%s' ~ error sending message of type %d, %s", mName.c_str(),
378 msg->header.type, strerror(error));
379 #endif
380 if (error == EAGAIN || error == EWOULDBLOCK) {
381 return WOULD_BLOCK;
382 }
383 if (error == EPIPE || error == ENOTCONN || error == ECONNREFUSED || error == ECONNRESET) {
384 return DEAD_OBJECT;
385 }
386 return -error;
387 }
388
389 if (size_t(nWrite) != msgLength) {
390 #if DEBUG_CHANNEL_MESSAGES
391 ALOGD("channel '%s' ~ error sending message type %d, send was incomplete",
392 mName.c_str(), msg->header.type);
393 #endif
394 return DEAD_OBJECT;
395 }
396
397 #if DEBUG_CHANNEL_MESSAGES
398 ALOGD("channel '%s' ~ sent message of type %d", mName.c_str(), msg->header.type);
399 #endif
400 return OK;
401 }
402
receiveMessage(InputMessage * msg)403 status_t InputChannel::receiveMessage(InputMessage* msg) {
404 ssize_t nRead;
405 do {
406 nRead = ::recv(getFd(), msg, sizeof(InputMessage), MSG_DONTWAIT);
407 } while (nRead == -1 && errno == EINTR);
408
409 if (nRead < 0) {
410 int error = errno;
411 #if DEBUG_CHANNEL_MESSAGES
412 ALOGD("channel '%s' ~ receive message failed, errno=%d", mName.c_str(), errno);
413 #endif
414 if (error == EAGAIN || error == EWOULDBLOCK) {
415 return WOULD_BLOCK;
416 }
417 if (error == EPIPE || error == ENOTCONN || error == ECONNREFUSED) {
418 return DEAD_OBJECT;
419 }
420 return -error;
421 }
422
423 if (nRead == 0) { // check for EOF
424 #if DEBUG_CHANNEL_MESSAGES
425 ALOGD("channel '%s' ~ receive message failed because peer was closed", mName.c_str());
426 #endif
427 return DEAD_OBJECT;
428 }
429
430 if (!msg->isValid(nRead)) {
431 ALOGE("channel '%s' ~ received invalid message of size %zd", mName.c_str(), nRead);
432 return BAD_VALUE;
433 }
434
435 #if DEBUG_CHANNEL_MESSAGES
436 ALOGD("channel '%s' ~ received message of type %d", mName.c_str(), msg->header.type);
437 #endif
438 return OK;
439 }
440
dup() const441 std::unique_ptr<InputChannel> InputChannel::dup() const {
442 base::unique_fd newFd(dupFd());
443 return InputChannel::create(getName(), std::move(newFd), getConnectionToken());
444 }
445
copyTo(InputChannel & outChannel) const446 void InputChannel::copyTo(InputChannel& outChannel) const {
447 outChannel.mName = getName();
448 outChannel.mFd = dupFd();
449 outChannel.mToken = getConnectionToken();
450 }
451
writeToParcel(android::Parcel * parcel) const452 status_t InputChannel::writeToParcel(android::Parcel* parcel) const {
453 if (parcel == nullptr) {
454 ALOGE("%s: Null parcel", __func__);
455 return BAD_VALUE;
456 }
457 return parcel->writeStrongBinder(mToken)
458 ?: parcel->writeUtf8AsUtf16(mName) ?: parcel->writeUniqueFileDescriptor(mFd);
459 }
460
readFromParcel(const android::Parcel * parcel)461 status_t InputChannel::readFromParcel(const android::Parcel* parcel) {
462 if (parcel == nullptr) {
463 ALOGE("%s: Null parcel", __func__);
464 return BAD_VALUE;
465 }
466 mToken = parcel->readStrongBinder();
467 return parcel->readUtf8FromUtf16(&mName) ?: parcel->readUniqueFileDescriptor(&mFd);
468 }
469
getConnectionToken() const470 sp<IBinder> InputChannel::getConnectionToken() const {
471 return mToken;
472 }
473
dupFd() const474 base::unique_fd InputChannel::dupFd() const {
475 android::base::unique_fd newFd(::dup(getFd()));
476 if (!newFd.ok()) {
477 ALOGE("Could not duplicate fd %i for channel %s: %s", getFd().get(), getName().c_str(),
478 strerror(errno));
479 const bool hitFdLimit = errno == EMFILE || errno == ENFILE;
480 // If this process is out of file descriptors, then throwing that might end up exploding
481 // on the other side of a binder call, which isn't really helpful.
482 // Better to just crash here and hope that the FD leak is slow.
483 // Other failures could be client errors, so we still propagate those back to the caller.
484 LOG_ALWAYS_FATAL_IF(hitFdLimit, "Too many open files, could not duplicate input channel %s",
485 getName().c_str());
486 return {};
487 }
488 return newFd;
489 }
490
491 // --- InputPublisher ---
492
InputPublisher(const std::shared_ptr<InputChannel> & channel)493 InputPublisher::InputPublisher(const std::shared_ptr<InputChannel>& channel) : mChannel(channel) {}
494
~InputPublisher()495 InputPublisher::~InputPublisher() {
496 }
497
publishKeyEvent(uint32_t seq,int32_t eventId,int32_t deviceId,int32_t source,int32_t displayId,std::array<uint8_t,32> hmac,int32_t action,int32_t flags,int32_t keyCode,int32_t scanCode,int32_t metaState,int32_t repeatCount,nsecs_t downTime,nsecs_t eventTime)498 status_t InputPublisher::publishKeyEvent(uint32_t seq, int32_t eventId, int32_t deviceId,
499 int32_t source, int32_t displayId,
500 std::array<uint8_t, 32> hmac, int32_t action,
501 int32_t flags, int32_t keyCode, int32_t scanCode,
502 int32_t metaState, int32_t repeatCount, nsecs_t downTime,
503 nsecs_t eventTime) {
504 if (ATRACE_ENABLED()) {
505 std::string message = StringPrintf("publishKeyEvent(inputChannel=%s, keyCode=%" PRId32 ")",
506 mChannel->getName().c_str(), keyCode);
507 ATRACE_NAME(message.c_str());
508 }
509 if (DEBUG_TRANSPORT_ACTIONS) {
510 ALOGD("channel '%s' publisher ~ publishKeyEvent: seq=%u, deviceId=%d, source=0x%x, "
511 "action=0x%x, flags=0x%x, keyCode=%d, scanCode=%d, metaState=0x%x, repeatCount=%d,"
512 "downTime=%" PRId64 ", eventTime=%" PRId64,
513 mChannel->getName().c_str(), seq, deviceId, source, action, flags, keyCode, scanCode,
514 metaState, repeatCount, downTime, eventTime);
515 }
516
517 if (!seq) {
518 ALOGE("Attempted to publish a key event with sequence number 0.");
519 return BAD_VALUE;
520 }
521
522 InputMessage msg;
523 msg.header.type = InputMessage::Type::KEY;
524 msg.header.seq = seq;
525 msg.body.key.eventId = eventId;
526 msg.body.key.deviceId = deviceId;
527 msg.body.key.source = source;
528 msg.body.key.displayId = displayId;
529 msg.body.key.hmac = std::move(hmac);
530 msg.body.key.action = action;
531 msg.body.key.flags = flags;
532 msg.body.key.keyCode = keyCode;
533 msg.body.key.scanCode = scanCode;
534 msg.body.key.metaState = metaState;
535 msg.body.key.repeatCount = repeatCount;
536 msg.body.key.downTime = downTime;
537 msg.body.key.eventTime = eventTime;
538 return mChannel->sendMessage(&msg);
539 }
540
publishMotionEvent(uint32_t seq,int32_t eventId,int32_t deviceId,int32_t source,int32_t displayId,std::array<uint8_t,32> hmac,int32_t action,int32_t actionButton,int32_t flags,int32_t edgeFlags,int32_t metaState,int32_t buttonState,MotionClassification classification,const ui::Transform & transform,float xPrecision,float yPrecision,float xCursorPosition,float yCursorPosition,const ui::Transform & rawTransform,nsecs_t downTime,nsecs_t eventTime,uint32_t pointerCount,const PointerProperties * pointerProperties,const PointerCoords * pointerCoords)541 status_t InputPublisher::publishMotionEvent(
542 uint32_t seq, int32_t eventId, int32_t deviceId, int32_t source, int32_t displayId,
543 std::array<uint8_t, 32> hmac, int32_t action, int32_t actionButton, int32_t flags,
544 int32_t edgeFlags, int32_t metaState, int32_t buttonState,
545 MotionClassification classification, const ui::Transform& transform, float xPrecision,
546 float yPrecision, float xCursorPosition, float yCursorPosition,
547 const ui::Transform& rawTransform, nsecs_t downTime, nsecs_t eventTime,
548 uint32_t pointerCount, const PointerProperties* pointerProperties,
549 const PointerCoords* pointerCoords) {
550 if (ATRACE_ENABLED()) {
551 std::string message = StringPrintf(
552 "publishMotionEvent(inputChannel=%s, action=%" PRId32 ")",
553 mChannel->getName().c_str(), action);
554 ATRACE_NAME(message.c_str());
555 }
556 if (DEBUG_TRANSPORT_ACTIONS) {
557 std::string transformString;
558 transform.dump(transformString, "transform", " ");
559 ALOGD("channel '%s' publisher ~ publishMotionEvent: seq=%u, deviceId=%d, source=0x%x, "
560 "displayId=%" PRId32 ", "
561 "action=0x%x, actionButton=0x%08x, flags=0x%x, edgeFlags=0x%x, "
562 "metaState=0x%x, buttonState=0x%x, classification=%s,"
563 "xPrecision=%f, yPrecision=%f, downTime=%" PRId64 ", eventTime=%" PRId64 ", "
564 "pointerCount=%" PRIu32 " \n%s",
565 mChannel->getName().c_str(), seq, deviceId, source, displayId, action, actionButton,
566 flags, edgeFlags, metaState, buttonState,
567 motionClassificationToString(classification), xPrecision, yPrecision, downTime,
568 eventTime, pointerCount, transformString.c_str());
569 }
570
571 if (!seq) {
572 ALOGE("Attempted to publish a motion event with sequence number 0.");
573 return BAD_VALUE;
574 }
575
576 if (pointerCount > MAX_POINTERS || pointerCount < 1) {
577 ALOGE("channel '%s' publisher ~ Invalid number of pointers provided: %" PRIu32 ".",
578 mChannel->getName().c_str(), pointerCount);
579 return BAD_VALUE;
580 }
581
582 InputMessage msg;
583 msg.header.type = InputMessage::Type::MOTION;
584 msg.header.seq = seq;
585 msg.body.motion.eventId = eventId;
586 msg.body.motion.deviceId = deviceId;
587 msg.body.motion.source = source;
588 msg.body.motion.displayId = displayId;
589 msg.body.motion.hmac = std::move(hmac);
590 msg.body.motion.action = action;
591 msg.body.motion.actionButton = actionButton;
592 msg.body.motion.flags = flags;
593 msg.body.motion.edgeFlags = edgeFlags;
594 msg.body.motion.metaState = metaState;
595 msg.body.motion.buttonState = buttonState;
596 msg.body.motion.classification = classification;
597 msg.body.motion.dsdx = transform.dsdx();
598 msg.body.motion.dtdx = transform.dtdx();
599 msg.body.motion.dtdy = transform.dtdy();
600 msg.body.motion.dsdy = transform.dsdy();
601 msg.body.motion.tx = transform.tx();
602 msg.body.motion.ty = transform.ty();
603 msg.body.motion.xPrecision = xPrecision;
604 msg.body.motion.yPrecision = yPrecision;
605 msg.body.motion.xCursorPosition = xCursorPosition;
606 msg.body.motion.yCursorPosition = yCursorPosition;
607 msg.body.motion.dsdxRaw = rawTransform.dsdx();
608 msg.body.motion.dtdxRaw = rawTransform.dtdx();
609 msg.body.motion.dtdyRaw = rawTransform.dtdy();
610 msg.body.motion.dsdyRaw = rawTransform.dsdy();
611 msg.body.motion.txRaw = rawTransform.tx();
612 msg.body.motion.tyRaw = rawTransform.ty();
613 msg.body.motion.downTime = downTime;
614 msg.body.motion.eventTime = eventTime;
615 msg.body.motion.pointerCount = pointerCount;
616 for (uint32_t i = 0; i < pointerCount; i++) {
617 msg.body.motion.pointers[i].properties.copyFrom(pointerProperties[i]);
618 msg.body.motion.pointers[i].coords.copyFrom(pointerCoords[i]);
619 }
620
621 return mChannel->sendMessage(&msg);
622 }
623
publishFocusEvent(uint32_t seq,int32_t eventId,bool hasFocus)624 status_t InputPublisher::publishFocusEvent(uint32_t seq, int32_t eventId, bool hasFocus) {
625 if (ATRACE_ENABLED()) {
626 std::string message = StringPrintf("publishFocusEvent(inputChannel=%s, hasFocus=%s)",
627 mChannel->getName().c_str(), toString(hasFocus));
628 ATRACE_NAME(message.c_str());
629 }
630
631 InputMessage msg;
632 msg.header.type = InputMessage::Type::FOCUS;
633 msg.header.seq = seq;
634 msg.body.focus.eventId = eventId;
635 msg.body.focus.hasFocus = hasFocus;
636 return mChannel->sendMessage(&msg);
637 }
638
publishCaptureEvent(uint32_t seq,int32_t eventId,bool pointerCaptureEnabled)639 status_t InputPublisher::publishCaptureEvent(uint32_t seq, int32_t eventId,
640 bool pointerCaptureEnabled) {
641 if (ATRACE_ENABLED()) {
642 std::string message =
643 StringPrintf("publishCaptureEvent(inputChannel=%s, pointerCaptureEnabled=%s)",
644 mChannel->getName().c_str(), toString(pointerCaptureEnabled));
645 ATRACE_NAME(message.c_str());
646 }
647
648 InputMessage msg;
649 msg.header.type = InputMessage::Type::CAPTURE;
650 msg.header.seq = seq;
651 msg.body.capture.eventId = eventId;
652 msg.body.capture.pointerCaptureEnabled = pointerCaptureEnabled;
653 return mChannel->sendMessage(&msg);
654 }
655
publishDragEvent(uint32_t seq,int32_t eventId,float x,float y,bool isExiting)656 status_t InputPublisher::publishDragEvent(uint32_t seq, int32_t eventId, float x, float y,
657 bool isExiting) {
658 if (ATRACE_ENABLED()) {
659 std::string message =
660 StringPrintf("publishDragEvent(inputChannel=%s, x=%f, y=%f, isExiting=%s)",
661 mChannel->getName().c_str(), x, y, toString(isExiting));
662 ATRACE_NAME(message.c_str());
663 }
664
665 InputMessage msg;
666 msg.header.type = InputMessage::Type::DRAG;
667 msg.header.seq = seq;
668 msg.body.drag.eventId = eventId;
669 msg.body.drag.isExiting = isExiting;
670 msg.body.drag.x = x;
671 msg.body.drag.y = y;
672 return mChannel->sendMessage(&msg);
673 }
674
publishTouchModeEvent(uint32_t seq,int32_t eventId,bool isInTouchMode)675 status_t InputPublisher::publishTouchModeEvent(uint32_t seq, int32_t eventId, bool isInTouchMode) {
676 if (ATRACE_ENABLED()) {
677 std::string message =
678 StringPrintf("publishTouchModeEvent(inputChannel=%s, isInTouchMode=%s)",
679 mChannel->getName().c_str(), toString(isInTouchMode));
680 ATRACE_NAME(message.c_str());
681 }
682
683 InputMessage msg;
684 msg.header.type = InputMessage::Type::TOUCH_MODE;
685 msg.header.seq = seq;
686 msg.body.touchMode.eventId = eventId;
687 msg.body.touchMode.isInTouchMode = isInTouchMode;
688 return mChannel->sendMessage(&msg);
689 }
690
receiveConsumerResponse()691 android::base::Result<InputPublisher::ConsumerResponse> InputPublisher::receiveConsumerResponse() {
692 if (DEBUG_TRANSPORT_ACTIONS) {
693 ALOGD("channel '%s' publisher ~ %s", mChannel->getName().c_str(), __func__);
694 }
695
696 InputMessage msg;
697 status_t result = mChannel->receiveMessage(&msg);
698 if (result) {
699 return android::base::Error(result);
700 }
701 if (msg.header.type == InputMessage::Type::FINISHED) {
702 return Finished{
703 .seq = msg.header.seq,
704 .handled = msg.body.finished.handled,
705 .consumeTime = msg.body.finished.consumeTime,
706 };
707 }
708
709 if (msg.header.type == InputMessage::Type::TIMELINE) {
710 return Timeline{
711 .inputEventId = msg.body.timeline.eventId,
712 .graphicsTimeline = msg.body.timeline.graphicsTimeline,
713 };
714 }
715
716 ALOGE("channel '%s' publisher ~ Received unexpected %s message from consumer",
717 mChannel->getName().c_str(), ftl::enum_string(msg.header.type).c_str());
718 return android::base::Error(UNKNOWN_ERROR);
719 }
720
721 // --- InputConsumer ---
722
InputConsumer(const std::shared_ptr<InputChannel> & channel)723 InputConsumer::InputConsumer(const std::shared_ptr<InputChannel>& channel)
724 : mResampleTouch(isTouchResamplingEnabled()), mChannel(channel), mMsgDeferred(false) {}
725
~InputConsumer()726 InputConsumer::~InputConsumer() {
727 }
728
isTouchResamplingEnabled()729 bool InputConsumer::isTouchResamplingEnabled() {
730 return property_get_bool(PROPERTY_RESAMPLING_ENABLED, true);
731 }
732
consume(InputEventFactoryInterface * factory,bool consumeBatches,nsecs_t frameTime,uint32_t * outSeq,InputEvent ** outEvent)733 status_t InputConsumer::consume(InputEventFactoryInterface* factory, bool consumeBatches,
734 nsecs_t frameTime, uint32_t* outSeq, InputEvent** outEvent) {
735 if (DEBUG_TRANSPORT_ACTIONS) {
736 ALOGD("channel '%s' consumer ~ consume: consumeBatches=%s, frameTime=%" PRId64,
737 mChannel->getName().c_str(), toString(consumeBatches), frameTime);
738 }
739
740 *outSeq = 0;
741 *outEvent = nullptr;
742
743 // Fetch the next input message.
744 // Loop until an event can be returned or no additional events are received.
745 while (!*outEvent) {
746 if (mMsgDeferred) {
747 // mMsg contains a valid input message from the previous call to consume
748 // that has not yet been processed.
749 mMsgDeferred = false;
750 } else {
751 // Receive a fresh message.
752 status_t result = mChannel->receiveMessage(&mMsg);
753 if (result == OK) {
754 mConsumeTimes.emplace(mMsg.header.seq, systemTime(SYSTEM_TIME_MONOTONIC));
755 }
756 if (result) {
757 // Consume the next batched event unless batches are being held for later.
758 if (consumeBatches || result != WOULD_BLOCK) {
759 result = consumeBatch(factory, frameTime, outSeq, outEvent);
760 if (*outEvent) {
761 if (DEBUG_TRANSPORT_ACTIONS) {
762 ALOGD("channel '%s' consumer ~ consumed batch event, seq=%u",
763 mChannel->getName().c_str(), *outSeq);
764 }
765 break;
766 }
767 }
768 return result;
769 }
770 }
771
772 switch (mMsg.header.type) {
773 case InputMessage::Type::KEY: {
774 KeyEvent* keyEvent = factory->createKeyEvent();
775 if (!keyEvent) return NO_MEMORY;
776
777 initializeKeyEvent(keyEvent, &mMsg);
778 *outSeq = mMsg.header.seq;
779 *outEvent = keyEvent;
780 if (DEBUG_TRANSPORT_ACTIONS) {
781 ALOGD("channel '%s' consumer ~ consumed key event, seq=%u",
782 mChannel->getName().c_str(), *outSeq);
783 }
784 break;
785 }
786
787 case InputMessage::Type::MOTION: {
788 ssize_t batchIndex = findBatch(mMsg.body.motion.deviceId, mMsg.body.motion.source);
789 if (batchIndex >= 0) {
790 Batch& batch = mBatches[batchIndex];
791 if (canAddSample(batch, &mMsg)) {
792 batch.samples.push_back(mMsg);
793 if (DEBUG_TRANSPORT_ACTIONS) {
794 ALOGD("channel '%s' consumer ~ appended to batch event",
795 mChannel->getName().c_str());
796 }
797 break;
798 } else if (isPointerEvent(mMsg.body.motion.source) &&
799 mMsg.body.motion.action == AMOTION_EVENT_ACTION_CANCEL) {
800 // No need to process events that we are going to cancel anyways
801 const size_t count = batch.samples.size();
802 for (size_t i = 0; i < count; i++) {
803 const InputMessage& msg = batch.samples[i];
804 sendFinishedSignal(msg.header.seq, false);
805 }
806 batch.samples.erase(batch.samples.begin(), batch.samples.begin() + count);
807 mBatches.erase(mBatches.begin() + batchIndex);
808 } else {
809 // We cannot append to the batch in progress, so we need to consume
810 // the previous batch right now and defer the new message until later.
811 mMsgDeferred = true;
812 status_t result = consumeSamples(factory, batch, batch.samples.size(),
813 outSeq, outEvent);
814 mBatches.erase(mBatches.begin() + batchIndex);
815 if (result) {
816 return result;
817 }
818 if (DEBUG_TRANSPORT_ACTIONS) {
819 ALOGD("channel '%s' consumer ~ consumed batch event and "
820 "deferred current event, seq=%u",
821 mChannel->getName().c_str(), *outSeq);
822 }
823 break;
824 }
825 }
826
827 // Start a new batch if needed.
828 if (mMsg.body.motion.action == AMOTION_EVENT_ACTION_MOVE ||
829 mMsg.body.motion.action == AMOTION_EVENT_ACTION_HOVER_MOVE) {
830 Batch batch;
831 batch.samples.push_back(mMsg);
832 mBatches.push_back(batch);
833 if (DEBUG_TRANSPORT_ACTIONS) {
834 ALOGD("channel '%s' consumer ~ started batch event",
835 mChannel->getName().c_str());
836 }
837 break;
838 }
839
840 MotionEvent* motionEvent = factory->createMotionEvent();
841 if (!motionEvent) return NO_MEMORY;
842
843 updateTouchState(mMsg);
844 initializeMotionEvent(motionEvent, &mMsg);
845 *outSeq = mMsg.header.seq;
846 *outEvent = motionEvent;
847
848 if (DEBUG_TRANSPORT_ACTIONS) {
849 ALOGD("channel '%s' consumer ~ consumed motion event, seq=%u",
850 mChannel->getName().c_str(), *outSeq);
851 }
852 break;
853 }
854
855 case InputMessage::Type::FINISHED:
856 case InputMessage::Type::TIMELINE: {
857 LOG_ALWAYS_FATAL("Consumed a %s message, which should never be seen by "
858 "InputConsumer!",
859 ftl::enum_string(mMsg.header.type).c_str());
860 break;
861 }
862
863 case InputMessage::Type::FOCUS: {
864 FocusEvent* focusEvent = factory->createFocusEvent();
865 if (!focusEvent) return NO_MEMORY;
866
867 initializeFocusEvent(focusEvent, &mMsg);
868 *outSeq = mMsg.header.seq;
869 *outEvent = focusEvent;
870 break;
871 }
872
873 case InputMessage::Type::CAPTURE: {
874 CaptureEvent* captureEvent = factory->createCaptureEvent();
875 if (!captureEvent) return NO_MEMORY;
876
877 initializeCaptureEvent(captureEvent, &mMsg);
878 *outSeq = mMsg.header.seq;
879 *outEvent = captureEvent;
880 break;
881 }
882
883 case InputMessage::Type::DRAG: {
884 DragEvent* dragEvent = factory->createDragEvent();
885 if (!dragEvent) return NO_MEMORY;
886
887 initializeDragEvent(dragEvent, &mMsg);
888 *outSeq = mMsg.header.seq;
889 *outEvent = dragEvent;
890 break;
891 }
892
893 case InputMessage::Type::TOUCH_MODE: {
894 TouchModeEvent* touchModeEvent = factory->createTouchModeEvent();
895 if (!touchModeEvent) return NO_MEMORY;
896
897 initializeTouchModeEvent(touchModeEvent, &mMsg);
898 *outSeq = mMsg.header.seq;
899 *outEvent = touchModeEvent;
900 break;
901 }
902 }
903 }
904 return OK;
905 }
906
consumeBatch(InputEventFactoryInterface * factory,nsecs_t frameTime,uint32_t * outSeq,InputEvent ** outEvent)907 status_t InputConsumer::consumeBatch(InputEventFactoryInterface* factory,
908 nsecs_t frameTime, uint32_t* outSeq, InputEvent** outEvent) {
909 status_t result;
910 for (size_t i = mBatches.size(); i > 0; ) {
911 i--;
912 Batch& batch = mBatches[i];
913 if (frameTime < 0) {
914 result = consumeSamples(factory, batch, batch.samples.size(), outSeq, outEvent);
915 mBatches.erase(mBatches.begin() + i);
916 return result;
917 }
918
919 nsecs_t sampleTime = frameTime;
920 if (mResampleTouch) {
921 sampleTime -= RESAMPLE_LATENCY;
922 }
923 ssize_t split = findSampleNoLaterThan(batch, sampleTime);
924 if (split < 0) {
925 continue;
926 }
927
928 result = consumeSamples(factory, batch, split + 1, outSeq, outEvent);
929 const InputMessage* next;
930 if (batch.samples.empty()) {
931 mBatches.erase(mBatches.begin() + i);
932 next = nullptr;
933 } else {
934 next = &batch.samples[0];
935 }
936 if (!result && mResampleTouch) {
937 resampleTouchState(sampleTime, static_cast<MotionEvent*>(*outEvent), next);
938 }
939 return result;
940 }
941
942 return WOULD_BLOCK;
943 }
944
consumeSamples(InputEventFactoryInterface * factory,Batch & batch,size_t count,uint32_t * outSeq,InputEvent ** outEvent)945 status_t InputConsumer::consumeSamples(InputEventFactoryInterface* factory,
946 Batch& batch, size_t count, uint32_t* outSeq, InputEvent** outEvent) {
947 MotionEvent* motionEvent = factory->createMotionEvent();
948 if (! motionEvent) return NO_MEMORY;
949
950 uint32_t chain = 0;
951 for (size_t i = 0; i < count; i++) {
952 InputMessage& msg = batch.samples[i];
953 updateTouchState(msg);
954 if (i) {
955 SeqChain seqChain;
956 seqChain.seq = msg.header.seq;
957 seqChain.chain = chain;
958 mSeqChains.push_back(seqChain);
959 addSample(motionEvent, &msg);
960 } else {
961 initializeMotionEvent(motionEvent, &msg);
962 }
963 chain = msg.header.seq;
964 }
965 batch.samples.erase(batch.samples.begin(), batch.samples.begin() + count);
966
967 *outSeq = chain;
968 *outEvent = motionEvent;
969 return OK;
970 }
971
updateTouchState(InputMessage & msg)972 void InputConsumer::updateTouchState(InputMessage& msg) {
973 if (!mResampleTouch || !isPointerEvent(msg.body.motion.source)) {
974 return;
975 }
976
977 int32_t deviceId = msg.body.motion.deviceId;
978 int32_t source = msg.body.motion.source;
979
980 // Update the touch state history to incorporate the new input message.
981 // If the message is in the past relative to the most recently produced resampled
982 // touch, then use the resampled time and coordinates instead.
983 switch (msg.body.motion.action & AMOTION_EVENT_ACTION_MASK) {
984 case AMOTION_EVENT_ACTION_DOWN: {
985 ssize_t index = findTouchState(deviceId, source);
986 if (index < 0) {
987 mTouchStates.push_back({});
988 index = mTouchStates.size() - 1;
989 }
990 TouchState& touchState = mTouchStates[index];
991 touchState.initialize(deviceId, source);
992 touchState.addHistory(msg);
993 break;
994 }
995
996 case AMOTION_EVENT_ACTION_MOVE: {
997 ssize_t index = findTouchState(deviceId, source);
998 if (index >= 0) {
999 TouchState& touchState = mTouchStates[index];
1000 touchState.addHistory(msg);
1001 rewriteMessage(touchState, msg);
1002 }
1003 break;
1004 }
1005
1006 case AMOTION_EVENT_ACTION_POINTER_DOWN: {
1007 ssize_t index = findTouchState(deviceId, source);
1008 if (index >= 0) {
1009 TouchState& touchState = mTouchStates[index];
1010 touchState.lastResample.idBits.clearBit(msg.body.motion.getActionId());
1011 rewriteMessage(touchState, msg);
1012 }
1013 break;
1014 }
1015
1016 case AMOTION_EVENT_ACTION_POINTER_UP: {
1017 ssize_t index = findTouchState(deviceId, source);
1018 if (index >= 0) {
1019 TouchState& touchState = mTouchStates[index];
1020 rewriteMessage(touchState, msg);
1021 touchState.lastResample.idBits.clearBit(msg.body.motion.getActionId());
1022 }
1023 break;
1024 }
1025
1026 case AMOTION_EVENT_ACTION_SCROLL: {
1027 ssize_t index = findTouchState(deviceId, source);
1028 if (index >= 0) {
1029 TouchState& touchState = mTouchStates[index];
1030 rewriteMessage(touchState, msg);
1031 }
1032 break;
1033 }
1034
1035 case AMOTION_EVENT_ACTION_UP:
1036 case AMOTION_EVENT_ACTION_CANCEL: {
1037 ssize_t index = findTouchState(deviceId, source);
1038 if (index >= 0) {
1039 TouchState& touchState = mTouchStates[index];
1040 rewriteMessage(touchState, msg);
1041 mTouchStates.erase(mTouchStates.begin() + index);
1042 }
1043 break;
1044 }
1045 }
1046 }
1047
1048 /**
1049 * Replace the coordinates in msg with the coordinates in lastResample, if necessary.
1050 *
1051 * If lastResample is no longer valid for a specific pointer (i.e. the lastResample time
1052 * is in the past relative to msg and the past two events do not contain identical coordinates),
1053 * then invalidate the lastResample data for that pointer.
1054 * If the two past events have identical coordinates, then lastResample data for that pointer will
1055 * remain valid, and will be used to replace these coordinates. Thus, if a certain coordinate x0 is
1056 * resampled to the new value x1, then x1 will always be used to replace x0 until some new value
1057 * not equal to x0 is received.
1058 */
rewriteMessage(TouchState & state,InputMessage & msg)1059 void InputConsumer::rewriteMessage(TouchState& state, InputMessage& msg) {
1060 nsecs_t eventTime = msg.body.motion.eventTime;
1061 for (uint32_t i = 0; i < msg.body.motion.pointerCount; i++) {
1062 uint32_t id = msg.body.motion.pointers[i].properties.id;
1063 if (state.lastResample.idBits.hasBit(id)) {
1064 if (eventTime < state.lastResample.eventTime ||
1065 state.recentCoordinatesAreIdentical(id)) {
1066 PointerCoords& msgCoords = msg.body.motion.pointers[i].coords;
1067 const PointerCoords& resampleCoords = state.lastResample.getPointerById(id);
1068 #if DEBUG_RESAMPLING
1069 ALOGD("[%d] - rewrite (%0.3f, %0.3f), old (%0.3f, %0.3f)", id,
1070 resampleCoords.getX(), resampleCoords.getY(),
1071 msgCoords.getX(), msgCoords.getY());
1072 #endif
1073 msgCoords.setAxisValue(AMOTION_EVENT_AXIS_X, resampleCoords.getX());
1074 msgCoords.setAxisValue(AMOTION_EVENT_AXIS_Y, resampleCoords.getY());
1075 } else {
1076 state.lastResample.idBits.clearBit(id);
1077 }
1078 }
1079 }
1080 }
1081
resampleTouchState(nsecs_t sampleTime,MotionEvent * event,const InputMessage * next)1082 void InputConsumer::resampleTouchState(nsecs_t sampleTime, MotionEvent* event,
1083 const InputMessage* next) {
1084 if (!mResampleTouch
1085 || !(isPointerEvent(event->getSource()))
1086 || event->getAction() != AMOTION_EVENT_ACTION_MOVE) {
1087 return;
1088 }
1089
1090 ssize_t index = findTouchState(event->getDeviceId(), event->getSource());
1091 if (index < 0) {
1092 #if DEBUG_RESAMPLING
1093 ALOGD("Not resampled, no touch state for device.");
1094 #endif
1095 return;
1096 }
1097
1098 TouchState& touchState = mTouchStates[index];
1099 if (touchState.historySize < 1) {
1100 #if DEBUG_RESAMPLING
1101 ALOGD("Not resampled, no history for device.");
1102 #endif
1103 return;
1104 }
1105
1106 // Ensure that the current sample has all of the pointers that need to be reported.
1107 const History* current = touchState.getHistory(0);
1108 size_t pointerCount = event->getPointerCount();
1109 for (size_t i = 0; i < pointerCount; i++) {
1110 uint32_t id = event->getPointerId(i);
1111 if (!current->idBits.hasBit(id)) {
1112 #if DEBUG_RESAMPLING
1113 ALOGD("Not resampled, missing id %d", id);
1114 #endif
1115 return;
1116 }
1117 }
1118
1119 // Find the data to use for resampling.
1120 const History* other;
1121 History future;
1122 float alpha;
1123 if (next) {
1124 // Interpolate between current sample and future sample.
1125 // So current->eventTime <= sampleTime <= future.eventTime.
1126 future.initializeFrom(*next);
1127 other = &future;
1128 nsecs_t delta = future.eventTime - current->eventTime;
1129 if (delta < RESAMPLE_MIN_DELTA) {
1130 #if DEBUG_RESAMPLING
1131 ALOGD("Not resampled, delta time is too small: %" PRId64 " ns.", delta);
1132 #endif
1133 return;
1134 }
1135 alpha = float(sampleTime - current->eventTime) / delta;
1136 } else if (touchState.historySize >= 2) {
1137 // Extrapolate future sample using current sample and past sample.
1138 // So other->eventTime <= current->eventTime <= sampleTime.
1139 other = touchState.getHistory(1);
1140 nsecs_t delta = current->eventTime - other->eventTime;
1141 if (delta < RESAMPLE_MIN_DELTA) {
1142 #if DEBUG_RESAMPLING
1143 ALOGD("Not resampled, delta time is too small: %" PRId64 " ns.", delta);
1144 #endif
1145 return;
1146 } else if (delta > RESAMPLE_MAX_DELTA) {
1147 #if DEBUG_RESAMPLING
1148 ALOGD("Not resampled, delta time is too large: %" PRId64 " ns.", delta);
1149 #endif
1150 return;
1151 }
1152 nsecs_t maxPredict = current->eventTime + min(delta / 2, RESAMPLE_MAX_PREDICTION);
1153 if (sampleTime > maxPredict) {
1154 #if DEBUG_RESAMPLING
1155 ALOGD("Sample time is too far in the future, adjusting prediction "
1156 "from %" PRId64 " to %" PRId64 " ns.",
1157 sampleTime - current->eventTime, maxPredict - current->eventTime);
1158 #endif
1159 sampleTime = maxPredict;
1160 }
1161 alpha = float(current->eventTime - sampleTime) / delta;
1162 } else {
1163 #if DEBUG_RESAMPLING
1164 ALOGD("Not resampled, insufficient data.");
1165 #endif
1166 return;
1167 }
1168
1169 // Resample touch coordinates.
1170 History oldLastResample;
1171 oldLastResample.initializeFrom(touchState.lastResample);
1172 touchState.lastResample.eventTime = sampleTime;
1173 touchState.lastResample.idBits.clear();
1174 for (size_t i = 0; i < pointerCount; i++) {
1175 uint32_t id = event->getPointerId(i);
1176 touchState.lastResample.idToIndex[id] = i;
1177 touchState.lastResample.idBits.markBit(id);
1178 if (oldLastResample.hasPointerId(id) && touchState.recentCoordinatesAreIdentical(id)) {
1179 // We maintain the previously resampled value for this pointer (stored in
1180 // oldLastResample) when the coordinates for this pointer haven't changed since then.
1181 // This way we don't introduce artificial jitter when pointers haven't actually moved.
1182
1183 // We know here that the coordinates for the pointer haven't changed because we
1184 // would've cleared the resampled bit in rewriteMessage if they had. We can't modify
1185 // lastResample in place becasue the mapping from pointer ID to index may have changed.
1186 touchState.lastResample.pointers[i].copyFrom(oldLastResample.getPointerById(id));
1187 continue;
1188 }
1189
1190 PointerCoords& resampledCoords = touchState.lastResample.pointers[i];
1191 const PointerCoords& currentCoords = current->getPointerById(id);
1192 resampledCoords.copyFrom(currentCoords);
1193 if (other->idBits.hasBit(id)
1194 && shouldResampleTool(event->getToolType(i))) {
1195 const PointerCoords& otherCoords = other->getPointerById(id);
1196 resampledCoords.setAxisValue(AMOTION_EVENT_AXIS_X,
1197 lerp(currentCoords.getX(), otherCoords.getX(), alpha));
1198 resampledCoords.setAxisValue(AMOTION_EVENT_AXIS_Y,
1199 lerp(currentCoords.getY(), otherCoords.getY(), alpha));
1200 #if DEBUG_RESAMPLING
1201 ALOGD("[%d] - out (%0.3f, %0.3f), cur (%0.3f, %0.3f), "
1202 "other (%0.3f, %0.3f), alpha %0.3f",
1203 id, resampledCoords.getX(), resampledCoords.getY(),
1204 currentCoords.getX(), currentCoords.getY(),
1205 otherCoords.getX(), otherCoords.getY(),
1206 alpha);
1207 #endif
1208 } else {
1209 #if DEBUG_RESAMPLING
1210 ALOGD("[%d] - out (%0.3f, %0.3f), cur (%0.3f, %0.3f)",
1211 id, resampledCoords.getX(), resampledCoords.getY(),
1212 currentCoords.getX(), currentCoords.getY());
1213 #endif
1214 }
1215 }
1216
1217 event->addSample(sampleTime, touchState.lastResample.pointers);
1218 }
1219
shouldResampleTool(int32_t toolType)1220 bool InputConsumer::shouldResampleTool(int32_t toolType) {
1221 return toolType == AMOTION_EVENT_TOOL_TYPE_FINGER
1222 || toolType == AMOTION_EVENT_TOOL_TYPE_UNKNOWN;
1223 }
1224
sendFinishedSignal(uint32_t seq,bool handled)1225 status_t InputConsumer::sendFinishedSignal(uint32_t seq, bool handled) {
1226 if (DEBUG_TRANSPORT_ACTIONS) {
1227 ALOGD("channel '%s' consumer ~ sendFinishedSignal: seq=%u, handled=%s",
1228 mChannel->getName().c_str(), seq, toString(handled));
1229 }
1230
1231 if (!seq) {
1232 ALOGE("Attempted to send a finished signal with sequence number 0.");
1233 return BAD_VALUE;
1234 }
1235
1236 // Send finished signals for the batch sequence chain first.
1237 size_t seqChainCount = mSeqChains.size();
1238 if (seqChainCount) {
1239 uint32_t currentSeq = seq;
1240 uint32_t chainSeqs[seqChainCount];
1241 size_t chainIndex = 0;
1242 for (size_t i = seqChainCount; i > 0; ) {
1243 i--;
1244 const SeqChain& seqChain = mSeqChains[i];
1245 if (seqChain.seq == currentSeq) {
1246 currentSeq = seqChain.chain;
1247 chainSeqs[chainIndex++] = currentSeq;
1248 mSeqChains.erase(mSeqChains.begin() + i);
1249 }
1250 }
1251 status_t status = OK;
1252 while (!status && chainIndex > 0) {
1253 chainIndex--;
1254 status = sendUnchainedFinishedSignal(chainSeqs[chainIndex], handled);
1255 }
1256 if (status) {
1257 // An error occurred so at least one signal was not sent, reconstruct the chain.
1258 for (;;) {
1259 SeqChain seqChain;
1260 seqChain.seq = chainIndex != 0 ? chainSeqs[chainIndex - 1] : seq;
1261 seqChain.chain = chainSeqs[chainIndex];
1262 mSeqChains.push_back(seqChain);
1263 if (!chainIndex) break;
1264 chainIndex--;
1265 }
1266 return status;
1267 }
1268 }
1269
1270 // Send finished signal for the last message in the batch.
1271 return sendUnchainedFinishedSignal(seq, handled);
1272 }
1273
sendTimeline(int32_t inputEventId,std::array<nsecs_t,GraphicsTimeline::SIZE> graphicsTimeline)1274 status_t InputConsumer::sendTimeline(int32_t inputEventId,
1275 std::array<nsecs_t, GraphicsTimeline::SIZE> graphicsTimeline) {
1276 if (DEBUG_TRANSPORT_ACTIONS) {
1277 ALOGD("channel '%s' consumer ~ sendTimeline: inputEventId=%" PRId32
1278 ", gpuCompletedTime=%" PRId64 ", presentTime=%" PRId64,
1279 mChannel->getName().c_str(), inputEventId,
1280 graphicsTimeline[GraphicsTimeline::GPU_COMPLETED_TIME],
1281 graphicsTimeline[GraphicsTimeline::PRESENT_TIME]);
1282 }
1283
1284 InputMessage msg;
1285 msg.header.type = InputMessage::Type::TIMELINE;
1286 msg.header.seq = 0;
1287 msg.body.timeline.eventId = inputEventId;
1288 msg.body.timeline.graphicsTimeline = std::move(graphicsTimeline);
1289 return mChannel->sendMessage(&msg);
1290 }
1291
getConsumeTime(uint32_t seq) const1292 nsecs_t InputConsumer::getConsumeTime(uint32_t seq) const {
1293 auto it = mConsumeTimes.find(seq);
1294 // Consume time will be missing if either 'finishInputEvent' is called twice, or if it was
1295 // called for the wrong (synthetic?) input event. Either way, it is a bug that should be fixed.
1296 LOG_ALWAYS_FATAL_IF(it == mConsumeTimes.end(), "Could not find consume time for seq=%" PRIu32,
1297 seq);
1298 return it->second;
1299 }
1300
popConsumeTime(uint32_t seq)1301 void InputConsumer::popConsumeTime(uint32_t seq) {
1302 mConsumeTimes.erase(seq);
1303 }
1304
sendUnchainedFinishedSignal(uint32_t seq,bool handled)1305 status_t InputConsumer::sendUnchainedFinishedSignal(uint32_t seq, bool handled) {
1306 InputMessage msg;
1307 msg.header.type = InputMessage::Type::FINISHED;
1308 msg.header.seq = seq;
1309 msg.body.finished.handled = handled;
1310 msg.body.finished.consumeTime = getConsumeTime(seq);
1311 status_t result = mChannel->sendMessage(&msg);
1312 if (result == OK) {
1313 // Remove the consume time if the socket write succeeded. We will not need to ack this
1314 // message anymore. If the socket write did not succeed, we will try again and will still
1315 // need consume time.
1316 popConsumeTime(seq);
1317 }
1318 return result;
1319 }
1320
hasPendingBatch() const1321 bool InputConsumer::hasPendingBatch() const {
1322 return !mBatches.empty();
1323 }
1324
getPendingBatchSource() const1325 int32_t InputConsumer::getPendingBatchSource() const {
1326 if (mBatches.empty()) {
1327 return AINPUT_SOURCE_CLASS_NONE;
1328 }
1329
1330 const Batch& batch = mBatches[0];
1331 const InputMessage& head = batch.samples[0];
1332 return head.body.motion.source;
1333 }
1334
findBatch(int32_t deviceId,int32_t source) const1335 ssize_t InputConsumer::findBatch(int32_t deviceId, int32_t source) const {
1336 for (size_t i = 0; i < mBatches.size(); i++) {
1337 const Batch& batch = mBatches[i];
1338 const InputMessage& head = batch.samples[0];
1339 if (head.body.motion.deviceId == deviceId && head.body.motion.source == source) {
1340 return i;
1341 }
1342 }
1343 return -1;
1344 }
1345
findTouchState(int32_t deviceId,int32_t source) const1346 ssize_t InputConsumer::findTouchState(int32_t deviceId, int32_t source) const {
1347 for (size_t i = 0; i < mTouchStates.size(); i++) {
1348 const TouchState& touchState = mTouchStates[i];
1349 if (touchState.deviceId == deviceId && touchState.source == source) {
1350 return i;
1351 }
1352 }
1353 return -1;
1354 }
1355
initializeKeyEvent(KeyEvent * event,const InputMessage * msg)1356 void InputConsumer::initializeKeyEvent(KeyEvent* event, const InputMessage* msg) {
1357 event->initialize(msg->body.key.eventId, msg->body.key.deviceId, msg->body.key.source,
1358 msg->body.key.displayId, msg->body.key.hmac, msg->body.key.action,
1359 msg->body.key.flags, msg->body.key.keyCode, msg->body.key.scanCode,
1360 msg->body.key.metaState, msg->body.key.repeatCount, msg->body.key.downTime,
1361 msg->body.key.eventTime);
1362 }
1363
initializeFocusEvent(FocusEvent * event,const InputMessage * msg)1364 void InputConsumer::initializeFocusEvent(FocusEvent* event, const InputMessage* msg) {
1365 event->initialize(msg->body.focus.eventId, msg->body.focus.hasFocus);
1366 }
1367
initializeCaptureEvent(CaptureEvent * event,const InputMessage * msg)1368 void InputConsumer::initializeCaptureEvent(CaptureEvent* event, const InputMessage* msg) {
1369 event->initialize(msg->body.capture.eventId, msg->body.capture.pointerCaptureEnabled);
1370 }
1371
initializeDragEvent(DragEvent * event,const InputMessage * msg)1372 void InputConsumer::initializeDragEvent(DragEvent* event, const InputMessage* msg) {
1373 event->initialize(msg->body.drag.eventId, msg->body.drag.x, msg->body.drag.y,
1374 msg->body.drag.isExiting);
1375 }
1376
initializeMotionEvent(MotionEvent * event,const InputMessage * msg)1377 void InputConsumer::initializeMotionEvent(MotionEvent* event, const InputMessage* msg) {
1378 uint32_t pointerCount = msg->body.motion.pointerCount;
1379 PointerProperties pointerProperties[pointerCount];
1380 PointerCoords pointerCoords[pointerCount];
1381 for (uint32_t i = 0; i < pointerCount; i++) {
1382 pointerProperties[i].copyFrom(msg->body.motion.pointers[i].properties);
1383 pointerCoords[i].copyFrom(msg->body.motion.pointers[i].coords);
1384 }
1385
1386 ui::Transform transform;
1387 transform.set({msg->body.motion.dsdx, msg->body.motion.dtdx, msg->body.motion.tx,
1388 msg->body.motion.dtdy, msg->body.motion.dsdy, msg->body.motion.ty, 0, 0, 1});
1389 ui::Transform displayTransform;
1390 displayTransform.set({msg->body.motion.dsdxRaw, msg->body.motion.dtdxRaw,
1391 msg->body.motion.txRaw, msg->body.motion.dtdyRaw,
1392 msg->body.motion.dsdyRaw, msg->body.motion.tyRaw, 0, 0, 1});
1393 event->initialize(msg->body.motion.eventId, msg->body.motion.deviceId, msg->body.motion.source,
1394 msg->body.motion.displayId, msg->body.motion.hmac, msg->body.motion.action,
1395 msg->body.motion.actionButton, msg->body.motion.flags,
1396 msg->body.motion.edgeFlags, msg->body.motion.metaState,
1397 msg->body.motion.buttonState, msg->body.motion.classification, transform,
1398 msg->body.motion.xPrecision, msg->body.motion.yPrecision,
1399 msg->body.motion.xCursorPosition, msg->body.motion.yCursorPosition,
1400 displayTransform, msg->body.motion.downTime, msg->body.motion.eventTime,
1401 pointerCount, pointerProperties, pointerCoords);
1402 }
1403
initializeTouchModeEvent(TouchModeEvent * event,const InputMessage * msg)1404 void InputConsumer::initializeTouchModeEvent(TouchModeEvent* event, const InputMessage* msg) {
1405 event->initialize(msg->body.touchMode.eventId, msg->body.touchMode.isInTouchMode);
1406 }
1407
addSample(MotionEvent * event,const InputMessage * msg)1408 void InputConsumer::addSample(MotionEvent* event, const InputMessage* msg) {
1409 uint32_t pointerCount = msg->body.motion.pointerCount;
1410 PointerCoords pointerCoords[pointerCount];
1411 for (uint32_t i = 0; i < pointerCount; i++) {
1412 pointerCoords[i].copyFrom(msg->body.motion.pointers[i].coords);
1413 }
1414
1415 event->setMetaState(event->getMetaState() | msg->body.motion.metaState);
1416 event->addSample(msg->body.motion.eventTime, pointerCoords);
1417 }
1418
canAddSample(const Batch & batch,const InputMessage * msg)1419 bool InputConsumer::canAddSample(const Batch& batch, const InputMessage *msg) {
1420 const InputMessage& head = batch.samples[0];
1421 uint32_t pointerCount = msg->body.motion.pointerCount;
1422 if (head.body.motion.pointerCount != pointerCount
1423 || head.body.motion.action != msg->body.motion.action) {
1424 return false;
1425 }
1426 for (size_t i = 0; i < pointerCount; i++) {
1427 if (head.body.motion.pointers[i].properties
1428 != msg->body.motion.pointers[i].properties) {
1429 return false;
1430 }
1431 }
1432 return true;
1433 }
1434
findSampleNoLaterThan(const Batch & batch,nsecs_t time)1435 ssize_t InputConsumer::findSampleNoLaterThan(const Batch& batch, nsecs_t time) {
1436 size_t numSamples = batch.samples.size();
1437 size_t index = 0;
1438 while (index < numSamples && batch.samples[index].body.motion.eventTime <= time) {
1439 index += 1;
1440 }
1441 return ssize_t(index) - 1;
1442 }
1443
dump() const1444 std::string InputConsumer::dump() const {
1445 std::string out;
1446 out = out + "mResampleTouch = " + toString(mResampleTouch) + "\n";
1447 out = out + "mChannel = " + mChannel->getName() + "\n";
1448 out = out + "mMsgDeferred: " + toString(mMsgDeferred) + "\n";
1449 if (mMsgDeferred) {
1450 out = out + "mMsg : " + ftl::enum_string(mMsg.header.type) + "\n";
1451 }
1452 out += "Batches:\n";
1453 for (const Batch& batch : mBatches) {
1454 out += " Batch:\n";
1455 for (const InputMessage& msg : batch.samples) {
1456 out += android::base::StringPrintf(" Message %" PRIu32 ": %s ", msg.header.seq,
1457 ftl::enum_string(msg.header.type).c_str());
1458 switch (msg.header.type) {
1459 case InputMessage::Type::KEY: {
1460 out += android::base::StringPrintf("action=%s keycode=%" PRId32,
1461 KeyEvent::actionToString(
1462 msg.body.key.action),
1463 msg.body.key.keyCode);
1464 break;
1465 }
1466 case InputMessage::Type::MOTION: {
1467 out = out + "action=" + MotionEvent::actionToString(msg.body.motion.action);
1468 for (uint32_t i = 0; i < msg.body.motion.pointerCount; i++) {
1469 const float x = msg.body.motion.pointers[i].coords.getX();
1470 const float y = msg.body.motion.pointers[i].coords.getY();
1471 out += android::base::StringPrintf("\n Pointer %" PRIu32
1472 " : x=%.1f y=%.1f",
1473 i, x, y);
1474 }
1475 break;
1476 }
1477 case InputMessage::Type::FINISHED: {
1478 out += android::base::StringPrintf("handled=%s, consumeTime=%" PRId64,
1479 toString(msg.body.finished.handled),
1480 msg.body.finished.consumeTime);
1481 break;
1482 }
1483 case InputMessage::Type::FOCUS: {
1484 out += android::base::StringPrintf("hasFocus=%s",
1485 toString(msg.body.focus.hasFocus));
1486 break;
1487 }
1488 case InputMessage::Type::CAPTURE: {
1489 out += android::base::StringPrintf("hasCapture=%s",
1490 toString(msg.body.capture
1491 .pointerCaptureEnabled));
1492 break;
1493 }
1494 case InputMessage::Type::DRAG: {
1495 out += android::base::StringPrintf("x=%.1f y=%.1f, isExiting=%s",
1496 msg.body.drag.x, msg.body.drag.y,
1497 toString(msg.body.drag.isExiting));
1498 break;
1499 }
1500 case InputMessage::Type::TIMELINE: {
1501 const nsecs_t gpuCompletedTime =
1502 msg.body.timeline
1503 .graphicsTimeline[GraphicsTimeline::GPU_COMPLETED_TIME];
1504 const nsecs_t presentTime =
1505 msg.body.timeline.graphicsTimeline[GraphicsTimeline::PRESENT_TIME];
1506 out += android::base::StringPrintf("inputEventId=%" PRId32
1507 ", gpuCompletedTime=%" PRId64
1508 ", presentTime=%" PRId64,
1509 msg.body.timeline.eventId, gpuCompletedTime,
1510 presentTime);
1511 break;
1512 }
1513 case InputMessage::Type::TOUCH_MODE: {
1514 out += android::base::StringPrintf("isInTouchMode=%s",
1515 toString(msg.body.touchMode.isInTouchMode));
1516 break;
1517 }
1518 }
1519 out += "\n";
1520 }
1521 }
1522 if (mBatches.empty()) {
1523 out += " <empty>\n";
1524 }
1525 out += "mSeqChains:\n";
1526 for (const SeqChain& chain : mSeqChains) {
1527 out += android::base::StringPrintf(" chain: seq = %" PRIu32 " chain=%" PRIu32, chain.seq,
1528 chain.chain);
1529 }
1530 if (mSeqChains.empty()) {
1531 out += " <empty>\n";
1532 }
1533 out += "mConsumeTimes:\n";
1534 for (const auto& [seq, consumeTime] : mConsumeTimes) {
1535 out += android::base::StringPrintf(" seq = %" PRIu32 " consumeTime = %" PRId64, seq,
1536 consumeTime);
1537 }
1538 if (mConsumeTimes.empty()) {
1539 out += " <empty>\n";
1540 }
1541 return out;
1542 }
1543
1544 } // namespace android
1545