InputTransport.h revision 771526c88f5cc4b56a41cb12aa06a28d377a07d5
1/* 2 * Copyright (C) 2010 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#ifndef _ANDROIDFW_INPUT_TRANSPORT_H 18#define _ANDROIDFW_INPUT_TRANSPORT_H 19 20/** 21 * Native input transport. 22 * 23 * The InputChannel provides a mechanism for exchanging InputMessage structures across processes. 24 * 25 * The InputPublisher and InputConsumer each handle one end-point of an input channel. 26 * The InputPublisher is used by the input dispatcher to send events to the application. 27 * The InputConsumer is used by the application to receive events from the input dispatcher. 28 */ 29 30#include <androidfw/Input.h> 31#include <utils/Errors.h> 32#include <utils/Timers.h> 33#include <utils/RefBase.h> 34#include <utils/String8.h> 35#include <utils/Vector.h> 36#include <utils/BitSet.h> 37 38namespace android { 39 40/* 41 * Intermediate representation used to send input events and related signals. 42 */ 43struct InputMessage { 44 enum { 45 TYPE_KEY = 1, 46 TYPE_MOTION = 2, 47 TYPE_FINISHED = 3, 48 }; 49 50 struct Header { 51 uint32_t type; 52 uint32_t padding; // 8 byte alignment for the body that follows 53 } header; 54 55 union Body { 56 struct Key { 57 uint32_t seq; 58 nsecs_t eventTime; 59 int32_t deviceId; 60 int32_t source; 61 int32_t action; 62 int32_t flags; 63 int32_t keyCode; 64 int32_t scanCode; 65 int32_t metaState; 66 int32_t repeatCount; 67 nsecs_t downTime; 68 69 inline size_t size() const { 70 return sizeof(Key); 71 } 72 } key; 73 74 struct Motion { 75 uint32_t seq; 76 nsecs_t eventTime; 77 int32_t deviceId; 78 int32_t source; 79 int32_t action; 80 int32_t flags; 81 int32_t metaState; 82 int32_t buttonState; 83 int32_t edgeFlags; 84 nsecs_t downTime; 85 float xOffset; 86 float yOffset; 87 float xPrecision; 88 float yPrecision; 89 size_t pointerCount; 90 struct Pointer { 91 PointerProperties properties; 92 PointerCoords coords; 93 } pointers[MAX_POINTERS]; 94 95 inline size_t size() const { 96 return sizeof(Motion) - sizeof(Pointer) * MAX_POINTERS 97 + sizeof(Pointer) * pointerCount; 98 } 99 } motion; 100 101 struct Finished { 102 uint32_t seq; 103 bool handled; 104 105 inline size_t size() const { 106 return sizeof(Finished); 107 } 108 } finished; 109 } body; 110 111 bool isValid(size_t actualSize) const; 112 size_t size() const; 113}; 114 115/* 116 * An input channel consists of a local unix domain socket used to send and receive 117 * input messages across processes. Each channel has a descriptive name for debugging purposes. 118 * 119 * Each endpoint has its own InputChannel object that specifies its file descriptor. 120 * 121 * The input channel is closed when all references to it are released. 122 */ 123class InputChannel : public RefBase { 124protected: 125 virtual ~InputChannel(); 126 127public: 128 InputChannel(const String8& name, int fd); 129 130 /* Creates a pair of input channels. 131 * 132 * Returns OK on success. 133 */ 134 static status_t openInputChannelPair(const String8& name, 135 sp<InputChannel>& outServerChannel, sp<InputChannel>& outClientChannel); 136 137 inline String8 getName() const { return mName; } 138 inline int getFd() const { return mFd; } 139 140 /* Sends a message to the other endpoint. 141 * 142 * If the channel is full then the message is guaranteed not to have been sent at all. 143 * Try again after the consumer has sent a finished signal indicating that it has 144 * consumed some of the pending messages from the channel. 145 * 146 * Returns OK on success. 147 * Returns WOULD_BLOCK if the channel is full. 148 * Returns DEAD_OBJECT if the channel's peer has been closed. 149 * Other errors probably indicate that the channel is broken. 150 */ 151 status_t sendMessage(const InputMessage* msg); 152 153 /* Receives a message sent by the other endpoint. 154 * 155 * If there is no message present, try again after poll() indicates that the fd 156 * is readable. 157 * 158 * Returns OK on success. 159 * Returns WOULD_BLOCK if there is no message present. 160 * Returns DEAD_OBJECT if the channel's peer has been closed. 161 * Other errors probably indicate that the channel is broken. 162 */ 163 status_t receiveMessage(InputMessage* msg); 164 165private: 166 String8 mName; 167 int mFd; 168}; 169 170/* 171 * Publishes input events to an input channel. 172 */ 173class InputPublisher { 174public: 175 /* Creates a publisher associated with an input channel. */ 176 explicit InputPublisher(const sp<InputChannel>& channel); 177 178 /* Destroys the publisher and releases its input channel. */ 179 ~InputPublisher(); 180 181 /* Gets the underlying input channel. */ 182 inline sp<InputChannel> getChannel() { return mChannel; } 183 184 /* Publishes a key event to the input channel. 185 * 186 * Returns OK on success. 187 * Returns WOULD_BLOCK if the channel is full. 188 * Returns DEAD_OBJECT if the channel's peer has been closed. 189 * Returns BAD_VALUE if seq is 0. 190 * Other errors probably indicate that the channel is broken. 191 */ 192 status_t publishKeyEvent( 193 uint32_t seq, 194 int32_t deviceId, 195 int32_t source, 196 int32_t action, 197 int32_t flags, 198 int32_t keyCode, 199 int32_t scanCode, 200 int32_t metaState, 201 int32_t repeatCount, 202 nsecs_t downTime, 203 nsecs_t eventTime); 204 205 /* Publishes a motion event to the input channel. 206 * 207 * Returns OK on success. 208 * Returns WOULD_BLOCK if the channel is full. 209 * Returns DEAD_OBJECT if the channel's peer has been closed. 210 * Returns BAD_VALUE if seq is 0 or if pointerCount is less than 1 or greater than MAX_POINTERS. 211 * Other errors probably indicate that the channel is broken. 212 */ 213 status_t publishMotionEvent( 214 uint32_t seq, 215 int32_t deviceId, 216 int32_t source, 217 int32_t action, 218 int32_t flags, 219 int32_t edgeFlags, 220 int32_t metaState, 221 int32_t buttonState, 222 float xOffset, 223 float yOffset, 224 float xPrecision, 225 float yPrecision, 226 nsecs_t downTime, 227 nsecs_t eventTime, 228 size_t pointerCount, 229 const PointerProperties* pointerProperties, 230 const PointerCoords* pointerCoords); 231 232 /* Receives the finished signal from the consumer in reply to the original dispatch signal. 233 * If a signal was received, returns the message sequence number, 234 * and whether the consumer handled the message. 235 * 236 * The returned sequence number is never 0 unless the operation failed. 237 * 238 * Returns OK on success. 239 * Returns WOULD_BLOCK if there is no signal present. 240 * Returns DEAD_OBJECT if the channel's peer has been closed. 241 * Other errors probably indicate that the channel is broken. 242 */ 243 status_t receiveFinishedSignal(uint32_t* outSeq, bool* outHandled); 244 245private: 246 sp<InputChannel> mChannel; 247}; 248 249/* 250 * Consumes input events from an input channel. 251 */ 252class InputConsumer { 253public: 254 /* Creates a consumer associated with an input channel. */ 255 explicit InputConsumer(const sp<InputChannel>& channel); 256 257 /* Destroys the consumer and releases its input channel. */ 258 ~InputConsumer(); 259 260 /* Gets the underlying input channel. */ 261 inline sp<InputChannel> getChannel() { return mChannel; } 262 263 /* Consumes an input event from the input channel and copies its contents into 264 * an InputEvent object created using the specified factory. 265 * 266 * Tries to combine a series of move events into larger batches whenever possible. 267 * 268 * If consumeBatches is false, then defers consuming pending batched events if it 269 * is possible for additional samples to be added to them later. Call hasPendingBatch() 270 * to determine whether a pending batch is available to be consumed. 271 * 272 * If consumeBatches is true, then events are still batched but they are consumed 273 * immediately as soon as the input channel is exhausted. 274 * 275 * The frameTime parameter specifies the time when the current display frame started 276 * rendering in the CLOCK_MONOTONIC time base, or -1 if unknown. 277 * 278 * The returned sequence number is never 0 unless the operation failed. 279 * 280 * Returns OK on success. 281 * Returns WOULD_BLOCK if there is no event present. 282 * Returns DEAD_OBJECT if the channel's peer has been closed. 283 * Returns NO_MEMORY if the event could not be created. 284 * Other errors probably indicate that the channel is broken. 285 */ 286 status_t consume(InputEventFactoryInterface* factory, bool consumeBatches, 287 nsecs_t frameTime, uint32_t* outSeq, InputEvent** outEvent); 288 289 /* Sends a finished signal to the publisher to inform it that the message 290 * with the specified sequence number has finished being process and whether 291 * the message was handled by the consumer. 292 * 293 * Returns OK on success. 294 * Returns BAD_VALUE if seq is 0. 295 * Other errors probably indicate that the channel is broken. 296 */ 297 status_t sendFinishedSignal(uint32_t seq, bool handled); 298 299 /* Returns true if there is a deferred event waiting. 300 * 301 * Should be called after calling consume() to determine whether the consumer 302 * has a deferred event to be processed. Deferred events are somewhat special in 303 * that they have already been removed from the input channel. If the input channel 304 * becomes empty, the client may need to do extra work to ensure that it processes 305 * the deferred event despite the fact that the input channel's file descriptor 306 * is not readable. 307 * 308 * One option is simply to call consume() in a loop until it returns WOULD_BLOCK. 309 * This guarantees that all deferred events will be processed. 310 * 311 * Alternately, the caller can call hasDeferredEvent() to determine whether there is 312 * a deferred event waiting and then ensure that its event loop wakes up at least 313 * one more time to consume the deferred event. 314 */ 315 bool hasDeferredEvent() const; 316 317 /* Returns true if there is a pending batch. 318 * 319 * Should be called after calling consume() with consumeBatches == false to determine 320 * whether consume() should be called again later on with consumeBatches == true. 321 */ 322 bool hasPendingBatch() const; 323 324private: 325 sp<InputChannel> mChannel; 326 327 // The current input message. 328 InputMessage mMsg; 329 330 // True if mMsg contains a valid input message that was deferred from the previous 331 // call to consume and that still needs to be handled. 332 bool mMsgDeferred; 333 334 // Batched motion events per device and source. 335 struct Batch { 336 Vector<InputMessage> samples; 337 }; 338 Vector<Batch> mBatches; 339 340 // Touch state per device and source, only for sources of class pointer. 341 struct History { 342 nsecs_t eventTime; 343 BitSet32 idBits; 344 PointerCoords pointers[MAX_POINTERS]; 345 346 void initializeFrom(const InputMessage* msg) { 347 eventTime = msg->body.motion.eventTime; 348 idBits.clear(); 349 for (size_t i = 0; i < msg->body.motion.pointerCount; i++) { 350 uint32_t id = msg->body.motion.pointers[i].properties.id; 351 idBits.markBit(id); 352 size_t index = idBits.getIndexOfBit(id); 353 pointers[index].copyFrom(msg->body.motion.pointers[i].coords); 354 } 355 } 356 }; 357 struct TouchState { 358 int32_t deviceId; 359 int32_t source; 360 size_t historyCurrent; 361 size_t historySize; 362 History history[2]; 363 364 void initialize(int32_t deviceId, int32_t source) { 365 this->deviceId = deviceId; 366 this->source = source; 367 historyCurrent = 0; 368 historySize = 0; 369 } 370 371 void addHistory(const InputMessage* msg) { 372 historyCurrent ^= 1; 373 if (historySize < 2) { 374 historySize += 1; 375 } 376 history[historyCurrent].initializeFrom(msg); 377 } 378 379 const History* getHistory(size_t index) const { 380 return &history[(historyCurrent + index) & 1]; 381 } 382 }; 383 Vector<TouchState> mTouchStates; 384 385 // Chain of batched sequence numbers. When multiple input messages are combined into 386 // a batch, we append a record here that associates the last sequence number in the 387 // batch with the previous one. When the finished signal is sent, we traverse the 388 // chain to individually finish all input messages that were part of the batch. 389 struct SeqChain { 390 uint32_t seq; // sequence number of batched input message 391 uint32_t chain; // sequence number of previous batched input message 392 }; 393 Vector<SeqChain> mSeqChains; 394 395 status_t consumeBatch(InputEventFactoryInterface* factory, 396 nsecs_t frameTime, uint32_t* outSeq, InputEvent** outEvent); 397 status_t consumeSamples(InputEventFactoryInterface* factory, 398 Batch& batch, size_t count, uint32_t* outSeq, InputEvent** outEvent); 399 400 void updateTouchState(InputMessage* msg); 401 void resampleTouchState(nsecs_t frameTime, MotionEvent* event, 402 const InputMessage *next); 403 404 ssize_t findBatch(int32_t deviceId, int32_t source) const; 405 ssize_t findTouchState(int32_t deviceId, int32_t source) const; 406 407 status_t sendUnchainedFinishedSignal(uint32_t seq, bool handled); 408 409 static void initializeKeyEvent(KeyEvent* event, const InputMessage* msg); 410 static void initializeMotionEvent(MotionEvent* event, const InputMessage* msg); 411 static void addSample(MotionEvent* event, const InputMessage* msg); 412 static bool canAddSample(const Batch& batch, const InputMessage* msg); 413 static ssize_t findSampleNoLaterThan(const Batch& batch, nsecs_t time); 414 static bool shouldResampleTool(int32_t toolType); 415}; 416 417} // namespace android 418 419#endif // _ANDROIDFW_INPUT_TRANSPORT_H 420