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 #define ATRACE_TAG ATRACE_TAG_INPUT
8 
9 #include <errno.h>
10 #include <fcntl.h>
11 #include <inttypes.h>
12 #include <math.h>
13 #include <poll.h>
14 #include <sys/socket.h>
15 #include <sys/types.h>
16 #include <unistd.h>
17 
18 #include <android-base/logging.h>
19 #include <android-base/properties.h>
20 #include <android-base/stringprintf.h>
21 #include <binder/Parcel.h>
22 #include <cutils/properties.h>
23 #include <ftl/enum.h>
24 #include <log/log.h>
25 #include <utils/Trace.h>
26 
27 #include <com_android_input_flags.h>
28 #include <input/InputTransport.h>
29 #include <input/PrintTools.h>
30 #include <input/TraceTools.h>
31 
32 namespace input_flags = com::android::input::flags;
33 
34 namespace android {
35 
36 namespace {
37 
38 /**
39  * Log debug messages about channel messages (send message, receive message).
40  * Enable this via "adb shell setprop log.tag.InputTransportMessages DEBUG"
41  * (requires restart)
42  */
43 const bool DEBUG_CHANNEL_MESSAGES =
44         __android_log_is_loggable(ANDROID_LOG_DEBUG, LOG_TAG "Messages", ANDROID_LOG_INFO);
45 
46 /**
47  * Log debug messages whenever InputChannel objects are created/destroyed.
48  * Enable this via "adb shell setprop log.tag.InputTransportLifecycle DEBUG"
49  * (requires restart)
50  */
51 const bool DEBUG_CHANNEL_LIFECYCLE =
52         __android_log_is_loggable(ANDROID_LOG_DEBUG, LOG_TAG "Lifecycle", ANDROID_LOG_INFO);
53 
54 const bool IS_DEBUGGABLE_BUILD =
55 #if defined(__ANDROID__)
56         android::base::GetBoolProperty("ro.debuggable", false);
57 #else
58         true;
59 #endif
60 
61 /**
62  * Log debug messages relating to the producer end of the transport channel.
63  * Enable this via "adb shell setprop log.tag.InputTransportPublisher DEBUG".
64  * This requires a restart on non-debuggable (e.g. user) builds, but should take effect immediately
65  * on debuggable builds (e.g. userdebug).
66  */
debugTransportPublisher()67 bool debugTransportPublisher() {
68     if (!IS_DEBUGGABLE_BUILD) {
69         static const bool DEBUG_TRANSPORT_PUBLISHER =
70                 __android_log_is_loggable(ANDROID_LOG_DEBUG, LOG_TAG "Publisher", ANDROID_LOG_INFO);
71         return DEBUG_TRANSPORT_PUBLISHER;
72     }
73     return __android_log_is_loggable(ANDROID_LOG_DEBUG, LOG_TAG "Publisher", ANDROID_LOG_INFO);
74 }
75 
dupChannelFd(int fd)76 android::base::unique_fd dupChannelFd(int fd) {
77     android::base::unique_fd newFd(::dup(fd));
78     if (!newFd.ok()) {
79         ALOGE("Could not duplicate fd %i : %s", fd, strerror(errno));
80         const bool hitFdLimit = errno == EMFILE || errno == ENFILE;
81         // If this process is out of file descriptors, then throwing that might end up exploding
82         // on the other side of a binder call, which isn't really helpful.
83         // Better to just crash here and hope that the FD leak is slow.
84         // Other failures could be client errors, so we still propagate those back to the caller.
85         LOG_ALWAYS_FATAL_IF(hitFdLimit, "Too many open files, could not duplicate input channel");
86         return {};
87     }
88     return newFd;
89 }
90 
91 // Socket buffer size.  The default is typically about 128KB, which is much larger than
92 // we really need.  So we make it smaller.  It just needs to be big enough to hold
93 // a few dozen large multi-finger motion events in the case where an application gets
94 // behind processing touches.
95 constexpr size_t SOCKET_BUFFER_SIZE = 32 * 1024;
96 
97 /**
98  * Crash if the events that are getting sent to the InputPublisher are inconsistent.
99  * Enable this via "adb shell setprop log.tag.InputTransportVerifyEvents DEBUG"
100  */
verifyEvents()101 bool verifyEvents() {
102     return input_flags::enable_outbound_event_verification() ||
103             __android_log_is_loggable(ANDROID_LOG_DEBUG, LOG_TAG "VerifyEvents", ANDROID_LOG_INFO);
104 }
105 
106 } // namespace
107 
108 using android::base::Result;
109 using android::base::StringPrintf;
110 
111 // --- InputMessage ---
112 
isValid(size_t actualSize) const113 bool InputMessage::isValid(size_t actualSize) const {
114     if (size() != actualSize) {
115         ALOGE("Received message of incorrect size %zu (expected %zu)", actualSize, size());
116         return false;
117     }
118 
119     switch (header.type) {
120         case Type::KEY:
121             return true;
122         case Type::MOTION: {
123             const bool valid =
124                     body.motion.pointerCount > 0 && body.motion.pointerCount <= MAX_POINTERS;
125             if (!valid) {
126                 ALOGE("Received invalid MOTION: pointerCount = %" PRIu32, body.motion.pointerCount);
127             }
128             return valid;
129         }
130         case Type::FINISHED:
131         case Type::FOCUS:
132         case Type::CAPTURE:
133         case Type::DRAG:
134         case Type::TOUCH_MODE:
135             return true;
136         case Type::TIMELINE: {
137             const nsecs_t gpuCompletedTime =
138                     body.timeline.graphicsTimeline[GraphicsTimeline::GPU_COMPLETED_TIME];
139             const nsecs_t presentTime =
140                     body.timeline.graphicsTimeline[GraphicsTimeline::PRESENT_TIME];
141             const bool valid = presentTime > gpuCompletedTime;
142             if (!valid) {
143                 ALOGE("Received invalid TIMELINE: gpuCompletedTime = %" PRId64
144                       " presentTime = %" PRId64,
145                       gpuCompletedTime, presentTime);
146             }
147             return valid;
148         }
149     }
150     ALOGE("Invalid message type: %s", ftl::enum_string(header.type).c_str());
151     return false;
152 }
153 
size() const154 size_t InputMessage::size() const {
155     switch (header.type) {
156         case Type::KEY:
157             return sizeof(Header) + body.key.size();
158         case Type::MOTION:
159             return sizeof(Header) + body.motion.size();
160         case Type::FINISHED:
161             return sizeof(Header) + body.finished.size();
162         case Type::FOCUS:
163             return sizeof(Header) + body.focus.size();
164         case Type::CAPTURE:
165             return sizeof(Header) + body.capture.size();
166         case Type::DRAG:
167             return sizeof(Header) + body.drag.size();
168         case Type::TIMELINE:
169             return sizeof(Header) + body.timeline.size();
170         case Type::TOUCH_MODE:
171             return sizeof(Header) + body.touchMode.size();
172     }
173     return sizeof(Header);
174 }
175 
176 /**
177  * There could be non-zero bytes in-between InputMessage fields. Force-initialize the entire
178  * memory to zero, then only copy the valid bytes on a per-field basis.
179  */
getSanitizedCopy(InputMessage * msg) const180 void InputMessage::getSanitizedCopy(InputMessage* msg) const {
181     memset(msg, 0, sizeof(*msg));
182 
183     // Write the header
184     msg->header.type = header.type;
185     msg->header.seq = header.seq;
186 
187     // Write the body
188     switch(header.type) {
189         case InputMessage::Type::KEY: {
190             // int32_t eventId
191             msg->body.key.eventId = body.key.eventId;
192             // nsecs_t eventTime
193             msg->body.key.eventTime = body.key.eventTime;
194             // int32_t deviceId
195             msg->body.key.deviceId = body.key.deviceId;
196             // int32_t source
197             msg->body.key.source = body.key.source;
198             // int32_t displayId
199             msg->body.key.displayId = body.key.displayId;
200             // std::array<uint8_t, 32> hmac
201             msg->body.key.hmac = body.key.hmac;
202             // int32_t action
203             msg->body.key.action = body.key.action;
204             // int32_t flags
205             msg->body.key.flags = body.key.flags;
206             // int32_t keyCode
207             msg->body.key.keyCode = body.key.keyCode;
208             // int32_t scanCode
209             msg->body.key.scanCode = body.key.scanCode;
210             // int32_t metaState
211             msg->body.key.metaState = body.key.metaState;
212             // int32_t repeatCount
213             msg->body.key.repeatCount = body.key.repeatCount;
214             // nsecs_t downTime
215             msg->body.key.downTime = body.key.downTime;
216             break;
217         }
218         case InputMessage::Type::MOTION: {
219             // int32_t eventId
220             msg->body.motion.eventId = body.motion.eventId;
221             // uint32_t pointerCount
222             msg->body.motion.pointerCount = body.motion.pointerCount;
223             // nsecs_t eventTime
224             msg->body.motion.eventTime = body.motion.eventTime;
225             // int32_t deviceId
226             msg->body.motion.deviceId = body.motion.deviceId;
227             // int32_t source
228             msg->body.motion.source = body.motion.source;
229             // int32_t displayId
230             msg->body.motion.displayId = body.motion.displayId;
231             // std::array<uint8_t, 32> hmac
232             msg->body.motion.hmac = body.motion.hmac;
233             // int32_t action
234             msg->body.motion.action = body.motion.action;
235             // int32_t actionButton
236             msg->body.motion.actionButton = body.motion.actionButton;
237             // int32_t flags
238             msg->body.motion.flags = body.motion.flags;
239             // int32_t metaState
240             msg->body.motion.metaState = body.motion.metaState;
241             // int32_t buttonState
242             msg->body.motion.buttonState = body.motion.buttonState;
243             // MotionClassification classification
244             msg->body.motion.classification = body.motion.classification;
245             // int32_t edgeFlags
246             msg->body.motion.edgeFlags = body.motion.edgeFlags;
247             // nsecs_t downTime
248             msg->body.motion.downTime = body.motion.downTime;
249 
250             msg->body.motion.dsdx = body.motion.dsdx;
251             msg->body.motion.dtdx = body.motion.dtdx;
252             msg->body.motion.dtdy = body.motion.dtdy;
253             msg->body.motion.dsdy = body.motion.dsdy;
254             msg->body.motion.tx = body.motion.tx;
255             msg->body.motion.ty = body.motion.ty;
256 
257             // float xPrecision
258             msg->body.motion.xPrecision = body.motion.xPrecision;
259             // float yPrecision
260             msg->body.motion.yPrecision = body.motion.yPrecision;
261             // float xCursorPosition
262             msg->body.motion.xCursorPosition = body.motion.xCursorPosition;
263             // float yCursorPosition
264             msg->body.motion.yCursorPosition = body.motion.yCursorPosition;
265 
266             msg->body.motion.dsdxRaw = body.motion.dsdxRaw;
267             msg->body.motion.dtdxRaw = body.motion.dtdxRaw;
268             msg->body.motion.dtdyRaw = body.motion.dtdyRaw;
269             msg->body.motion.dsdyRaw = body.motion.dsdyRaw;
270             msg->body.motion.txRaw = body.motion.txRaw;
271             msg->body.motion.tyRaw = body.motion.tyRaw;
272 
273             //struct Pointer pointers[MAX_POINTERS]
274             for (size_t i = 0; i < body.motion.pointerCount; i++) {
275                 // PointerProperties properties
276                 msg->body.motion.pointers[i].properties.id = body.motion.pointers[i].properties.id;
277                 msg->body.motion.pointers[i].properties.toolType =
278                         body.motion.pointers[i].properties.toolType,
279                 // PointerCoords coords
280                 msg->body.motion.pointers[i].coords.bits = body.motion.pointers[i].coords.bits;
281                 const uint32_t count = BitSet64::count(body.motion.pointers[i].coords.bits);
282                 memcpy(&msg->body.motion.pointers[i].coords.values[0],
283                         &body.motion.pointers[i].coords.values[0],
284                         count * (sizeof(body.motion.pointers[i].coords.values[0])));
285                 msg->body.motion.pointers[i].coords.isResampled =
286                         body.motion.pointers[i].coords.isResampled;
287             }
288             break;
289         }
290         case InputMessage::Type::FINISHED: {
291             msg->body.finished.handled = body.finished.handled;
292             msg->body.finished.consumeTime = body.finished.consumeTime;
293             break;
294         }
295         case InputMessage::Type::FOCUS: {
296             msg->body.focus.eventId = body.focus.eventId;
297             msg->body.focus.hasFocus = body.focus.hasFocus;
298             break;
299         }
300         case InputMessage::Type::CAPTURE: {
301             msg->body.capture.eventId = body.capture.eventId;
302             msg->body.capture.pointerCaptureEnabled = body.capture.pointerCaptureEnabled;
303             break;
304         }
305         case InputMessage::Type::DRAG: {
306             msg->body.drag.eventId = body.drag.eventId;
307             msg->body.drag.x = body.drag.x;
308             msg->body.drag.y = body.drag.y;
309             msg->body.drag.isExiting = body.drag.isExiting;
310             break;
311         }
312         case InputMessage::Type::TIMELINE: {
313             msg->body.timeline.eventId = body.timeline.eventId;
314             msg->body.timeline.graphicsTimeline = body.timeline.graphicsTimeline;
315             break;
316         }
317         case InputMessage::Type::TOUCH_MODE: {
318             msg->body.touchMode.eventId = body.touchMode.eventId;
319             msg->body.touchMode.isInTouchMode = body.touchMode.isInTouchMode;
320         }
321     }
322 }
323 
324 // --- InputChannel ---
325 
create(const std::string & name,android::base::unique_fd fd,sp<IBinder> token)326 std::unique_ptr<InputChannel> InputChannel::create(const std::string& name,
327                                                    android::base::unique_fd fd, sp<IBinder> token) {
328     const int result = fcntl(fd, F_SETFL, O_NONBLOCK);
329     if (result != 0) {
330         LOG_ALWAYS_FATAL("channel '%s' ~ Could not make socket non-blocking: %s", name.c_str(),
331                          strerror(errno));
332         return nullptr;
333     }
334     // using 'new' to access a non-public constructor
335     return std::unique_ptr<InputChannel>(new InputChannel(name, std::move(fd), token));
336 }
337 
create(android::os::InputChannelCore && parceledChannel)338 std::unique_ptr<InputChannel> InputChannel::create(
339         android::os::InputChannelCore&& parceledChannel) {
340     return InputChannel::create(parceledChannel.name, parceledChannel.fd.release(),
341                                 parceledChannel.token);
342 }
343 
InputChannel(const std::string name,android::base::unique_fd fd,sp<IBinder> token)344 InputChannel::InputChannel(const std::string name, android::base::unique_fd fd, sp<IBinder> token) {
345     this->name = std::move(name);
346     this->fd.reset(std::move(fd));
347     this->token = std::move(token);
348     ALOGD_IF(DEBUG_CHANNEL_LIFECYCLE, "Input channel constructed: name='%s', fd=%d",
349              getName().c_str(), getFd());
350 }
351 
~InputChannel()352 InputChannel::~InputChannel() {
353     ALOGD_IF(DEBUG_CHANNEL_LIFECYCLE, "Input channel destroyed: name='%s', fd=%d",
354              getName().c_str(), getFd());
355 }
356 
openInputChannelPair(const std::string & name,std::unique_ptr<InputChannel> & outServerChannel,std::unique_ptr<InputChannel> & outClientChannel)357 status_t InputChannel::openInputChannelPair(const std::string& name,
358                                             std::unique_ptr<InputChannel>& outServerChannel,
359                                             std::unique_ptr<InputChannel>& outClientChannel) {
360     int sockets[2];
361     if (socketpair(AF_UNIX, SOCK_SEQPACKET, 0, sockets)) {
362         status_t result = -errno;
363         ALOGE("channel '%s' ~ Could not create socket pair.  errno=%s(%d)", name.c_str(),
364               strerror(errno), errno);
365         outServerChannel.reset();
366         outClientChannel.reset();
367         return result;
368     }
369 
370     int bufferSize = SOCKET_BUFFER_SIZE;
371     setsockopt(sockets[0], SOL_SOCKET, SO_SNDBUF, &bufferSize, sizeof(bufferSize));
372     setsockopt(sockets[0], SOL_SOCKET, SO_RCVBUF, &bufferSize, sizeof(bufferSize));
373     setsockopt(sockets[1], SOL_SOCKET, SO_SNDBUF, &bufferSize, sizeof(bufferSize));
374     setsockopt(sockets[1], SOL_SOCKET, SO_RCVBUF, &bufferSize, sizeof(bufferSize));
375 
376     sp<IBinder> token = sp<BBinder>::make();
377 
378     std::string serverChannelName = name + " (server)";
379     android::base::unique_fd serverFd(sockets[0]);
380     outServerChannel = InputChannel::create(serverChannelName, std::move(serverFd), token);
381 
382     std::string clientChannelName = name + " (client)";
383     android::base::unique_fd clientFd(sockets[1]);
384     outClientChannel = InputChannel::create(clientChannelName, std::move(clientFd), token);
385     return OK;
386 }
387 
sendMessage(const InputMessage * msg)388 status_t InputChannel::sendMessage(const InputMessage* msg) {
389     ATRACE_NAME_IF(ATRACE_ENABLED(),
390                    StringPrintf("sendMessage(inputChannel=%s, seq=0x%" PRIx32 ", type=%s)",
391                                 name.c_str(), msg->header.seq,
392                                 ftl::enum_string(msg->header.type).c_str()));
393     const size_t msgLength = msg->size();
394     InputMessage cleanMsg;
395     msg->getSanitizedCopy(&cleanMsg);
396     ssize_t nWrite;
397     do {
398         nWrite = ::send(getFd(), &cleanMsg, msgLength, MSG_DONTWAIT | MSG_NOSIGNAL);
399     } while (nWrite == -1 && errno == EINTR);
400 
401     if (nWrite < 0) {
402         int error = errno;
403         ALOGD_IF(DEBUG_CHANNEL_MESSAGES, "channel '%s' ~ error sending message of type %s, %s",
404                  name.c_str(), ftl::enum_string(msg->header.type).c_str(), strerror(error));
405         if (error == EAGAIN || error == EWOULDBLOCK) {
406             return WOULD_BLOCK;
407         }
408         if (error == EPIPE || error == ENOTCONN || error == ECONNREFUSED || error == ECONNRESET) {
409             return DEAD_OBJECT;
410         }
411         return -error;
412     }
413 
414     if (size_t(nWrite) != msgLength) {
415         ALOGD_IF(DEBUG_CHANNEL_MESSAGES,
416                  "channel '%s' ~ error sending message type %s, send was incomplete", name.c_str(),
417                  ftl::enum_string(msg->header.type).c_str());
418         return DEAD_OBJECT;
419     }
420 
421     ALOGD_IF(DEBUG_CHANNEL_MESSAGES, "channel '%s' ~ sent message of type %s", name.c_str(),
422              ftl::enum_string(msg->header.type).c_str());
423 
424     return OK;
425 }
426 
receiveMessage(InputMessage * msg)427 status_t InputChannel::receiveMessage(InputMessage* msg) {
428     ssize_t nRead;
429     do {
430         nRead = ::recv(getFd(), msg, sizeof(InputMessage), MSG_DONTWAIT);
431     } while (nRead == -1 && errno == EINTR);
432 
433     if (nRead < 0) {
434         int error = errno;
435         ALOGD_IF(DEBUG_CHANNEL_MESSAGES, "channel '%s' ~ receive message failed, errno=%d",
436                  name.c_str(), errno);
437         if (error == EAGAIN || error == EWOULDBLOCK) {
438             return WOULD_BLOCK;
439         }
440         if (error == EPIPE || error == ENOTCONN || error == ECONNREFUSED) {
441             return DEAD_OBJECT;
442         }
443         return -error;
444     }
445 
446     if (nRead == 0) { // check for EOF
447         ALOGD_IF(DEBUG_CHANNEL_MESSAGES,
448                  "channel '%s' ~ receive message failed because peer was closed", name.c_str());
449         return DEAD_OBJECT;
450     }
451 
452     if (!msg->isValid(nRead)) {
453         ALOGE("channel '%s' ~ received invalid message of size %zd", name.c_str(), nRead);
454         return BAD_VALUE;
455     }
456 
457     ALOGD_IF(DEBUG_CHANNEL_MESSAGES, "channel '%s' ~ received message of type %s", name.c_str(),
458              ftl::enum_string(msg->header.type).c_str());
459     if (ATRACE_ENABLED()) {
460         // Add an additional trace point to include data about the received message.
461         std::string message =
462                 StringPrintf("receiveMessage(inputChannel=%s, seq=0x%" PRIx32 ", type=%s)",
463                              name.c_str(), msg->header.seq,
464                              ftl::enum_string(msg->header.type).c_str());
465         ATRACE_NAME(message.c_str());
466     }
467     return OK;
468 }
469 
probablyHasInput() const470 bool InputChannel::probablyHasInput() const {
471     struct pollfd pfds = {.fd = fd.get(), .events = POLLIN};
472     if (::poll(&pfds, /*nfds=*/1, /*timeout=*/0) <= 0) {
473         // This can be a false negative because EINTR and ENOMEM are not handled. The latter should
474         // be extremely rare. The EINTR is also unlikely because it happens only when the signal
475         // arrives while the syscall is executed, and the syscall is quick. Hitting EINTR too often
476         // would be a sign of having too many signals, which is a bigger performance problem. A
477         // common tradition is to repeat the syscall on each EINTR, but it is not necessary here.
478         // In other words, the missing one liner is replaced by a multiline explanation.
479         return false;
480     }
481     // From poll(2): The bits returned in |revents| can include any of those specified in |events|,
482     // or one of the values POLLERR, POLLHUP, or POLLNVAL.
483     return (pfds.revents & POLLIN) != 0;
484 }
485 
waitForMessage(std::chrono::milliseconds timeout) const486 void InputChannel::waitForMessage(std::chrono::milliseconds timeout) const {
487     if (timeout < 0ms) {
488         LOG(FATAL) << "Timeout cannot be negative, received " << timeout.count();
489     }
490     struct pollfd pfds = {.fd = fd.get(), .events = POLLIN};
491     int ret;
492     std::chrono::time_point<std::chrono::steady_clock> stopTime =
493             std::chrono::steady_clock::now() + timeout;
494     std::chrono::milliseconds remaining = timeout;
495     do {
496         ret = ::poll(&pfds, /*nfds=*/1, /*timeout=*/remaining.count());
497         remaining = std::chrono::duration_cast<std::chrono::milliseconds>(
498                 stopTime - std::chrono::steady_clock::now());
499     } while (ret == -1 && errno == EINTR && remaining > 0ms);
500 }
501 
dup() const502 std::unique_ptr<InputChannel> InputChannel::dup() const {
503     base::unique_fd newFd(dupChannelFd(fd.get()));
504     return InputChannel::create(getName(), std::move(newFd), getConnectionToken());
505 }
506 
copyTo(android::os::InputChannelCore & outChannel) const507 void InputChannel::copyTo(android::os::InputChannelCore& outChannel) const {
508     outChannel.name = getName();
509     outChannel.fd.reset(dupChannelFd(fd.get()));
510     outChannel.token = getConnectionToken();
511 }
512 
moveChannel(std::unique_ptr<InputChannel> from,android::os::InputChannelCore & outChannel)513 void InputChannel::moveChannel(std::unique_ptr<InputChannel> from,
514                                android::os::InputChannelCore& outChannel) {
515     outChannel.name = from->getName();
516     outChannel.fd = android::os::ParcelFileDescriptor(std::move(from->fd));
517     outChannel.token = from->getConnectionToken();
518 }
519 
getConnectionToken() const520 sp<IBinder> InputChannel::getConnectionToken() const {
521     return token;
522 }
523 
524 // --- InputPublisher ---
525 
InputPublisher(const std::shared_ptr<InputChannel> & channel)526 InputPublisher::InputPublisher(const std::shared_ptr<InputChannel>& channel)
527       : mChannel(channel), mInputVerifier(mChannel->getName()) {}
528 
~InputPublisher()529 InputPublisher::~InputPublisher() {
530 }
531 
publishKeyEvent(uint32_t seq,int32_t eventId,int32_t deviceId,int32_t source,ui::LogicalDisplayId 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)532 status_t InputPublisher::publishKeyEvent(uint32_t seq, int32_t eventId, int32_t deviceId,
533                                          int32_t source, ui::LogicalDisplayId displayId,
534                                          std::array<uint8_t, 32> hmac, int32_t action,
535                                          int32_t flags, int32_t keyCode, int32_t scanCode,
536                                          int32_t metaState, int32_t repeatCount, nsecs_t downTime,
537                                          nsecs_t eventTime) {
538     ATRACE_NAME_IF(ATRACE_ENABLED(),
539                    StringPrintf("publishKeyEvent(inputChannel=%s, action=%s, keyCode=%s)",
540                                 mChannel->getName().c_str(), KeyEvent::actionToString(action),
541                                 KeyEvent::getLabel(keyCode)));
542     ALOGD_IF(debugTransportPublisher(),
543              "channel '%s' publisher ~ %s: seq=%u, id=%d, deviceId=%d, source=%s, "
544              "action=%s, flags=0x%x, keyCode=%s, scanCode=%d, metaState=0x%x, repeatCount=%d,"
545              "downTime=%" PRId64 ", eventTime=%" PRId64,
546              mChannel->getName().c_str(), __func__, seq, eventId, deviceId,
547              inputEventSourceToString(source).c_str(), KeyEvent::actionToString(action), flags,
548              KeyEvent::getLabel(keyCode), scanCode, metaState, repeatCount, downTime, eventTime);
549 
550     if (!seq) {
551         ALOGE("Attempted to publish a key event with sequence number 0.");
552         return BAD_VALUE;
553     }
554 
555     InputMessage msg;
556     msg.header.type = InputMessage::Type::KEY;
557     msg.header.seq = seq;
558     msg.body.key.eventId = eventId;
559     msg.body.key.deviceId = deviceId;
560     msg.body.key.source = source;
561     msg.body.key.displayId = displayId.val();
562     msg.body.key.hmac = std::move(hmac);
563     msg.body.key.action = action;
564     msg.body.key.flags = flags;
565     msg.body.key.keyCode = keyCode;
566     msg.body.key.scanCode = scanCode;
567     msg.body.key.metaState = metaState;
568     msg.body.key.repeatCount = repeatCount;
569     msg.body.key.downTime = downTime;
570     msg.body.key.eventTime = eventTime;
571     return mChannel->sendMessage(&msg);
572 }
573 
publishMotionEvent(uint32_t seq,int32_t eventId,int32_t deviceId,int32_t source,ui::LogicalDisplayId 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)574 status_t InputPublisher::publishMotionEvent(
575         uint32_t seq, int32_t eventId, int32_t deviceId, int32_t source,
576         ui::LogicalDisplayId displayId, std::array<uint8_t, 32> hmac, int32_t action,
577         int32_t actionButton, int32_t flags, int32_t edgeFlags, int32_t metaState,
578         int32_t buttonState, MotionClassification classification, const ui::Transform& transform,
579         float xPrecision, float yPrecision, float xCursorPosition, float yCursorPosition,
580         const ui::Transform& rawTransform, nsecs_t downTime, nsecs_t eventTime,
581         uint32_t pointerCount, const PointerProperties* pointerProperties,
582         const PointerCoords* pointerCoords) {
583     ATRACE_NAME_IF(ATRACE_ENABLED(),
584                    StringPrintf("publishMotionEvent(inputChannel=%s, action=%s)",
585                                 mChannel->getName().c_str(),
586                                 MotionEvent::actionToString(action).c_str()));
587     if (verifyEvents()) {
588         Result<void> result =
589                 mInputVerifier.processMovement(deviceId, source, action, pointerCount,
590                                                pointerProperties, pointerCoords, flags);
591         if (!result.ok()) {
592             LOG(FATAL) << "Bad stream: " << result.error();
593         }
594     }
595     if (debugTransportPublisher()) {
596         std::string transformString;
597         transform.dump(transformString, "transform", "        ");
598         ALOGD("channel '%s' publisher ~ %s: seq=%u, id=%d, deviceId=%d, source=%s, "
599               "displayId=%s, "
600               "action=%s, actionButton=0x%08x, flags=0x%x, edgeFlags=0x%x, "
601               "metaState=0x%x, buttonState=0x%x, classification=%s,"
602               "xPrecision=%f, yPrecision=%f, downTime=%" PRId64 ", eventTime=%" PRId64 ", "
603               "pointerCount=%" PRIu32 "\n%s",
604               mChannel->getName().c_str(), __func__, seq, eventId, deviceId,
605               inputEventSourceToString(source).c_str(), displayId.toString().c_str(),
606               MotionEvent::actionToString(action).c_str(), actionButton, flags, edgeFlags,
607               metaState, buttonState, motionClassificationToString(classification), xPrecision,
608               yPrecision, downTime, eventTime, pointerCount, transformString.c_str());
609     }
610 
611     if (!seq) {
612         ALOGE("Attempted to publish a motion event with sequence number 0.");
613         return BAD_VALUE;
614     }
615 
616     if (pointerCount > MAX_POINTERS || pointerCount < 1) {
617         ALOGE("channel '%s' publisher ~ Invalid number of pointers provided: %" PRIu32 ".",
618                 mChannel->getName().c_str(), pointerCount);
619         return BAD_VALUE;
620     }
621 
622     InputMessage msg;
623     msg.header.type = InputMessage::Type::MOTION;
624     msg.header.seq = seq;
625     msg.body.motion.eventId = eventId;
626     msg.body.motion.deviceId = deviceId;
627     msg.body.motion.source = source;
628     msg.body.motion.displayId = displayId.val();
629     msg.body.motion.hmac = std::move(hmac);
630     msg.body.motion.action = action;
631     msg.body.motion.actionButton = actionButton;
632     msg.body.motion.flags = flags;
633     msg.body.motion.edgeFlags = edgeFlags;
634     msg.body.motion.metaState = metaState;
635     msg.body.motion.buttonState = buttonState;
636     msg.body.motion.classification = classification;
637     msg.body.motion.dsdx = transform.dsdx();
638     msg.body.motion.dtdx = transform.dtdx();
639     msg.body.motion.dtdy = transform.dtdy();
640     msg.body.motion.dsdy = transform.dsdy();
641     msg.body.motion.tx = transform.tx();
642     msg.body.motion.ty = transform.ty();
643     msg.body.motion.xPrecision = xPrecision;
644     msg.body.motion.yPrecision = yPrecision;
645     msg.body.motion.xCursorPosition = xCursorPosition;
646     msg.body.motion.yCursorPosition = yCursorPosition;
647     msg.body.motion.dsdxRaw = rawTransform.dsdx();
648     msg.body.motion.dtdxRaw = rawTransform.dtdx();
649     msg.body.motion.dtdyRaw = rawTransform.dtdy();
650     msg.body.motion.dsdyRaw = rawTransform.dsdy();
651     msg.body.motion.txRaw = rawTransform.tx();
652     msg.body.motion.tyRaw = rawTransform.ty();
653     msg.body.motion.downTime = downTime;
654     msg.body.motion.eventTime = eventTime;
655     msg.body.motion.pointerCount = pointerCount;
656     for (uint32_t i = 0; i < pointerCount; i++) {
657         msg.body.motion.pointers[i].properties = pointerProperties[i];
658         msg.body.motion.pointers[i].coords = pointerCoords[i];
659     }
660 
661     return mChannel->sendMessage(&msg);
662 }
663 
publishFocusEvent(uint32_t seq,int32_t eventId,bool hasFocus)664 status_t InputPublisher::publishFocusEvent(uint32_t seq, int32_t eventId, bool hasFocus) {
665     ATRACE_NAME_IF(ATRACE_ENABLED(),
666                    StringPrintf("publishFocusEvent(inputChannel=%s, hasFocus=%s)",
667                                 mChannel->getName().c_str(), toString(hasFocus)));
668     ALOGD_IF(debugTransportPublisher(), "channel '%s' publisher ~ %s: seq=%u, id=%d, hasFocus=%s",
669              mChannel->getName().c_str(), __func__, seq, eventId, toString(hasFocus));
670 
671     InputMessage msg;
672     msg.header.type = InputMessage::Type::FOCUS;
673     msg.header.seq = seq;
674     msg.body.focus.eventId = eventId;
675     msg.body.focus.hasFocus = hasFocus;
676     return mChannel->sendMessage(&msg);
677 }
678 
publishCaptureEvent(uint32_t seq,int32_t eventId,bool pointerCaptureEnabled)679 status_t InputPublisher::publishCaptureEvent(uint32_t seq, int32_t eventId,
680                                              bool pointerCaptureEnabled) {
681     ATRACE_NAME_IF(ATRACE_ENABLED(),
682                    StringPrintf("publishCaptureEvent(inputChannel=%s, pointerCaptureEnabled=%s)",
683                                 mChannel->getName().c_str(), toString(pointerCaptureEnabled)));
684     ALOGD_IF(debugTransportPublisher(),
685              "channel '%s' publisher ~ %s: seq=%u, id=%d, pointerCaptureEnabled=%s",
686              mChannel->getName().c_str(), __func__, seq, eventId, toString(pointerCaptureEnabled));
687 
688     InputMessage msg;
689     msg.header.type = InputMessage::Type::CAPTURE;
690     msg.header.seq = seq;
691     msg.body.capture.eventId = eventId;
692     msg.body.capture.pointerCaptureEnabled = pointerCaptureEnabled;
693     return mChannel->sendMessage(&msg);
694 }
695 
publishDragEvent(uint32_t seq,int32_t eventId,float x,float y,bool isExiting)696 status_t InputPublisher::publishDragEvent(uint32_t seq, int32_t eventId, float x, float y,
697                                           bool isExiting) {
698     ATRACE_NAME_IF(ATRACE_ENABLED(),
699                    StringPrintf("publishDragEvent(inputChannel=%s, x=%f, y=%f, isExiting=%s)",
700                                 mChannel->getName().c_str(), x, y, toString(isExiting)));
701     ALOGD_IF(debugTransportPublisher(),
702              "channel '%s' publisher ~ %s: seq=%u, id=%d, x=%f, y=%f, isExiting=%s",
703              mChannel->getName().c_str(), __func__, seq, eventId, x, y, toString(isExiting));
704 
705     InputMessage msg;
706     msg.header.type = InputMessage::Type::DRAG;
707     msg.header.seq = seq;
708     msg.body.drag.eventId = eventId;
709     msg.body.drag.isExiting = isExiting;
710     msg.body.drag.x = x;
711     msg.body.drag.y = y;
712     return mChannel->sendMessage(&msg);
713 }
714 
publishTouchModeEvent(uint32_t seq,int32_t eventId,bool isInTouchMode)715 status_t InputPublisher::publishTouchModeEvent(uint32_t seq, int32_t eventId, bool isInTouchMode) {
716     ATRACE_NAME_IF(ATRACE_ENABLED(),
717                    StringPrintf("publishTouchModeEvent(inputChannel=%s, isInTouchMode=%s)",
718                                 mChannel->getName().c_str(), toString(isInTouchMode)));
719     ALOGD_IF(debugTransportPublisher(),
720              "channel '%s' publisher ~ %s: seq=%u, id=%d, isInTouchMode=%s",
721              mChannel->getName().c_str(), __func__, seq, eventId, toString(isInTouchMode));
722 
723     InputMessage msg;
724     msg.header.type = InputMessage::Type::TOUCH_MODE;
725     msg.header.seq = seq;
726     msg.body.touchMode.eventId = eventId;
727     msg.body.touchMode.isInTouchMode = isInTouchMode;
728     return mChannel->sendMessage(&msg);
729 }
730 
receiveConsumerResponse()731 android::base::Result<InputPublisher::ConsumerResponse> InputPublisher::receiveConsumerResponse() {
732     InputMessage msg;
733     status_t result = mChannel->receiveMessage(&msg);
734     if (result) {
735         if (debugTransportPublisher() && result != WOULD_BLOCK) {
736             LOG(INFO) << "channel '" << mChannel->getName() << "' publisher ~ " << __func__ << ": "
737                       << strerror(result);
738         }
739         return android::base::Error(result);
740     }
741     if (msg.header.type == InputMessage::Type::FINISHED) {
742         ALOGD_IF(debugTransportPublisher(),
743                  "channel '%s' publisher ~ %s: finished: seq=%u, handled=%s",
744                  mChannel->getName().c_str(), __func__, msg.header.seq,
745                  toString(msg.body.finished.handled));
746         return Finished{
747                 .seq = msg.header.seq,
748                 .handled = msg.body.finished.handled,
749                 .consumeTime = msg.body.finished.consumeTime,
750         };
751     }
752 
753     if (msg.header.type == InputMessage::Type::TIMELINE) {
754         ALOGD_IF(debugTransportPublisher(), "channel '%s' publisher ~ %s: timeline: id=%d",
755                  mChannel->getName().c_str(), __func__, msg.body.timeline.eventId);
756         return Timeline{
757                 .inputEventId = msg.body.timeline.eventId,
758                 .graphicsTimeline = msg.body.timeline.graphicsTimeline,
759         };
760     }
761 
762     ALOGE("channel '%s' publisher ~ Received unexpected %s message from consumer",
763           mChannel->getName().c_str(), ftl::enum_string(msg.header.type).c_str());
764     return android::base::Error(UNKNOWN_ERROR);
765 }
766 
767 } // namespace android
768