Key event 分发流程研究心得

125 阅读 0 评论 83 点赞

我是靠谱客的博主自觉犀牛，最近开发中收集的这篇文章主要介绍Key event 分发流程研究心得，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

Android在分发Input event(Key, Motion, Pointer,TrackBall)的流程牵扯到的WindowMangerService,ViewRootImpl和InputDispatcherThread三位角色.这三位角色的工作关系会依以下三个阶段来分析.

1. 起源.

2. 指定接受者.

3. 处理输入事件流程.

起源

在之前的输入法研究分析可以知道, 在android一开机的时候会去启动InputManager service, 此service会再去启动InputReaderThread和InputDispatcherThread,前者是从driver哪边获取inputevent放入Queue中在通知InputDispatcherThread去Queue中捞出来放进linux中的共享内存, 之后在通知ViewRootImpl去作分发的处理. 这一篇着重在于分发的过程. 至于inputevent在android中的流程机制之前就有作过分析了. 这里就不再重复描述. 就从InputDispatcherThread被启动的流程开始分析.

threadLoop @InputDispatcher.cpp
bool InputDispatcherThread::threadLoop() {
mDispatcher->dispatchOnce();
return true;
}
threadLoop @InputDispatcher.cpp
void InputDispatcher::dispatchOnce() {
// do something
nsecs_t currentTime = now();
int timeoutMillis = toMillisecondTimeoutDelay(currentTime,
nextWakeupTime);
mLooper->pollOnce(timeoutMillis);
1
}

1. 开始针对目前process的looper作polling状态. 检查是否有新的inputevent

pollOnce @Looper.cpp
int Looper::pollOnce(int timeoutMillis, int* outFd, int* outEvents, void** outData) {
for (;;) {
// do something
result = pollInner(timeoutMillis);
}
}
pollInner@ Looper.cpp
int Looper::pollInner(int timeoutMillis) {
//do something
int result = ALOOPER_POLL_WAKE;
mResponses.clear();
mResponseIndex = 0;
struct epoll_event eventItems[EPOLL_MAX_EVENTS];
int eventCount = epoll_wait(mEpollFd, eventItems,
EPOLL_MAX_EVENTS, timeoutMillis);
1
//处理所监听到的相关事件
//do something
sp<MessageHandler> handler = messageEnvelope.handler;
Message message = messageEnvelope.message;
mMessageEnvelopes.removeAt(0);
mSendingMessage = true;
mLock.unlock();
handler->handleMessage(message);
2
//do something
if (response.request.ident == ALOOPER_POLL_CALLBACK) {
int fd = response.request.fd;
int events = response.events;
void* data = response.request.data;
int callbackResult = response.request.callback->handleEvent(fd,
events, data);
3
if (callbackResult == 0) {
removeFd(fd);
}
response.request.callback.clear();
result = ALOOPER_POLL_CALLBACK;
}

1. 利用epoll_wait函数来监听目前looper上的event,一有event其eventCount就会回传event的数目. 假若在最后一个参数指定的 timeoutMillis内都没有事件发生, 其eventCount就会回传0,若有发生错误回传-1.由 EPOLL_MAX_EVENTS 的定义值可以知道, 所监听到的event数最多为16个event.

2. 呼叫执行所有在looper中的闲置中的Message所带的CallBackfunction handleMessage

3. 呼叫执行所有在looper中的reponse eventCallBack function handleEvent

由上面的程序代码分析可以知道在一开始InputDispatcherThread就会一直开始监听目前looper上是否有message或是event需要处理.

指定接受者.

当Android app一开始要去绘制整个layout时,WindowsManager会先作 addView 的处理还将自己的View先设定到目前的Window上. 就从WindowManager的addViewfunction开始分析.

addView@ WindowManagerGlobal.java
public void addView(View view, ViewGroup.LayoutParams params,
Display display, Window parentWindow) {
//do something
root.setView(view, wparams, panelParentView);
//do something
}
setView@ ViewRootImpl.java
public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
//do something
mInputEventReceiver = new
WindowInputEventReceiver(mInputChannel,
Looper.myLooper());
1
//do something
}
WindowInputEventReceiver@ ViewRootImpl.java
final class WindowInputEventReceiver extends InputEventReceiver {
public WindowInputEventReceiver(InputChannel inputChannel, Looper
looper) {
super(inputChannel, looper);
2
}
@Override
public void onInputEvent(InputEvent event) {
enqueueInputEvent(event, this, 0, true);
}
@Override
public void onBatchedInputEventPending() {
scheduleConsumeBatchedInput();
}
@Override
public void dispose() {
unscheduleConsumeBatchedInput();
super.dispose();
}
}

