在上一篇文章的最后，我们发现InputDispatcher是调用了InputChannel->sendMessage把键值发送出去，那么相应的，也有接收键值的地方。接收函数是InputChannel->receiveMessage。
在InputConsumer::consume内找到了receiveMessage，从类名能看出来发送端与接收端相当于生产者与消费者的关系。
status_t InputConsumer::consume(InputEventFactoryInterface* factory,
bool consumeBatches, nsecs_t frameTime, uint32_t* outSeq, InputEvent** outEvent) {
// Receive a fresh message.
status_t result = mChannel->receiveMessage(&mMsg);
}
receiveMessage内调用的是socket的接收函数recv
status_t InputChannel::receiveMessage(InputMessage* msg) {
do {
nRead = ::recv(mFd, msg, sizeof(InputMessage), MSG_DONTWAIT);
} while (nRead == -1 && errno == EINTR);
}
事件接收端NativeInputEventReceiver
那么究竟是谁来消费这些事件呢，我们在NativeInputEventReceiver里面找到了答案。
在NativeInputEventReceiver内有个事件处理函数handleEvent，该函数是looperCallback的虚函数，NativeInputEventReceiver作为looperCallback的子类，自然有义务实现handleEvent这个函数。handleEvent就可以监听I/O事件。一旦有I/O事件，如上述的socket send事件，handleEvent就会被启动，进行后续的处理。
int NativeInputEventReceiver::handleEvent(int receiveFd, int events, void* data) {
status_t status = consumeEvents(env, false /*consumeBatches*/, -1, NULL);
}
既然有LooperCallback（NativeInputEventReceiver），必然会有Looper。虽然Looper不是本篇文章的研究对象，但是我们有必要理清下面的问题：
- 究竟与NativeInputEventReceiver对应的这个Looper是什么？
- 这个Looper是怎样与LooperCallback关联起来的呢？
实际上，一切起始于ViewRootImpl的setView方法：
public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
...
//在这里传入了当前线程的Looper
new WindowInputEventReceiver(mInputChannel, Looper.myLooper());
...
}
InputEventReceiver作为WindowInputEventReceiver的子类，会一起被创建出来。在InputEventReceiver的构造方法中，会调用native方法nativeInit
public InputEventReceiver(InputChannel inputChannel, Looper looper) {
mInputChannel = inputChannel;
mMessageQueue = looper.getQueue();
mReceiverPtr = nativeInit(new WeakReference<InputEventReceiver>(this),inputChannel, mMessageQueue);
}
在NativeInputEventReceiver的nativeInit方法中，创建了NativeInputEventReceiver对象，并调用它的initialize方法
static jint nativeInit(JNIEnv* env, jclass clazz, jobject receiverWeak,
jobject inputChannelObj, jobject messageQueueObj) {
...
sp<NativeInputEventReceiver> receiver = new NativeInputEventReceiver(env,
receiverWeak, inputChannel, messageQueue);
status_t status = receiver->initialize();
...
}
initialize方法只做了一件事，就是把NativeInputEventReceiver与Looper关联起来
status_t NativeInputEventReceiver::initialize() {
setFdEvents(ALOOPER_EVENT_INPUT);
return OK;
}
void NativeInputEventReceiver::setFdEvents(int events) {
if (mFdEvents != events) {
mFdEvents = events;
int fd = mInputConsumer.getChannel()->getFd();
if (events) {
mMessageQueue->getLooper()->addFd(fd, 0, events, this, NULL);
} else {
mMessageQueue->getLooper()->removeFd(fd);
}
}
}
Looper的方法addFd实现了关联Looper与LooperCallback（NativeInputEventReceiver）的功能，我们先来分析一下传给addFd的参数
- fd，fd即inputChannel的socket fd，Looper会侦测该fd的状态
- events，即传入的ALOOPER_EVENT_INPUT，只有fd的状态是INPUT的时候才会触发调用LooperCallback中的handleEvent方法
- this，即NativeInputEventReceiver，当fd状态为Input时，NativeInputEventReceiver中的handleEvent方法会被调用
在consumeEvents内，我们能看到调用了InputConsume::consume来接收InputDispatcher发送过来的事件
status_t NativeInputEventReceiver::consumeEvents(JNIEnv* env,
bool consumeBatches, nsecs_t frameTime, bool* outConsumedBatch) {
for (;;) {
status_t status = mInputConsumer.consume(&mInputEventFactory,
consumeBatches, frameTime, &seq, &inputEvent);
}
}
输入事件在consumeEvents内将会被处理完成，其中包含了四个主要步骤：
- 获取输入事件
- 把输入事件转换成java也能处理的格式
- 输入事件分发到相应窗口去处理
- 处理结果反馈
1. 获取输入事件已在上面阐述过
2. 输入事件转换
以Key为例，输入事件只是把事件内部的成员拆分，然后通过JNI调用java的构造函数来生成相应的java event对象，后面的事件处理都在java层
jobject inputEventObj;
switch (inputEvent->getType()) {
case AINPUT_EVENT_TYPE_KEY:
inputEventObj = android_view_KeyEvent_fromNative(env,
static_cast<KeyEvent*>(inputEvent));
break; // ---------------------------------------------------------------------------- jobject android_view_KeyEvent_fromNative(JNIEnv* env, const KeyEvent* event) {
jobject eventObj = env->CallStaticObjectMethod(gKeyEventClassInfo.clazz,
gKeyEventClassInfo.obtain,
nanoseconds_to_milliseconds(event->getDownTime()),
nanoseconds_to_milliseconds(event->getEventTime()),
event->getAction(),
event->getKeyCode(),
event->getRepeatCount(),
event->getMetaState(),
event->getDeviceId(),
event->getScanCode(),
event->getFlags(),
event->getSource(),
NULL);
if (env->ExceptionCheck()) {
ALOGE("An exception occurred while obtaining a key event.");
LOGE_EX(env);
env->ExceptionClear();
return NULL;
}
return eventObj;
} public static KeyEvent obtain(long downTime, long eventTime, int action,
int code, int repeat, int metaState,
int deviceId, int scancode, int flags, int source, String characters) {
KeyEvent ev = obtain();
ev.mDownTime = downTime;
ev.mEventTime = eventTime;
ev.mAction = action;
ev.mKeyCode = code;
ev.mRepeatCount = repeat;
ev.mMetaState = metaState;
ev.mDeviceId = deviceId;
ev.mScanCode = scancode;
ev.mFlags = flags;
ev.mSource = source;
ev.mCharacters = characters;
return ev;
}
3.输入事件分发
这里是在java层的事件分发，最终目的是为了调用到窗口的onTouch这类回调函数。
env->CallVoidMethod(receiverObj.get(),
gInputEventReceiverClassInfo.dispatchInputEvent, seq, inputEventObj);
还记得上面InputEventReceiver初始化时的流程吗？是通过setView--->new WindowInputEventReceiver--->new InputEventReceiver--->new NativeInputEventReceiver这样一步一步创建的。
通过上述的JNI调用，会调用到WindowInputEventReceiver的dispatchInputEvent方法，不过由于WindowInputEventReceiver并没有自己实现这个方法，因此会调用父类InputEventReceiver::dispatchInputEvent，内部会真正调用到WindowInputEventReceiver::onInputEvent
public void dispatchInputEvent(InputEvent event) {
onInputEvent(event);
}
在onInputEvent内，转到了ViewRootImpl这边进行处理
public void onInputEvent(InputEvent event) {
enqueueInputEvent(event, this, 0, true);
}
void enqueueInputEvent(InputEvent event,
InputEventReceiver receiver, int flags, boolean processImmediately) {
doProcessInputEvents();
}
由于事件队列内会包含多个事件，因此在doProcessInputEvent时，需要分别对所有的事件都进行分发
void doProcessInputEvents() {
// Deliver all pending input events in the queue.
while (mPendingInputEventHead != null) {
QueuedInputEvent q = mPendingInputEventHead;
mPendingInputEventHead = q.mNext;
if (mPendingInputEventHead == null) {
mPendingInputEventTail = null;
}
q.mNext = null;
mPendingInputEventCount -= 1;
deliverInputEvent(q);
}
}
deliverInputEvent会调用到InputState的deliver方法
public final void deliver(QueuedInputEvent q) {
if ((q.mFlags & QueuedInputEvent.FLAG_FINISHED) != 0) {
forward(q);
} else if (shouldDropInputEvent(q)) {
finish(q, false);
} else {
apply(q, onProcess(q));
}
}
由于一开始我们的事件还没有完成，因此不会带上FLAG_FINISHED，而且我们的事件时一般事件，并不会被丢弃，因此会走apply分支。
首先会调用onProcess处理事件
protected int onProcess(QueuedInputEvent q) {
if (q.mEvent instanceof KeyEvent) {
return processKeyEvent(q);
} else {
// If delivering a new non-key event, make sure the window is
// now allowed to start updating.
handleDispatchDoneAnimating();
final int source = q.mEvent.getSource();
if ((source & InputDevice.SOURCE_CLASS_POINTER) != 0) {
return processPointerEvent(q);
} else if ((source & InputDevice.SOURCE_CLASS_TRACKBALL) != 0) {
return processTrackballEvent(q);
} else {
return processGenericMotionEvent(q);
}
}
}
以Key为例，我们会调用到processKeyEvent
private int processKeyEvent(QueuedInputEvent q) {
// Deliver the key to the view hierarchy.
if (mView.dispatchKeyEvent(event)) {
return FINISH_HANDLED;
}
}
然后调用了View类的dispatchKeyEvent方法，最终会调用到onKey这个回调函数
public boolean dispatchKeyEvent(KeyEvent event) {
// Give any attached key listener a first crack at the event.
//noinspection SimplifiableIfStatement
ListenerInfo li = mListenerInfo;
if (li != null && li.mOnKeyListener != null && (mViewFlags & ENABLED_MASK) == ENABLED
&& li.mOnKeyListener.onKey(this, event.getKeyCode(), event)) {
return true;
}
}
4. 处理结果反馈
然后还剩下apply这个方法需要分析。如果onProcess正常处理完成后，会返回FINISH_HANDLED，否则返回FINISHED_NOT_NHANDLED。
protected void apply(QueuedInputEvent q, int result) {
if (result == FORWARD) {
forward(q);
} else if (result == FINISH_HANDLED) {
finish(q, true);
} else if (result == FINISH_NOT_HANDLED) {
finish(q, false);
} else {
throw new IllegalArgumentException("Invalid result: " + result);
}
}
protected void finish(QueuedInputEvent q, boolean handled) {
q.mFlags |= QueuedInputEvent.FLAG_FINISHED;
if (handled) {
q.mFlags |= QueuedInputEvent.FLAG_FINISHED_HANDLED;
}
forward(q);
}
protected void forward(QueuedInputEvent q) {
onDeliverToNext(q);
}
protected void onDeliverToNext(QueuedInputEvent q) {
if (mNext != null) {
mNext.deliver(q);
} else {
finishInputEvent(q);
}
}
private void finishInputEvent(QueuedInputEvent q) {
if (q.mReceiver != null) {
boolean handled = (q.mFlags & QueuedInputEvent.FLAG_FINISHED_HANDLED) != 0;
q.mReceiver.finishInputEvent(q.mEvent, handled);
} else {
q.mEvent.recycleIfNeededAfterDispatch();
}
recycleQueuedInputEvent(q);
}
mReceiver.finishInputEvent就是NativeInputEvent的finishInputEvent
status_t NativeInputEventReceiver::finishInputEvent(uint32_t seq, bool handled) {
status_t status = mInputConsumer.sendFinishedSignal(seq, handled);
}
status_t InputConsumer::sendFinishedSignal(uint32_t seq, bool handled) {
while (!status && chainIndex-- > 0) {
status = sendUnchainedFinishedSignal(chainSeqs[chainIndex], handled);
}
}
status_t InputConsumer::sendUnchainedFinishedSignal(uint32_t seq, bool handled) {
InputMessage msg;
msg.header.type = InputMessage::TYPE_FINISHED;
msg.body.finished.seq = seq;
msg.body.finished.handled = handled;
return mChannel->sendMessage(&msg);
}
最后也是调用sendMessage把消息反馈给InputDispatcher。
到这里，上层的处理已经完成，接下来就是InputDispatcher的反馈处理。
InputDispatcher反馈处理
反馈处理在handleReceiveCallback中进行，其中包含两个部分：
- 接收反馈消息
- 处理反馈消息
int InputDispatcher::handleReceiveCallback(int fd, int events, void* data) {
for (;;) {
uint32_t seq;
bool handled;
status = connection->inputPublisher.receiveFinishedSignal(&seq, &handled);
if (status) {
break;
}
d->finishDispatchCycleLocked(currentTime, connection, seq, handled);
gotOne = true;
}
}
1. 接收反馈消息
接收反馈消息是调用的inputPublisher的receiveFinishedSignal方法，内部还是调用了mChannel->receiveMessage
status_t InputPublisher::receiveFinishedSignal(uint32_t* outSeq, bool* outHandled) {
status_t result = mChannel->receiveMessage(&msg);
}
2. 处理反馈消息
处理反馈消息是调用了finishDispatchCycleLocked。
void InputDispatcher::finishDispatchCycleLocked(nsecs_t currentTime,
const sp<Connection>& connection, uint32_t seq, bool handled) { // Notify other system components and prepare to start the next dispatch cycle.
onDispatchCycleFinishedLocked(currentTime, connection, seq, handled);
}
void InputDispatcher::onDispatchCycleFinishedLocked(
nsecs_t currentTime, const sp<Connection>& connection, uint32_t seq, bool handled) {
CommandEntry* commandEntry = postCommandLocked(
& InputDispatcher::doDispatchCycleFinishedLockedInterruptible); }
postCommandLocked其实也是发送消息给InputDispatcherThread，那么在分发线程下一次处理消息的时候会首先处理doDispatchCycleFinishedLockedInterruptible。
doDispatchCycleFinishedLockedInterruptible是实际上反馈进行处理的地方，其中包含了下面几个处理步骤：
- 从waitQueue中取出所反馈的事件
- 事件是否处理超时，如果是则做超时处理
- 从waitQueue中删除所反馈的事件
- 立刻展开下一次的outboundQueue事件监听
void InputDispatcher::doDispatchCycleFinishedLockedInterruptible(
CommandEntry* commandEntry) { // Handle post-event policy actions.
DispatchEntry* dispatchEntry = connection->findWaitQueueEntry(seq); if (eventDuration > SLOW_EVENT_PROCESSING_WARNING_TIMEOUT) {
String8 msg;
msg.appendFormat("Window '%s' spent %0.1fms processing the last input event: ",
connection->getWindowName(), eventDuration * 0.000001f);
dispatchEntry->eventEntry->appendDescription(msg);
ALOGI("%s", msg.string());
} if (dispatchEntry == connection->findWaitQueueEntry(seq)) {
connection->waitQueue.dequeue(dispatchEntry);
} // Start the next dispatch cycle for this connection.
startDispatchCycleLocked(now(), connection);
}
}