ADHOC
/
replicant-frameworks_native
3
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Enable deferred input messages to be batched. 

This is part of a series of changes to improve input system pipelining.

Bug: 5963420
Change-Id: I6874d2128e880a35c6c33890c858cc6ee22af0fd
This commit is contained in:
Jeff Brown 2012-02-13 12:44:01 -08:00
parent f0490c94d0
commit 0a63adaff2
2 changed files with 45 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
include/ui/InputTransport.h
View File

@ -297,10 +297,12 @@ public:
private:
sp<InputChannel> mChannel;
// State about an event that consume would have returned except that it had to
// return a completed batch first. Sequence number is non-zero if an event was deferred.
uint32_t mDeferredEventSeq;
MotionEvent mDeferredEvent;
// The current input message.
InputMessage mMsg;
// True if mMsg contains a valid input message that was deferred from the previous
// call to consume and that still needs to be handled.
bool mMsgDeferred;
// Batched motion events per device and source.
struct Batch {

90
libs/ui/InputTransport.cpp
View File

@ -334,7 +334,7 @@ status_t InputPublisher::receiveFinishedSignal(uint32_t* outSeq, bool* outHandle
// --- InputConsumer ---
InputConsumer::InputConsumer(const sp<InputChannel>& channel) :
mChannel(channel), mDeferredEventSeq(0) {
mChannel(channel), mMsgDeferred(false) {
}
InputConsumer::~InputConsumer() {
@ -350,55 +350,44 @@ status_t InputConsumer::consume(InputEventFactoryInterface* factory,
*outSeq = 0;
*outEvent = NULL;
// Report deferred event first, if we had to end a batch earlier than we expected
// during the previous time consume was called.
if (mDeferredEventSeq) {
MotionEvent* motionEvent = factory->createMotionEvent();
if (! motionEvent) return NO_MEMORY;
motionEvent->copyFrom(&mDeferredEvent, true /*keepHistory*/);
*outSeq = mDeferredEventSeq;
*outEvent = motionEvent;
mDeferredEventSeq = 0;
#if DEBUG_TRANSPORT_ACTIONS
ALOGD("channel '%s' consumer ~ consumed deferred event, seq=%u",
mChannel->getName().string(), *outSeq);
#endif
return OK;
}
// Fetch the next input message.
// Loop until an event can be returned or no additional events are received.
while (!*outEvent) {
InputMessage msg;
status_t result = mChannel->receiveMessage(&msg);
if (result) {
// Consume the next batched event unless batches are being held for later.
if (!mBatches.isEmpty() && (consumeBatches || result != WOULD_BLOCK)) {
MotionEvent* motionEvent = factory->createMotionEvent();
if (! motionEvent) return NO_MEMORY;
if (mMsgDeferred) {
// mMsg contains a valid input message from the previous call to consume
// that has not yet been processed.
mMsgDeferred = false;
} else {
// Receive a fresh message.
status_t result = mChannel->receiveMessage(&mMsg);
if (result) {
// Consume the next batched event unless batches are being held for later.
if (!mBatches.isEmpty() && (consumeBatches || result != WOULD_BLOCK)) {
MotionEvent* motionEvent = factory->createMotionEvent();
if (! motionEvent) return NO_MEMORY;
const Batch& batch = mBatches.top();
motionEvent->copyFrom(&batch.event, true /*keepHistory*/);
*outSeq = batch.seq;
*outEvent = motionEvent;
mBatches.pop();
const Batch& batch = mBatches.top();
motionEvent->copyFrom(&batch.event, true /*keepHistory*/);
*outSeq = batch.seq;
*outEvent = motionEvent;
mBatches.pop();
#if DEBUG_TRANSPORT_ACTIONS
ALOGD("channel '%s' consumer ~ consumed batch event, seq=%u",
mChannel->getName().string(), *outSeq);
ALOGD("channel '%s' consumer ~ consumed batch event, seq=%u",
mChannel->getName().string(), *outSeq);
#endif
break;
break;
}
return result;
}
return result;
}
switch (msg.header.type) {
switch (mMsg.header.type) {
case InputMessage::TYPE_KEY: {
KeyEvent* keyEvent = factory->createKeyEvent();
if (!keyEvent) return NO_MEMORY;
initializeKeyEvent(keyEvent, &msg);
*outSeq = msg.body.key.seq;
initializeKeyEvent(keyEvent, &mMsg);
*outSeq = mMsg.body.key.seq;
*outEvent = keyEvent;
#if DEBUG_TRANSPORT_ACTIONS
ALOGD("channel '%s' consumer ~ consumed key event, seq=%u",
@ -408,10 +397,10 @@ status_t InputConsumer::consume(InputEventFactoryInterface* factory,
}
case AINPUT_EVENT_TYPE_MOTION: {
ssize_t batchIndex = findBatch(msg.body.motion.deviceId, msg.body.motion.source);
ssize_t batchIndex = findBatch(mMsg.body.motion.deviceId, mMsg.body.motion.source);
if (batchIndex >= 0) {
Batch& batch = mBatches.editItemAt(batchIndex);
if (canAppendSamples(&batch.event, &msg)) {
if (canAppendSamples(&batch.event, &mMsg)) {
// Send finished message for the earlier part of the batch.
// Claim that we handled the event. (The dispatcher doesn't care either
// way at the moment.)
@ -421,8 +410,8 @@ status_t InputConsumer::consume(InputEventFactoryInterface* factory,
}
// Append to the batch and save the new sequence number for the tail end.
appendSamples(&batch.event, &msg);
batch.seq = msg.body.motion.seq;
appendSamples(&batch.event, &mMsg);
batch.seq = mMsg.body.motion.seq;
#if DEBUG_TRANSPORT_ACTIONS
ALOGD("channel '%s' consumer ~ appended to batch event",
mChannel->getName().string());
@ -433,9 +422,8 @@ status_t InputConsumer::consume(InputEventFactoryInterface* factory,
if (! motionEvent) return NO_MEMORY;
// We cannot append to the batch in progress, so we need to consume
// the previous batch right now and defer the new event until later.
mDeferredEventSeq = msg.body.motion.seq;
initializeMotionEvent(&mDeferredEvent, &msg);
// the previous batch right now and defer the new message until later.
mMsgDeferred = true;
// Return the end of the previous batch.
motionEvent->copyFrom(&batch.event, true /*keepHistory*/);
@ -452,12 +440,12 @@ status_t InputConsumer::consume(InputEventFactoryInterface* factory,
}
// Start a new batch if needed.
if (msg.body.motion.action == AMOTION_EVENT_ACTION_MOVE
|| msg.body.motion.action == AMOTION_EVENT_ACTION_HOVER_MOVE) {
if (mMsg.body.motion.action == AMOTION_EVENT_ACTION_MOVE
|| mMsg.body.motion.action == AMOTION_EVENT_ACTION_HOVER_MOVE) {
mBatches.push();
Batch& batch = mBatches.editTop();
batch.seq = msg.body.motion.seq;
initializeMotionEvent(&batch.event, &msg);
batch.seq = mMsg.body.motion.seq;
initializeMotionEvent(&batch.event, &mMsg);
#if DEBUG_TRANSPORT_ACTIONS
ALOGD("channel '%s' consumer ~ started batch event",
mChannel->getName().string());
@ -468,8 +456,8 @@ status_t InputConsumer::consume(InputEventFactoryInterface* factory,
MotionEvent* motionEvent = factory->createMotionEvent();
if (! motionEvent) return NO_MEMORY;
initializeMotionEvent(motionEvent, &msg);
*outSeq = msg.body.motion.seq;
initializeMotionEvent(motionEvent, &mMsg);
*outSeq = mMsg.body.motion.seq;
*outEvent = motionEvent;
#if DEBUG_TRANSPORT_ACTIONS
ALOGD("channel '%s' consumer ~ consumed motion event, seq=%u",
@ -480,7 +468,7 @@ status_t InputConsumer::consume(InputEventFactoryInterface* factory,
default:
ALOGE("channel '%s' consumer ~ Received unexpected message of type %d",
mChannel->getName().string(), msg.header.type);
mChannel->getName().string(), mMsg.header.type);
return UNKNOWN_ERROR;
}
}