1. 产生一个带有两个CallBack function实作的 WindowInputEventReceiver物件 . 这两个CallBack function onInputEvent 和 onBatchedInputEventPending 会跟在nativelayer的 InputDispatcherThread 监听事件处理有相关.

2. 跟目前所在的Looper注册request CallBackobject NativeInputEventReceiver

处理输入事件流程.

由前面起源的分析可以知道, InputDispatcherThread一直处在监听looper上的事件阶段, 一旦监听到looper上有event就会接者呼叫执行event所带的CallBackfunctionhandleEvent . 至于是呼叫哪一个event所带的handleEvent函数. 这就要由程序代码 response.request.callback->handleEvent 开始分析. 就由前面指定接受者的第二个步骤开始分析.

WindowInputEventReceiver@ ViewRootImpl.java
public WindowInputEventReceiver(InputChannel inputChannel, Looper
looper) {
super(inputChannel, looper);
}
InputEventReceiver@ InputEventReceiver.java
public InputEventReceiver(InputChannel inputChannel, Looper looper) {
//do something
mInputChannel = inputChannel;
mMessageQueue = looper.getQueue();
mReceiverPtr = nativeInit(this, inputChannel, mMessageQueue);
//do somthing
}
nativeInit@ android_view_InputEventReceiver.cpp
static jint nativeInit(JNIEnv* env, jclass clazz, jobject receiverObj,
jobject inputChannelObj, jobject messageQueueObj) {
//do something
status_t status = receiver->initialize();
//do something
}
NativeInputEventReceiver::initialize@ android_view_InputEventReceiver.cpp
status_t NativeInputEventReceiver::initialize() {
int receiveFd = mInputConsumer.getChannel()->getFd();
mMessageQueue->getLooper()->addFd(receiveFd, 0,
ALOOPER_EVENT_INPUT, this, NULL);
return OK;
}
Looper::addFd@Looper.cpp
int Looper::addFd(int fd, int ident, int events, const sp<LooperCallback>&
callback, void* data) {
//do something
Request request;
request.fd = fd;
request.ident = ident;
request.callback = callback;
request.data = data;
struct epoll_event eventItem;
memset(& eventItem, 0, sizeof(epoll_event));
eventItem.events = epollEvents;
eventItem.data.fd = fd;
ssize_t requestIndex = mRequests.indexOfKey(fd);
if (requestIndex < 0) {
int epollResult = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, fd, &
eventItem);
if (epollResult < 0) {
ALOGE("Error adding epoll events for fd %d, errno=%d", fd,
errno);
return -1;
}
mRequests.add(fd, request);
} else {
int epollResult = epoll_ctl(mEpollFd, EPOLL_CTL_MOD, fd, &
eventItem);
if (epollResult < 0) {
ALOGE("Error modifying epoll events for fd %d, errno=%d",
fd, errno);
return -1;
}
mRequests.replaceValueAt(requestIndex, request);
}
//do something
}

由上面的程序代码流程可以知道, 在一开始初始化WindowInputEventReceiver对象时, 又去呼叫父类别InputEventReceiver建构子. 这时就又去呼叫JNI函数nativeInit去做初始化流程, 此初始化的流程就正式注册Looper上的CallBackevent 所带的信息. 也就是说先把request的information记录下来, 等到要回reponse的时候就知道要回给哪一个request.由此可知, 此程序代码 response.request.callback->handleEvent 等同于

(NativeInputEventReceiver*)receiver-> handleEvent.

NativeInputEventReceiver::handleEvent@ android_view_InputEventReceiver.cpp
int NativeInputEventReceiver::handleEvent(int receiveFd, int events, void* data) {
//do something
status_t status = consumeEvents(env, false /*consumeBatches*/, -1);
//do something
return status == OK || status == NO_MEMORY ? 1 : 0;
}
NativeInputEventReceiver::consumeEvents@ android_view_InputEventReceiver.cpp
status_t NativeInputEventReceiver::consumeEvents(JNIEnv* env,
bool consumeBatches, nsecs_t frameTime) {
//do something
for (;;) {
status_t status = mInputConsumer.consume(&mInputEventFactory,
consumeBatches, frameTime, &seq, &inputEvent);
//do something
switch (inputEvent->getType()) {
case AINPUT_EVENT_TYPE_KEY:
inputEventObj = android_view_KeyEvent_fromNative(env,
static_cast<KeyEvent*>(inputEvent));
break;
case AINPUT_EVENT_TYPE_MOTION:
inputEventObj =
android_view_MotionEvent_obtainAsCopy(env,
static_cast<MotionEvent*>(inputEvent));
break;
default:
assert(false);
inputEventObj = NULL;
}
env->CallVoidMethod(mReceiverObjGlobal,
gInputEventReceiverClassInfo.dispatchInputEvent,
seq, inputEventObj);
//do something
}
}
dispatchInputEvent@ InputEventReceiver.java
// Called from native code.
@SuppressWarnings("unused")
private void dispatchInputEvent(int seq, InputEvent event) {
mSeqMap.put(event.getSequenceNumber(), seq);
onInputEvent(event);
}

