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 <log/log.h>
34 #include <utils/Trace.h>
35 
36 #include <input/InputTransport.h>
37 
38 using android::base::StringPrintf;
39 
40 namespace android {
41 
42 // Socket buffer size.  The default is typically about 128KB, which is much larger than
43 // we really need.  So we make it smaller.  It just needs to be big enough to hold
44 // a few dozen large multi-finger motion events in the case where an application gets
45 // behind processing touches.
46 static const size_t SOCKET_BUFFER_SIZE = 32 * 1024;
47 
48 // Nanoseconds per milliseconds.
49 static const nsecs_t NANOS_PER_MS = 1000000;
50 
51 // Latency added during resampling.  A few milliseconds doesn't hurt much but
52 // reduces the impact of mispredicted touch positions.
53 static const nsecs_t RESAMPLE_LATENCY = 5 * NANOS_PER_MS;
54 
55 // Minimum time difference between consecutive samples before attempting to resample.
56 static const nsecs_t RESAMPLE_MIN_DELTA = 2 * NANOS_PER_MS;
57 
58 // Maximum time difference between consecutive samples before attempting to resample
59 // by extrapolation.
60 static const nsecs_t RESAMPLE_MAX_DELTA = 20 * NANOS_PER_MS;
61 
62 // Maximum time to predict forward from the last known state, to avoid predicting too
63 // far into the future.  This time is further bounded by 50% of the last time delta.
64 static const nsecs_t RESAMPLE_MAX_PREDICTION = 8 * NANOS_PER_MS;
65 
66 /**
67  * System property for enabling / disabling touch resampling.
68  * Resampling extrapolates / interpolates the reported touch event coordinates to better
69  * align them to the VSYNC signal, thus resulting in smoother scrolling performance.
70  * Resampling is not needed (and should be disabled) on hardware that already
71  * has touch events triggered by VSYNC.
72  * Set to "1" to enable resampling (default).
73  * Set to "0" to disable resampling.
74  * Resampling is enabled by default.
75  */
76 static const char* PROPERTY_RESAMPLING_ENABLED = "ro.input.resampling";
77 
78 template<typename T>
min(const T & a,const T & b)79 inline static T min(const T& a, const T& b) {
80     return a < b ? a : b;
81 }
82 
lerp(float a,float b,float alpha)83 inline static float lerp(float a, float b, float alpha) {
84     return a + alpha * (b - a);
85 }
86 
isPointerEvent(int32_t source)87 inline static bool isPointerEvent(int32_t source) {
88     return (source & AINPUT_SOURCE_CLASS_POINTER) == AINPUT_SOURCE_CLASS_POINTER;
89 }
90 
toString(bool value)91 inline static const char* toString(bool value) {
92     return value ? "true" : "false";
93 }
94 
95 // --- InputMessage ---
96 
isValid(size_t actualSize) const97 bool InputMessage::isValid(size_t actualSize) const {
98     if (size() == actualSize) {
99         switch (header.type) {
100             case Type::KEY:
101                 return true;
102             case Type::MOTION:
103                 return body.motion.pointerCount > 0 && body.motion.pointerCount <= MAX_POINTERS;
104             case Type::FINISHED:
105                 return true;
106             case Type::FOCUS:
107                 return true;
108         }
109     }
110     return false;
111 }
112 
size() const113 size_t InputMessage::size() const {
114     switch (header.type) {
115         case Type::KEY:
116             return sizeof(Header) + body.key.size();
117         case Type::MOTION:
118             return sizeof(Header) + body.motion.size();
119         case Type::FINISHED:
120             return sizeof(Header) + body.finished.size();
121         case Type::FOCUS:
122             return sizeof(Header) + body.focus.size();
123     }
124     return sizeof(Header);
125 }
126 
127 /**
128  * There could be non-zero bytes in-between InputMessage fields. Force-initialize the entire
129  * memory to zero, then only copy the valid bytes on a per-field basis.
130  */
getSanitizedCopy(InputMessage * msg) const131 void InputMessage::getSanitizedCopy(InputMessage* msg) const {
132     memset(msg, 0, sizeof(*msg));
133 
134     // Write the header
135     msg->header.type = header.type;
136 
137     // Write the body
138     switch(header.type) {
139         case InputMessage::Type::KEY: {
140             // uint32_t seq
141             msg->body.key.seq = body.key.seq;
142             // int32_t eventId
143             msg->body.key.eventId = body.key.eventId;
144             // nsecs_t eventTime
145             msg->body.key.eventTime = body.key.eventTime;
146             // int32_t deviceId
147             msg->body.key.deviceId = body.key.deviceId;
148             // int32_t source
149             msg->body.key.source = body.key.source;
150             // int32_t displayId
151             msg->body.key.displayId = body.key.displayId;
152             // std::array<uint8_t, 32> hmac
153             msg->body.key.hmac = body.key.hmac;
154             // int32_t action
155             msg->body.key.action = body.key.action;
156             // int32_t flags
157             msg->body.key.flags = body.key.flags;
158             // int32_t keyCode
159             msg->body.key.keyCode = body.key.keyCode;
160             // int32_t scanCode
161             msg->body.key.scanCode = body.key.scanCode;
162             // int32_t metaState
163             msg->body.key.metaState = body.key.metaState;
164             // int32_t repeatCount
165             msg->body.key.repeatCount = body.key.repeatCount;
166             // nsecs_t downTime
167             msg->body.key.downTime = body.key.downTime;
168             break;
169         }
170         case InputMessage::Type::MOTION: {
171             // uint32_t seq
172             msg->body.motion.seq = body.motion.seq;
173             // int32_t eventId
174             msg->body.motion.eventId = body.motion.eventId;
175             // nsecs_t eventTime
176             msg->body.motion.eventTime = body.motion.eventTime;
177             // int32_t deviceId
178             msg->body.motion.deviceId = body.motion.deviceId;
179             // int32_t source
180             msg->body.motion.source = body.motion.source;
181             // int32_t displayId
182             msg->body.motion.displayId = body.motion.displayId;
183             // std::array<uint8_t, 32> hmac
184             msg->body.motion.hmac = body.motion.hmac;
185             // int32_t action
186             msg->body.motion.action = body.motion.action;
187             // int32_t actionButton
188             msg->body.motion.actionButton = body.motion.actionButton;
189             // int32_t flags
190             msg->body.motion.flags = body.motion.flags;
191             // int32_t metaState
192             msg->body.motion.metaState = body.motion.metaState;
193             // int32_t buttonState
194             msg->body.motion.buttonState = body.motion.buttonState;
195             // MotionClassification classification
196             msg->body.motion.classification = body.motion.classification;
197             // int32_t edgeFlags
198             msg->body.motion.edgeFlags = body.motion.edgeFlags;
199             // nsecs_t downTime
200             msg->body.motion.downTime = body.motion.downTime;
201             // float xScale
202             msg->body.motion.xScale = body.motion.xScale;
203             // float yScale
204             msg->body.motion.yScale = body.motion.yScale;
205             // float xOffset
206             msg->body.motion.xOffset = body.motion.xOffset;
207             // float yOffset
208             msg->body.motion.yOffset = body.motion.yOffset;
209             // float xPrecision
210             msg->body.motion.xPrecision = body.motion.xPrecision;
211             // float yPrecision
212             msg->body.motion.yPrecision = body.motion.yPrecision;
213             // float xCursorPosition
214             msg->body.motion.xCursorPosition = body.motion.xCursorPosition;
215             // float yCursorPosition
216             msg->body.motion.yCursorPosition = body.motion.yCursorPosition;
217             // uint32_t pointerCount
218             msg->body.motion.pointerCount = body.motion.pointerCount;
219             //struct Pointer pointers[MAX_POINTERS]
220             for (size_t i = 0; i < body.motion.pointerCount; i++) {
221                 // PointerProperties properties
222                 msg->body.motion.pointers[i].properties.id = body.motion.pointers[i].properties.id;
223                 msg->body.motion.pointers[i].properties.toolType =
224                         body.motion.pointers[i].properties.toolType,
225                 // PointerCoords coords
226                 msg->body.motion.pointers[i].coords.bits = body.motion.pointers[i].coords.bits;
227                 const uint32_t count = BitSet64::count(body.motion.pointers[i].coords.bits);
228                 memcpy(&msg->body.motion.pointers[i].coords.values[0],
229                         &body.motion.pointers[i].coords.values[0],
230                         count * (sizeof(body.motion.pointers[i].coords.values[0])));
231             }
232             break;
233         }
234         case InputMessage::Type::FINISHED: {
235             msg->body.finished.seq = body.finished.seq;
236             msg->body.finished.handled = body.finished.handled;
237             break;
238         }
239         case InputMessage::Type::FOCUS: {
240             msg->body.focus.seq = body.focus.seq;
241             msg->body.focus.eventId = body.focus.eventId;
242             msg->body.focus.hasFocus = body.focus.hasFocus;
243             msg->body.focus.inTouchMode = body.focus.inTouchMode;
244             break;
245         }
246     }
247 }
248 
249 // --- InputChannel ---
250 
create(const std::string & name,android::base::unique_fd fd,sp<IBinder> token)251 sp<InputChannel> InputChannel::create(const std::string& name, android::base::unique_fd fd,
252                                       sp<IBinder> token) {
253     const int result = fcntl(fd, F_SETFL, O_NONBLOCK);
254     if (result != 0) {
255         LOG_ALWAYS_FATAL("channel '%s' ~ Could not make socket non-blocking: %s", name.c_str(),
256                          strerror(errno));
257         return nullptr;
258     }
259     return new InputChannel(name, std::move(fd), token);
260 }
261 
InputChannel(const std::string & name,android::base::unique_fd fd,sp<IBinder> token)262 InputChannel::InputChannel(const std::string& name, android::base::unique_fd fd, sp<IBinder> token)
263       : mName(name), mFd(std::move(fd)), mToken(token) {
264     if (DEBUG_CHANNEL_LIFECYCLE) {
265         ALOGD("Input channel constructed: name='%s', fd=%d", mName.c_str(), mFd.get());
266     }
267 }
268 
~InputChannel()269 InputChannel::~InputChannel() {
270     if (DEBUG_CHANNEL_LIFECYCLE) {
271         ALOGD("Input channel destroyed: name='%s', fd=%d", mName.c_str(), mFd.get());
272     }
273 }
274 
openInputChannelPair(const std::string & name,sp<InputChannel> & outServerChannel,sp<InputChannel> & outClientChannel)275 status_t InputChannel::openInputChannelPair(const std::string& name,
276         sp<InputChannel>& outServerChannel, sp<InputChannel>& outClientChannel) {
277     int sockets[2];
278     if (socketpair(AF_UNIX, SOCK_SEQPACKET, 0, sockets)) {
279         status_t result = -errno;
280         ALOGE("channel '%s' ~ Could not create socket pair.  errno=%d",
281                 name.c_str(), errno);
282         outServerChannel.clear();
283         outClientChannel.clear();
284         return result;
285     }
286 
287     int bufferSize = SOCKET_BUFFER_SIZE;
288     setsockopt(sockets[0], SOL_SOCKET, SO_SNDBUF, &bufferSize, sizeof(bufferSize));
289     setsockopt(sockets[0], SOL_SOCKET, SO_RCVBUF, &bufferSize, sizeof(bufferSize));
290     setsockopt(sockets[1], SOL_SOCKET, SO_SNDBUF, &bufferSize, sizeof(bufferSize));
291     setsockopt(sockets[1], SOL_SOCKET, SO_RCVBUF, &bufferSize, sizeof(bufferSize));
292 
293     sp<IBinder> token = new BBinder();
294 
295     std::string serverChannelName = name + " (server)";
296     android::base::unique_fd serverFd(sockets[0]);
297     outServerChannel = InputChannel::create(serverChannelName, std::move(serverFd), token);
298 
299     std::string clientChannelName = name + " (client)";
300     android::base::unique_fd clientFd(sockets[1]);
301     outClientChannel = InputChannel::create(clientChannelName, std::move(clientFd), token);
302     return OK;
303 }
304 
sendMessage(const InputMessage * msg)305 status_t InputChannel::sendMessage(const InputMessage* msg) {
306     const size_t msgLength = msg->size();
307     InputMessage cleanMsg;
308     msg->getSanitizedCopy(&cleanMsg);
309     ssize_t nWrite;
310     do {
311         nWrite = ::send(mFd.get(), &cleanMsg, msgLength, MSG_DONTWAIT | MSG_NOSIGNAL);
312     } while (nWrite == -1 && errno == EINTR);
313 
314     if (nWrite < 0) {
315         int error = errno;
316 #if DEBUG_CHANNEL_MESSAGES
317         ALOGD("channel '%s' ~ error sending message of type %d, %s", mName.c_str(),
318               msg->header.type, strerror(error));
319 #endif
320         if (error == EAGAIN || error == EWOULDBLOCK) {
321             return WOULD_BLOCK;
322         }
323         if (error == EPIPE || error == ENOTCONN || error == ECONNREFUSED || error == ECONNRESET) {
324             return DEAD_OBJECT;
325         }
326         return -error;
327     }
328 
329     if (size_t(nWrite) != msgLength) {
330 #if DEBUG_CHANNEL_MESSAGES
331         ALOGD("channel '%s' ~ error sending message type %d, send was incomplete",
332                 mName.c_str(), msg->header.type);
333 #endif
334         return DEAD_OBJECT;
335     }
336 
337 #if DEBUG_CHANNEL_MESSAGES
338     ALOGD("channel '%s' ~ sent message of type %d", mName.c_str(), msg->header.type);
339 #endif
340     return OK;
341 }
342 
receiveMessage(InputMessage * msg)343 status_t InputChannel::receiveMessage(InputMessage* msg) {
344     ssize_t nRead;
345     do {
346         nRead = ::recv(mFd.get(), msg, sizeof(InputMessage), MSG_DONTWAIT);
347     } while (nRead == -1 && errno == EINTR);
348 
349     if (nRead < 0) {
350         int error = errno;
351 #if DEBUG_CHANNEL_MESSAGES
352         ALOGD("channel '%s' ~ receive message failed, errno=%d", mName.c_str(), errno);
353 #endif
354         if (error == EAGAIN || error == EWOULDBLOCK) {
355             return WOULD_BLOCK;
356         }
357         if (error == EPIPE || error == ENOTCONN || error == ECONNREFUSED) {
358             return DEAD_OBJECT;
359         }
360         return -error;
361     }
362 
363     if (nRead == 0) { // check for EOF
364 #if DEBUG_CHANNEL_MESSAGES
365         ALOGD("channel '%s' ~ receive message failed because peer was closed", mName.c_str());
366 #endif
367         return DEAD_OBJECT;
368     }
369 
370     if (!msg->isValid(nRead)) {
371 #if DEBUG_CHANNEL_MESSAGES
372         ALOGD("channel '%s' ~ received invalid message", mName.c_str());
373 #endif
374         return BAD_VALUE;
375     }
376 
377 #if DEBUG_CHANNEL_MESSAGES
378     ALOGD("channel '%s' ~ received message of type %d", mName.c_str(), msg->header.type);
379 #endif
380     return OK;
381 }
382 
dup() const383 sp<InputChannel> InputChannel::dup() const {
384     android::base::unique_fd newFd(::dup(getFd()));
385     if (!newFd.ok()) {
386         ALOGE("Could not duplicate fd %i for channel %s: %s", getFd(), mName.c_str(),
387               strerror(errno));
388         const bool hitFdLimit = errno == EMFILE || errno == ENFILE;
389         // If this process is out of file descriptors, then throwing that might end up exploding
390         // on the other side of a binder call, which isn't really helpful.
391         // Better to just crash here and hope that the FD leak is slow.
392         // Other failures could be client errors, so we still propagate those back to the caller.
393         LOG_ALWAYS_FATAL_IF(hitFdLimit, "Too many open files, could not duplicate input channel %s",
394                             getName().c_str());
395         return nullptr;
396     }
397     return InputChannel::create(mName, std::move(newFd), mToken);
398 }
399 
write(Parcel & out) const400 status_t InputChannel::write(Parcel& out) const {
401     status_t s = out.writeCString(getName().c_str());
402     if (s != OK) {
403         return s;
404     }
405 
406     s = out.writeStrongBinder(mToken);
407     if (s != OK) {
408         return s;
409     }
410 
411     s = out.writeUniqueFileDescriptor(mFd);
412     return s;
413 }
414 
read(const Parcel & from)415 sp<InputChannel> InputChannel::read(const Parcel& from) {
416     std::string name = from.readCString();
417     sp<IBinder> token = from.readStrongBinder();
418     android::base::unique_fd rawFd;
419     status_t fdResult = from.readUniqueFileDescriptor(&rawFd);
420     if (fdResult != OK) {
421         return nullptr;
422     }
423 
424     return InputChannel::create(name, std::move(rawFd), token);
425 }
426 
getConnectionToken() const427 sp<IBinder> InputChannel::getConnectionToken() const {
428     return mToken;
429 }
430 
431 // --- InputPublisher ---
432 
InputPublisher(const sp<InputChannel> & channel)433 InputPublisher::InputPublisher(const sp<InputChannel>& channel) :
434         mChannel(channel) {
435 }
436 
~InputPublisher()437 InputPublisher::~InputPublisher() {
438 }
439 
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)440 status_t InputPublisher::publishKeyEvent(uint32_t seq, int32_t eventId, int32_t deviceId,
441                                          int32_t source, int32_t displayId,
442                                          std::array<uint8_t, 32> hmac, int32_t action,
443                                          int32_t flags, int32_t keyCode, int32_t scanCode,
444                                          int32_t metaState, int32_t repeatCount, nsecs_t downTime,
445                                          nsecs_t eventTime) {
446     if (ATRACE_ENABLED()) {
447         std::string message = StringPrintf("publishKeyEvent(inputChannel=%s, keyCode=%" PRId32 ")",
448                 mChannel->getName().c_str(), keyCode);
449         ATRACE_NAME(message.c_str());
450     }
451     if (DEBUG_TRANSPORT_ACTIONS) {
452         ALOGD("channel '%s' publisher ~ publishKeyEvent: seq=%u, deviceId=%d, source=0x%x, "
453               "action=0x%x, flags=0x%x, keyCode=%d, scanCode=%d, metaState=0x%x, repeatCount=%d,"
454               "downTime=%" PRId64 ", eventTime=%" PRId64,
455               mChannel->getName().c_str(), seq, deviceId, source, action, flags, keyCode, scanCode,
456               metaState, repeatCount, downTime, eventTime);
457     }
458 
459     if (!seq) {
460         ALOGE("Attempted to publish a key event with sequence number 0.");
461         return BAD_VALUE;
462     }
463 
464     InputMessage msg;
465     msg.header.type = InputMessage::Type::KEY;
466     msg.body.key.seq = seq;
467     msg.body.key.eventId = eventId;
468     msg.body.key.deviceId = deviceId;
469     msg.body.key.source = source;
470     msg.body.key.displayId = displayId;
471     msg.body.key.hmac = std::move(hmac);
472     msg.body.key.action = action;
473     msg.body.key.flags = flags;
474     msg.body.key.keyCode = keyCode;
475     msg.body.key.scanCode = scanCode;
476     msg.body.key.metaState = metaState;
477     msg.body.key.repeatCount = repeatCount;
478     msg.body.key.downTime = downTime;
479     msg.body.key.eventTime = eventTime;
480     return mChannel->sendMessage(&msg);
481 }
482 
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,float xScale,float yScale,float xOffset,float yOffset,float xPrecision,float yPrecision,float xCursorPosition,float yCursorPosition,nsecs_t downTime,nsecs_t eventTime,uint32_t pointerCount,const PointerProperties * pointerProperties,const PointerCoords * pointerCoords)483 status_t InputPublisher::publishMotionEvent(
484         uint32_t seq, int32_t eventId, int32_t deviceId, int32_t source, int32_t displayId,
485         std::array<uint8_t, 32> hmac, int32_t action, int32_t actionButton, int32_t flags,
486         int32_t edgeFlags, int32_t metaState, int32_t buttonState,
487         MotionClassification classification, float xScale, float yScale, float xOffset,
488         float yOffset, float xPrecision, float yPrecision, float xCursorPosition,
489         float yCursorPosition, nsecs_t downTime, nsecs_t eventTime, uint32_t pointerCount,
490         const PointerProperties* pointerProperties, const PointerCoords* pointerCoords) {
491     if (ATRACE_ENABLED()) {
492         std::string message = StringPrintf(
493                 "publishMotionEvent(inputChannel=%s, action=%" PRId32 ")",
494                 mChannel->getName().c_str(), action);
495         ATRACE_NAME(message.c_str());
496     }
497     if (DEBUG_TRANSPORT_ACTIONS) {
498         ALOGD("channel '%s' publisher ~ publishMotionEvent: seq=%u, deviceId=%d, source=0x%x, "
499               "displayId=%" PRId32 ", "
500               "action=0x%x, actionButton=0x%08x, flags=0x%x, edgeFlags=0x%x, "
501               "metaState=0x%x, buttonState=0x%x, classification=%s, xScale=%.1f, yScale=%.1f, "
502               "xOffset=%.1f, yOffset=%.1f, "
503               "xPrecision=%f, yPrecision=%f, downTime=%" PRId64 ", eventTime=%" PRId64 ", "
504               "pointerCount=%" PRIu32,
505               mChannel->getName().c_str(), seq, deviceId, source, displayId, action, actionButton,
506               flags, edgeFlags, metaState, buttonState,
507               motionClassificationToString(classification), xScale, yScale, xOffset, yOffset,
508               xPrecision, yPrecision, downTime, eventTime, pointerCount);
509     }
510 
511     if (!seq) {
512         ALOGE("Attempted to publish a motion event with sequence number 0.");
513         return BAD_VALUE;
514     }
515 
516     if (pointerCount > MAX_POINTERS || pointerCount < 1) {
517         ALOGE("channel '%s' publisher ~ Invalid number of pointers provided: %" PRIu32 ".",
518                 mChannel->getName().c_str(), pointerCount);
519         return BAD_VALUE;
520     }
521 
522     InputMessage msg;
523     msg.header.type = InputMessage::Type::MOTION;
524     msg.body.motion.seq = seq;
525     msg.body.motion.eventId = eventId;
526     msg.body.motion.deviceId = deviceId;
527     msg.body.motion.source = source;
528     msg.body.motion.displayId = displayId;
529     msg.body.motion.hmac = std::move(hmac);
530     msg.body.motion.action = action;
531     msg.body.motion.actionButton = actionButton;
532     msg.body.motion.flags = flags;
533     msg.body.motion.edgeFlags = edgeFlags;
534     msg.body.motion.metaState = metaState;
535     msg.body.motion.buttonState = buttonState;
536     msg.body.motion.classification = classification;
537     msg.body.motion.xScale = xScale;
538     msg.body.motion.yScale = yScale;
539     msg.body.motion.xOffset = xOffset;
540     msg.body.motion.yOffset = yOffset;
541     msg.body.motion.xPrecision = xPrecision;
542     msg.body.motion.yPrecision = yPrecision;
543     msg.body.motion.xCursorPosition = xCursorPosition;
544     msg.body.motion.yCursorPosition = yCursorPosition;
545     msg.body.motion.downTime = downTime;
546     msg.body.motion.eventTime = eventTime;
547     msg.body.motion.pointerCount = pointerCount;
548     for (uint32_t i = 0; i < pointerCount; i++) {
549         msg.body.motion.pointers[i].properties.copyFrom(pointerProperties[i]);
550         msg.body.motion.pointers[i].coords.copyFrom(pointerCoords[i]);
551     }
552 
553     return mChannel->sendMessage(&msg);
554 }
555 
publishFocusEvent(uint32_t seq,int32_t eventId,bool hasFocus,bool inTouchMode)556 status_t InputPublisher::publishFocusEvent(uint32_t seq, int32_t eventId, bool hasFocus,
557                                            bool inTouchMode) {
558     if (ATRACE_ENABLED()) {
559         std::string message =
560                 StringPrintf("publishFocusEvent(inputChannel=%s, hasFocus=%s, inTouchMode=%s)",
561                              mChannel->getName().c_str(), toString(hasFocus),
562                              toString(inTouchMode));
563         ATRACE_NAME(message.c_str());
564     }
565 
566     InputMessage msg;
567     msg.header.type = InputMessage::Type::FOCUS;
568     msg.body.focus.seq = seq;
569     msg.body.focus.eventId = eventId;
570     msg.body.focus.hasFocus = hasFocus ? 1 : 0;
571     msg.body.focus.inTouchMode = inTouchMode ? 1 : 0;
572     return mChannel->sendMessage(&msg);
573 }
574 
receiveFinishedSignal(uint32_t * outSeq,bool * outHandled)575 status_t InputPublisher::receiveFinishedSignal(uint32_t* outSeq, bool* outHandled) {
576     if (DEBUG_TRANSPORT_ACTIONS) {
577         ALOGD("channel '%s' publisher ~ receiveFinishedSignal", mChannel->getName().c_str());
578     }
579 
580     InputMessage msg;
581     status_t result = mChannel->receiveMessage(&msg);
582     if (result) {
583         *outSeq = 0;
584         *outHandled = false;
585         return result;
586     }
587     if (msg.header.type != InputMessage::Type::FINISHED) {
588         ALOGE("channel '%s' publisher ~ Received unexpected message of type %d from consumer",
589                 mChannel->getName().c_str(), msg.header.type);
590         return UNKNOWN_ERROR;
591     }
592     *outSeq = msg.body.finished.seq;
593     *outHandled = msg.body.finished.handled == 1;
594     return OK;
595 }
596 
597 // --- InputConsumer ---
598 
InputConsumer(const sp<InputChannel> & channel)599 InputConsumer::InputConsumer(const sp<InputChannel>& channel) :
600         mResampleTouch(isTouchResamplingEnabled()),
601         mChannel(channel), mMsgDeferred(false) {
602 }
603 
~InputConsumer()604 InputConsumer::~InputConsumer() {
605 }
606 
isTouchResamplingEnabled()607 bool InputConsumer::isTouchResamplingEnabled() {
608     return property_get_bool(PROPERTY_RESAMPLING_ENABLED, true);
609 }
610 
consume(InputEventFactoryInterface * factory,bool consumeBatches,nsecs_t frameTime,uint32_t * outSeq,InputEvent ** outEvent)611 status_t InputConsumer::consume(InputEventFactoryInterface* factory, bool consumeBatches,
612                                 nsecs_t frameTime, uint32_t* outSeq, InputEvent** outEvent) {
613     if (DEBUG_TRANSPORT_ACTIONS) {
614         ALOGD("channel '%s' consumer ~ consume: consumeBatches=%s, frameTime=%" PRId64,
615               mChannel->getName().c_str(), toString(consumeBatches), frameTime);
616     }
617 
618     *outSeq = 0;
619     *outEvent = nullptr;
620 
621     // Fetch the next input message.
622     // Loop until an event can be returned or no additional events are received.
623     while (!*outEvent) {
624         if (mMsgDeferred) {
625             // mMsg contains a valid input message from the previous call to consume
626             // that has not yet been processed.
627             mMsgDeferred = false;
628         } else {
629             // Receive a fresh message.
630             status_t result = mChannel->receiveMessage(&mMsg);
631             if (result) {
632                 // Consume the next batched event unless batches are being held for later.
633                 if (consumeBatches || result != WOULD_BLOCK) {
634                     result = consumeBatch(factory, frameTime, outSeq, outEvent);
635                     if (*outEvent) {
636                         if (DEBUG_TRANSPORT_ACTIONS) {
637                             ALOGD("channel '%s' consumer ~ consumed batch event, seq=%u",
638                                   mChannel->getName().c_str(), *outSeq);
639                         }
640                         break;
641                     }
642                 }
643                 return result;
644             }
645         }
646 
647         switch (mMsg.header.type) {
648             case InputMessage::Type::KEY: {
649                 KeyEvent* keyEvent = factory->createKeyEvent();
650                 if (!keyEvent) return NO_MEMORY;
651 
652                 initializeKeyEvent(keyEvent, &mMsg);
653                 *outSeq = mMsg.body.key.seq;
654                 *outEvent = keyEvent;
655                 if (DEBUG_TRANSPORT_ACTIONS) {
656                     ALOGD("channel '%s' consumer ~ consumed key event, seq=%u",
657                           mChannel->getName().c_str(), *outSeq);
658                 }
659             break;
660             }
661 
662             case InputMessage::Type::MOTION: {
663                 ssize_t batchIndex = findBatch(mMsg.body.motion.deviceId, mMsg.body.motion.source);
664                 if (batchIndex >= 0) {
665                     Batch& batch = mBatches.editItemAt(batchIndex);
666                     if (canAddSample(batch, &mMsg)) {
667                         batch.samples.push(mMsg);
668                         if (DEBUG_TRANSPORT_ACTIONS) {
669                             ALOGD("channel '%s' consumer ~ appended to batch event",
670                                   mChannel->getName().c_str());
671                         }
672                     break;
673                     } else if (isPointerEvent(mMsg.body.motion.source) &&
674                                mMsg.body.motion.action == AMOTION_EVENT_ACTION_CANCEL) {
675                         // No need to process events that we are going to cancel anyways
676                         const size_t count = batch.samples.size();
677                         for (size_t i = 0; i < count; i++) {
678                             const InputMessage& msg = batch.samples.itemAt(i);
679                             sendFinishedSignal(msg.body.motion.seq, false);
680                         }
681                         batch.samples.removeItemsAt(0, count);
682                         mBatches.removeAt(batchIndex);
683                     } else {
684                         // We cannot append to the batch in progress, so we need to consume
685                         // the previous batch right now and defer the new message until later.
686                         mMsgDeferred = true;
687                         status_t result = consumeSamples(factory, batch, batch.samples.size(),
688                                                          outSeq, outEvent);
689                         mBatches.removeAt(batchIndex);
690                         if (result) {
691                             return result;
692                         }
693                         if (DEBUG_TRANSPORT_ACTIONS) {
694                             ALOGD("channel '%s' consumer ~ consumed batch event and "
695                                   "deferred current event, seq=%u",
696                                   mChannel->getName().c_str(), *outSeq);
697                         }
698                     break;
699                     }
700                 }
701 
702                 // Start a new batch if needed.
703                 if (mMsg.body.motion.action == AMOTION_EVENT_ACTION_MOVE ||
704                     mMsg.body.motion.action == AMOTION_EVENT_ACTION_HOVER_MOVE) {
705                     mBatches.push();
706                     Batch& batch = mBatches.editTop();
707                     batch.samples.push(mMsg);
708                     if (DEBUG_TRANSPORT_ACTIONS) {
709                         ALOGD("channel '%s' consumer ~ started batch event",
710                               mChannel->getName().c_str());
711                     }
712                     break;
713                 }
714 
715                 MotionEvent* motionEvent = factory->createMotionEvent();
716                 if (!motionEvent) return NO_MEMORY;
717 
718                 updateTouchState(mMsg);
719                 initializeMotionEvent(motionEvent, &mMsg);
720                 *outSeq = mMsg.body.motion.seq;
721                 *outEvent = motionEvent;
722 
723                 if (DEBUG_TRANSPORT_ACTIONS) {
724                     ALOGD("channel '%s' consumer ~ consumed motion event, seq=%u",
725                           mChannel->getName().c_str(), *outSeq);
726                 }
727                 break;
728             }
729 
730             case InputMessage::Type::FINISHED: {
731                 LOG_ALWAYS_FATAL("Consumed a FINISHED message, which should never be seen by "
732                                  "InputConsumer!");
733                 break;
734             }
735 
736             case InputMessage::Type::FOCUS: {
737                 FocusEvent* focusEvent = factory->createFocusEvent();
738                 if (!focusEvent) return NO_MEMORY;
739 
740                 initializeFocusEvent(focusEvent, &mMsg);
741                 *outSeq = mMsg.body.focus.seq;
742                 *outEvent = focusEvent;
743                 break;
744             }
745         }
746     }
747     return OK;
748 }
749 
consumeBatch(InputEventFactoryInterface * factory,nsecs_t frameTime,uint32_t * outSeq,InputEvent ** outEvent)750 status_t InputConsumer::consumeBatch(InputEventFactoryInterface* factory,
751         nsecs_t frameTime, uint32_t* outSeq, InputEvent** outEvent) {
752     status_t result;
753     for (size_t i = mBatches.size(); i > 0; ) {
754         i--;
755         Batch& batch = mBatches.editItemAt(i);
756         if (frameTime < 0) {
757             result = consumeSamples(factory, batch, batch.samples.size(), outSeq, outEvent);
758             mBatches.removeAt(i);
759             return result;
760         }
761 
762         nsecs_t sampleTime = frameTime;
763         if (mResampleTouch) {
764             sampleTime -= RESAMPLE_LATENCY;
765         }
766         ssize_t split = findSampleNoLaterThan(batch, sampleTime);
767         if (split < 0) {
768             continue;
769         }
770 
771         result = consumeSamples(factory, batch, split + 1, outSeq, outEvent);
772         const InputMessage* next;
773         if (batch.samples.isEmpty()) {
774             mBatches.removeAt(i);
775             next = nullptr;
776         } else {
777             next = &batch.samples.itemAt(0);
778         }
779         if (!result && mResampleTouch) {
780             resampleTouchState(sampleTime, static_cast<MotionEvent*>(*outEvent), next);
781         }
782         return result;
783     }
784 
785     return WOULD_BLOCK;
786 }
787 
consumeSamples(InputEventFactoryInterface * factory,Batch & batch,size_t count,uint32_t * outSeq,InputEvent ** outEvent)788 status_t InputConsumer::consumeSamples(InputEventFactoryInterface* factory,
789         Batch& batch, size_t count, uint32_t* outSeq, InputEvent** outEvent) {
790     MotionEvent* motionEvent = factory->createMotionEvent();
791     if (! motionEvent) return NO_MEMORY;
792 
793     uint32_t chain = 0;
794     for (size_t i = 0; i < count; i++) {
795         InputMessage& msg = batch.samples.editItemAt(i);
796         updateTouchState(msg);
797         if (i) {
798             SeqChain seqChain;
799             seqChain.seq = msg.body.motion.seq;
800             seqChain.chain = chain;
801             mSeqChains.push(seqChain);
802             addSample(motionEvent, &msg);
803         } else {
804             initializeMotionEvent(motionEvent, &msg);
805         }
806         chain = msg.body.motion.seq;
807     }
808     batch.samples.removeItemsAt(0, count);
809 
810     *outSeq = chain;
811     *outEvent = motionEvent;
812     return OK;
813 }
814 
updateTouchState(InputMessage & msg)815 void InputConsumer::updateTouchState(InputMessage& msg) {
816     if (!mResampleTouch || !isPointerEvent(msg.body.motion.source)) {
817         return;
818     }
819 
820     int32_t deviceId = msg.body.motion.deviceId;
821     int32_t source = msg.body.motion.source;
822 
823     // Update the touch state history to incorporate the new input message.
824     // If the message is in the past relative to the most recently produced resampled
825     // touch, then use the resampled time and coordinates instead.
826     switch (msg.body.motion.action & AMOTION_EVENT_ACTION_MASK) {
827     case AMOTION_EVENT_ACTION_DOWN: {
828         ssize_t index = findTouchState(deviceId, source);
829         if (index < 0) {
830             mTouchStates.push();
831             index = mTouchStates.size() - 1;
832         }
833         TouchState& touchState = mTouchStates.editItemAt(index);
834         touchState.initialize(deviceId, source);
835         touchState.addHistory(msg);
836         break;
837     }
838 
839     case AMOTION_EVENT_ACTION_MOVE: {
840         ssize_t index = findTouchState(deviceId, source);
841         if (index >= 0) {
842             TouchState& touchState = mTouchStates.editItemAt(index);
843             touchState.addHistory(msg);
844             rewriteMessage(touchState, msg);
845         }
846         break;
847     }
848 
849     case AMOTION_EVENT_ACTION_POINTER_DOWN: {
850         ssize_t index = findTouchState(deviceId, source);
851         if (index >= 0) {
852             TouchState& touchState = mTouchStates.editItemAt(index);
853             touchState.lastResample.idBits.clearBit(msg.body.motion.getActionId());
854             rewriteMessage(touchState, msg);
855         }
856         break;
857     }
858 
859     case AMOTION_EVENT_ACTION_POINTER_UP: {
860         ssize_t index = findTouchState(deviceId, source);
861         if (index >= 0) {
862             TouchState& touchState = mTouchStates.editItemAt(index);
863             rewriteMessage(touchState, msg);
864             touchState.lastResample.idBits.clearBit(msg.body.motion.getActionId());
865         }
866         break;
867     }
868 
869     case AMOTION_EVENT_ACTION_SCROLL: {
870         ssize_t index = findTouchState(deviceId, source);
871         if (index >= 0) {
872             TouchState& touchState = mTouchStates.editItemAt(index);
873             rewriteMessage(touchState, msg);
874         }
875         break;
876     }
877 
878     case AMOTION_EVENT_ACTION_UP:
879     case AMOTION_EVENT_ACTION_CANCEL: {
880         ssize_t index = findTouchState(deviceId, source);
881         if (index >= 0) {
882             TouchState& touchState = mTouchStates.editItemAt(index);
883             rewriteMessage(touchState, msg);
884             mTouchStates.removeAt(index);
885         }
886         break;
887     }
888     }
889 }
890 
891 /**
892  * Replace the coordinates in msg with the coordinates in lastResample, if necessary.
893  *
894  * If lastResample is no longer valid for a specific pointer (i.e. the lastResample time
895  * is in the past relative to msg and the past two events do not contain identical coordinates),
896  * then invalidate the lastResample data for that pointer.
897  * If the two past events have identical coordinates, then lastResample data for that pointer will
898  * remain valid, and will be used to replace these coordinates. Thus, if a certain coordinate x0 is
899  * resampled to the new value x1, then x1 will always be used to replace x0 until some new value
900  * not equal to x0 is received.
901  */
rewriteMessage(TouchState & state,InputMessage & msg)902 void InputConsumer::rewriteMessage(TouchState& state, InputMessage& msg) {
903     nsecs_t eventTime = msg.body.motion.eventTime;
904     for (uint32_t i = 0; i < msg.body.motion.pointerCount; i++) {
905         uint32_t id = msg.body.motion.pointers[i].properties.id;
906         if (state.lastResample.idBits.hasBit(id)) {
907             if (eventTime < state.lastResample.eventTime ||
908                     state.recentCoordinatesAreIdentical(id)) {
909                 PointerCoords& msgCoords = msg.body.motion.pointers[i].coords;
910                 const PointerCoords& resampleCoords = state.lastResample.getPointerById(id);
911 #if DEBUG_RESAMPLING
912                 ALOGD("[%d] - rewrite (%0.3f, %0.3f), old (%0.3f, %0.3f)", id,
913                         resampleCoords.getX(), resampleCoords.getY(),
914                         msgCoords.getX(), msgCoords.getY());
915 #endif
916                 msgCoords.setAxisValue(AMOTION_EVENT_AXIS_X, resampleCoords.getX());
917                 msgCoords.setAxisValue(AMOTION_EVENT_AXIS_Y, resampleCoords.getY());
918             } else {
919                 state.lastResample.idBits.clearBit(id);
920             }
921         }
922     }
923 }
924 
resampleTouchState(nsecs_t sampleTime,MotionEvent * event,const InputMessage * next)925 void InputConsumer::resampleTouchState(nsecs_t sampleTime, MotionEvent* event,
926     const InputMessage* next) {
927     if (!mResampleTouch
928             || !(isPointerEvent(event->getSource()))
929             || event->getAction() != AMOTION_EVENT_ACTION_MOVE) {
930         return;
931     }
932 
933     ssize_t index = findTouchState(event->getDeviceId(), event->getSource());
934     if (index < 0) {
935 #if DEBUG_RESAMPLING
936         ALOGD("Not resampled, no touch state for device.");
937 #endif
938         return;
939     }
940 
941     TouchState& touchState = mTouchStates.editItemAt(index);
942     if (touchState.historySize < 1) {
943 #if DEBUG_RESAMPLING
944         ALOGD("Not resampled, no history for device.");
945 #endif
946         return;
947     }
948 
949     // Ensure that the current sample has all of the pointers that need to be reported.
950     const History* current = touchState.getHistory(0);
951     size_t pointerCount = event->getPointerCount();
952     for (size_t i = 0; i < pointerCount; i++) {
953         uint32_t id = event->getPointerId(i);
954         if (!current->idBits.hasBit(id)) {
955 #if DEBUG_RESAMPLING
956             ALOGD("Not resampled, missing id %d", id);
957 #endif
958             return;
959         }
960     }
961 
962     // Find the data to use for resampling.
963     const History* other;
964     History future;
965     float alpha;
966     if (next) {
967         // Interpolate between current sample and future sample.
968         // So current->eventTime <= sampleTime <= future.eventTime.
969         future.initializeFrom(*next);
970         other = &future;
971         nsecs_t delta = future.eventTime - current->eventTime;
972         if (delta < RESAMPLE_MIN_DELTA) {
973 #if DEBUG_RESAMPLING
974             ALOGD("Not resampled, delta time is too small: %" PRId64 " ns.", delta);
975 #endif
976             return;
977         }
978         alpha = float(sampleTime - current->eventTime) / delta;
979     } else if (touchState.historySize >= 2) {
980         // Extrapolate future sample using current sample and past sample.
981         // So other->eventTime <= current->eventTime <= sampleTime.
982         other = touchState.getHistory(1);
983         nsecs_t delta = current->eventTime - other->eventTime;
984         if (delta < RESAMPLE_MIN_DELTA) {
985 #if DEBUG_RESAMPLING
986             ALOGD("Not resampled, delta time is too small: %" PRId64 " ns.", delta);
987 #endif
988             return;
989         } else if (delta > RESAMPLE_MAX_DELTA) {
990 #if DEBUG_RESAMPLING
991             ALOGD("Not resampled, delta time is too large: %" PRId64 " ns.", delta);
992 #endif
993             return;
994         }
995         nsecs_t maxPredict = current->eventTime + min(delta / 2, RESAMPLE_MAX_PREDICTION);
996         if (sampleTime > maxPredict) {
997 #if DEBUG_RESAMPLING
998             ALOGD("Sample time is too far in the future, adjusting prediction "
999                     "from %" PRId64 " to %" PRId64 " ns.",
1000                     sampleTime - current->eventTime, maxPredict - current->eventTime);
1001 #endif
1002             sampleTime = maxPredict;
1003         }
1004         alpha = float(current->eventTime - sampleTime) / delta;
1005     } else {
1006 #if DEBUG_RESAMPLING
1007         ALOGD("Not resampled, insufficient data.");
1008 #endif
1009         return;
1010     }
1011 
1012     // Resample touch coordinates.
1013     History oldLastResample;
1014     oldLastResample.initializeFrom(touchState.lastResample);
1015     touchState.lastResample.eventTime = sampleTime;
1016     touchState.lastResample.idBits.clear();
1017     for (size_t i = 0; i < pointerCount; i++) {
1018         uint32_t id = event->getPointerId(i);
1019         touchState.lastResample.idToIndex[id] = i;
1020         touchState.lastResample.idBits.markBit(id);
1021         if (oldLastResample.hasPointerId(id) && touchState.recentCoordinatesAreIdentical(id)) {
1022             // We maintain the previously resampled value for this pointer (stored in
1023             // oldLastResample) when the coordinates for this pointer haven't changed since then.
1024             // This way we don't introduce artificial jitter when pointers haven't actually moved.
1025 
1026             // We know here that the coordinates for the pointer haven't changed because we
1027             // would've cleared the resampled bit in rewriteMessage if they had. We can't modify
1028             // lastResample in place becasue the mapping from pointer ID to index may have changed.
1029             touchState.lastResample.pointers[i].copyFrom(oldLastResample.getPointerById(id));
1030             continue;
1031         }
1032 
1033         PointerCoords& resampledCoords = touchState.lastResample.pointers[i];
1034         const PointerCoords& currentCoords = current->getPointerById(id);
1035         resampledCoords.copyFrom(currentCoords);
1036         if (other->idBits.hasBit(id)
1037                 && shouldResampleTool(event->getToolType(i))) {
1038             const PointerCoords& otherCoords = other->getPointerById(id);
1039             resampledCoords.setAxisValue(AMOTION_EVENT_AXIS_X,
1040                     lerp(currentCoords.getX(), otherCoords.getX(), alpha));
1041             resampledCoords.setAxisValue(AMOTION_EVENT_AXIS_Y,
1042                     lerp(currentCoords.getY(), otherCoords.getY(), alpha));
1043 #if DEBUG_RESAMPLING
1044             ALOGD("[%d] - out (%0.3f, %0.3f), cur (%0.3f, %0.3f), "
1045                     "other (%0.3f, %0.3f), alpha %0.3f",
1046                     id, resampledCoords.getX(), resampledCoords.getY(),
1047                     currentCoords.getX(), currentCoords.getY(),
1048                     otherCoords.getX(), otherCoords.getY(),
1049                     alpha);
1050 #endif
1051         } else {
1052 #if DEBUG_RESAMPLING
1053             ALOGD("[%d] - out (%0.3f, %0.3f), cur (%0.3f, %0.3f)",
1054                     id, resampledCoords.getX(), resampledCoords.getY(),
1055                     currentCoords.getX(), currentCoords.getY());
1056 #endif
1057         }
1058     }
1059 
1060     event->addSample(sampleTime, touchState.lastResample.pointers);
1061 }
1062 
shouldResampleTool(int32_t toolType)1063 bool InputConsumer::shouldResampleTool(int32_t toolType) {
1064     return toolType == AMOTION_EVENT_TOOL_TYPE_FINGER
1065             || toolType == AMOTION_EVENT_TOOL_TYPE_UNKNOWN;
1066 }
1067 
sendFinishedSignal(uint32_t seq,bool handled)1068 status_t InputConsumer::sendFinishedSignal(uint32_t seq, bool handled) {
1069     if (DEBUG_TRANSPORT_ACTIONS) {
1070         ALOGD("channel '%s' consumer ~ sendFinishedSignal: seq=%u, handled=%s",
1071               mChannel->getName().c_str(), seq, toString(handled));
1072     }
1073 
1074     if (!seq) {
1075         ALOGE("Attempted to send a finished signal with sequence number 0.");
1076         return BAD_VALUE;
1077     }
1078 
1079     // Send finished signals for the batch sequence chain first.
1080     size_t seqChainCount = mSeqChains.size();
1081     if (seqChainCount) {
1082         uint32_t currentSeq = seq;
1083         uint32_t chainSeqs[seqChainCount];
1084         size_t chainIndex = 0;
1085         for (size_t i = seqChainCount; i > 0; ) {
1086              i--;
1087              const SeqChain& seqChain = mSeqChains.itemAt(i);
1088              if (seqChain.seq == currentSeq) {
1089                  currentSeq = seqChain.chain;
1090                  chainSeqs[chainIndex++] = currentSeq;
1091                  mSeqChains.removeAt(i);
1092              }
1093         }
1094         status_t status = OK;
1095         while (!status && chainIndex > 0) {
1096             chainIndex--;
1097             status = sendUnchainedFinishedSignal(chainSeqs[chainIndex], handled);
1098         }
1099         if (status) {
1100             // An error occurred so at least one signal was not sent, reconstruct the chain.
1101             for (;;) {
1102                 SeqChain seqChain;
1103                 seqChain.seq = chainIndex != 0 ? chainSeqs[chainIndex - 1] : seq;
1104                 seqChain.chain = chainSeqs[chainIndex];
1105                 mSeqChains.push(seqChain);
1106                 if (!chainIndex) break;
1107                 chainIndex--;
1108             }
1109             return status;
1110         }
1111     }
1112 
1113     // Send finished signal for the last message in the batch.
1114     return sendUnchainedFinishedSignal(seq, handled);
1115 }
1116 
sendUnchainedFinishedSignal(uint32_t seq,bool handled)1117 status_t InputConsumer::sendUnchainedFinishedSignal(uint32_t seq, bool handled) {
1118     InputMessage msg;
1119     msg.header.type = InputMessage::Type::FINISHED;
1120     msg.body.finished.seq = seq;
1121     msg.body.finished.handled = handled ? 1 : 0;
1122     return mChannel->sendMessage(&msg);
1123 }
1124 
hasDeferredEvent() const1125 bool InputConsumer::hasDeferredEvent() const {
1126     return mMsgDeferred;
1127 }
1128 
hasPendingBatch() const1129 bool InputConsumer::hasPendingBatch() const {
1130     return !mBatches.isEmpty();
1131 }
1132 
getPendingBatchSource() const1133 int32_t InputConsumer::getPendingBatchSource() const {
1134     if (mBatches.isEmpty()) {
1135         return AINPUT_SOURCE_CLASS_NONE;
1136     }
1137 
1138     const Batch& batch = mBatches.itemAt(0);
1139     const InputMessage& head = batch.samples.itemAt(0);
1140     return head.body.motion.source;
1141 }
1142 
findBatch(int32_t deviceId,int32_t source) const1143 ssize_t InputConsumer::findBatch(int32_t deviceId, int32_t source) const {
1144     for (size_t i = 0; i < mBatches.size(); i++) {
1145         const Batch& batch = mBatches.itemAt(i);
1146         const InputMessage& head = batch.samples.itemAt(0);
1147         if (head.body.motion.deviceId == deviceId && head.body.motion.source == source) {
1148             return i;
1149         }
1150     }
1151     return -1;
1152 }
1153 
findTouchState(int32_t deviceId,int32_t source) const1154 ssize_t InputConsumer::findTouchState(int32_t deviceId, int32_t source) const {
1155     for (size_t i = 0; i < mTouchStates.size(); i++) {
1156         const TouchState& touchState = mTouchStates.itemAt(i);
1157         if (touchState.deviceId == deviceId && touchState.source == source) {
1158             return i;
1159         }
1160     }
1161     return -1;
1162 }
1163 
initializeKeyEvent(KeyEvent * event,const InputMessage * msg)1164 void InputConsumer::initializeKeyEvent(KeyEvent* event, const InputMessage* msg) {
1165     event->initialize(msg->body.key.eventId, msg->body.key.deviceId, msg->body.key.source,
1166                       msg->body.key.displayId, msg->body.key.hmac, msg->body.key.action,
1167                       msg->body.key.flags, msg->body.key.keyCode, msg->body.key.scanCode,
1168                       msg->body.key.metaState, msg->body.key.repeatCount, msg->body.key.downTime,
1169                       msg->body.key.eventTime);
1170 }
1171 
initializeFocusEvent(FocusEvent * event,const InputMessage * msg)1172 void InputConsumer::initializeFocusEvent(FocusEvent* event, const InputMessage* msg) {
1173     event->initialize(msg->body.focus.eventId, msg->body.focus.hasFocus == 1,
1174                       msg->body.focus.inTouchMode == 1);
1175 }
1176 
initializeMotionEvent(MotionEvent * event,const InputMessage * msg)1177 void InputConsumer::initializeMotionEvent(MotionEvent* event, const InputMessage* msg) {
1178     uint32_t pointerCount = msg->body.motion.pointerCount;
1179     PointerProperties pointerProperties[pointerCount];
1180     PointerCoords pointerCoords[pointerCount];
1181     for (uint32_t i = 0; i < pointerCount; i++) {
1182         pointerProperties[i].copyFrom(msg->body.motion.pointers[i].properties);
1183         pointerCoords[i].copyFrom(msg->body.motion.pointers[i].coords);
1184     }
1185 
1186     event->initialize(msg->body.motion.eventId, msg->body.motion.deviceId, msg->body.motion.source,
1187                       msg->body.motion.displayId, msg->body.motion.hmac, msg->body.motion.action,
1188                       msg->body.motion.actionButton, msg->body.motion.flags,
1189                       msg->body.motion.edgeFlags, msg->body.motion.metaState,
1190                       msg->body.motion.buttonState, msg->body.motion.classification,
1191                       msg->body.motion.xScale, msg->body.motion.yScale, msg->body.motion.xOffset,
1192                       msg->body.motion.yOffset, msg->body.motion.xPrecision,
1193                       msg->body.motion.yPrecision, msg->body.motion.xCursorPosition,
1194                       msg->body.motion.yCursorPosition, msg->body.motion.downTime,
1195                       msg->body.motion.eventTime, pointerCount, pointerProperties, pointerCoords);
1196 }
1197 
addSample(MotionEvent * event,const InputMessage * msg)1198 void InputConsumer::addSample(MotionEvent* event, const InputMessage* msg) {
1199     uint32_t pointerCount = msg->body.motion.pointerCount;
1200     PointerCoords pointerCoords[pointerCount];
1201     for (uint32_t i = 0; i < pointerCount; i++) {
1202         pointerCoords[i].copyFrom(msg->body.motion.pointers[i].coords);
1203     }
1204 
1205     event->setMetaState(event->getMetaState() | msg->body.motion.metaState);
1206     event->addSample(msg->body.motion.eventTime, pointerCoords);
1207 }
1208 
canAddSample(const Batch & batch,const InputMessage * msg)1209 bool InputConsumer::canAddSample(const Batch& batch, const InputMessage *msg) {
1210     const InputMessage& head = batch.samples.itemAt(0);
1211     uint32_t pointerCount = msg->body.motion.pointerCount;
1212     if (head.body.motion.pointerCount != pointerCount
1213             || head.body.motion.action != msg->body.motion.action) {
1214         return false;
1215     }
1216     for (size_t i = 0; i < pointerCount; i++) {
1217         if (head.body.motion.pointers[i].properties
1218                 != msg->body.motion.pointers[i].properties) {
1219             return false;
1220         }
1221     }
1222     return true;
1223 }
1224 
findSampleNoLaterThan(const Batch & batch,nsecs_t time)1225 ssize_t InputConsumer::findSampleNoLaterThan(const Batch& batch, nsecs_t time) {
1226     size_t numSamples = batch.samples.size();
1227     size_t index = 0;
1228     while (index < numSamples
1229             && batch.samples.itemAt(index).body.motion.eventTime <= time) {
1230         index += 1;
1231     }
1232     return ssize_t(index) - 1;
1233 }
1234 
1235 } // namespace android
1236