这一路下来, 由native layer的 handleEventfunction 藉由 InputConsumer对象将新的input event取出来, 然后就传给javalayer的 dispatchInputEvent 函数继续作分发的处理. 这里值得一提的是我们发现dispatchInputEvent函数会继续将event传给 onInputEvent函数, 然而此函数所属的InputEventReceiver是一个抽像类别, 抽象类是无法实体化的, 所以此函数最有可能实作在抽像类别所衍生的类别里. InputEventReceiver类别衍生的类别是 WindowInputEventReceiver类别, 所以就继续从WindowInputEventReceiver的 onInputEvent函数分析

onInputEvent@ ViewRootImpl.java
@Override
public void onInputEvent(InputEvent event) {
enqueueInputEvent(event, this, 0, true);
}
enqueueInputEvent @ ViewRootImpl.java
void enqueueInputEvent(InputEvent event,
InputEventReceiver receiver, int flags, boolean processImmediately) {
//do something
if (processImmediately) {
doProcessInputEvents();
} else {
scheduleProcessInputEvents();
}
}
doProcessInputEvents@ ViewRootImpl.java
void doProcessInputEvents() {
while (mCurrentInputEvent == null && mFirstPendingInputEvent != null)
{
QueuedInputEvent q = mFirstPendingInputEvent;
mFirstPendingInputEvent = q.mNext;
q.mNext = null;
mCurrentInputEvent = q;
deliverInputEvent(q);
}
// We are done processing all input events that we can process right now
// so we can clear the pending flag immediately.
if (mProcessInputEventsScheduled) {
mProcessInputEventsScheduled = false;
mHandler.removeMessages(MSG_PROCESS_INPUT_EVENTS);
}
}
deliverInputEvent @ ViewRootImpl.java
private void deliverInputEvent(QueuedInputEvent q) {
Trace.traceBegin(Trace.TRACE_TAG_VIEW, "deliverInputEvent");
try {
if (q.mEvent instanceof KeyEvent) {
deliverKeyEvent(q);
} else {
final int source = q.mEvent.getSource();
if ((source & InputDevice.SOURCE_CLASS_POINTER) != 0)
{
deliverPointerEvent(q);
} else if ((source &
InputDevice.SOURCE_CLASS_TRACKBALL) != 0) {
deliverTrackballEvent(q);
} else {
deliverGenericMotionEvent(q);
}
}
} finally {
Trace.traceEnd(Trace.TRACE_TAG_VIEW);
}
}
deliverKeyEvent @ ViewRootImpl.java
private void deliverKeyEvent(QueuedInputEvent q) {
//do something
deliverKeyEventPostIme(q);
}
deliverKeyEventPostIme @ ViewRootImpl.java
private void deliverKeyEventPostIme(QueuedInputEvent q) {
//do something
mView.dispatchKeyEvent(event)
//do something
}
dispatchKeyEvent @View.java
public boolean dispatchKeyEvent(KeyEvent event) {
//do something
ListenerInfo li = mListenerInfo;
if (li != null && li.mOnKeyListener != null && (mViewFlags &
ENABLED_MASK) == ENABLED
&& li.mOnKeyListener.onKey(this,
event.getKeyCode(), event)) {
1
return true;
}
if (event.dispatch(this, mAttachInfo != null
? mAttachInfo.mKeyDispatchState : null, this)) {
2
return true;
}
//do something
}

1. 自定义的view若有注册Key Listener,就会由此接收到

Key event.

2. 一般的Key event是由此函数 dispatch来作分发.

dispatch @ KeyEvent.java
public final boolean dispatch(Callback receiver, DispatcherState state,
Object target) {
//do something
switch (mAction) {
case ACTION_DOWN:
//do something
receiver.onKeyDown(mKeyCode, this);
case ACTION_UP:
//do something
receiver.onKeyUp(mKeyCode, this);
case ACTION_MULTIPLE:
//do something
receiver.onKeyMultiple(code, count, this)
}
}