android事件处理，把事件通知到焦点窗口，(5)

矫情吗；* 2022-06-08 07:53 149阅读 0赞

五，接下来的问题是InputDispatch是怎么把事件通知到到焦点窗口InputTarget的呢？

先看下InputTarget的定义，

InputDispatcher.h

一个inputtarget表明了怎样把一个输入事件分发给一个特定的窗口。

struct InputTarget \{

enum\{

//这个flag指示 事件应该发给前台应用程序。

FLAG\_FOREGROUND= 1 << 0,

//这个flag表明，这个motionevent，通常是触摸事件，落在了一个被上面的可见窗口遮盖的区域中了，

FLAG\_WINDOW\_IS\_OBSCURED= 1 << 1,

\};

//重点是这个inputChannel，一个inputchannel包含了一个本地的unix domain socket，它用于进程之间发送和接收输入消息，

sp<InputChannel>inputChannel;

由此可以知道，InputDispatch跟应用程序通信就是通过这个inputChannel了，既然这样， 每添加一个应用窗口，都要创建一个这样的inputChannel的通道，所以从应用窗口的添加看起：

在一个应用程序第一次启动的时候，肯定要先执行一次View树的遍历，然后再向WindowManagerService申请窗口注册，为什么不是先申请注册窗口，在执行viewtree的遍历呢？以为窗口一旦注册好就意味着可以接收事件、分发事件了，所以在这之前Viewtree要做好接收事件的准备。

ViewRootImpl.java

public void setView(View view, WindowManager.LayoutParamsattrs, View panelParentView)\{

//这里执行Viewtree的遍历，

requestLayout();

//这里开始申请注册窗口。

mInputChannel= new InputChannel();

res= mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,

getHostVisibility(),mDisplay.getDisplayId(),

mAttachInfo.mContentInsets,mAttachInfo.mStableInsets,

mAttachInfo.mOutsets,mInputChannel);

通过Session把请求发到WindowManagerService，只关注InputChannel的创建。

WindowManagerService.java

public int addWindow(Session session,IWindow client, int seq,

WindowManager.LayoutParams attrs, int viewVisibility, int displayId,

Rect outContentInsets, Rect outStableInsets, Rect outOutsets,

InputChannel outInputChannel)\{

win.openInputChannel(outInputChannel);

WindowState.java

void openInputChannel(InputChanneloutInputChannel) \{

//经过jni调用，就到了通道的本地实现，下面有这个通道详细的本地实现。

String name = makeInputChannelName();

InputChannel\[\] inputChannels = InputChannel.openInputChannelPair(name);

mInputChannel= inputChannels\[0\];

mClientChannel= inputChannels\[1\];

mInputWindowHandle.inputChannel= inputChannels\[0\];

//将 mClientChannel客户端的所有权转给了outInputChannel，这个 outInputChannel就是应用程序申请窗口时创建的。

mClientChannel.transferTo(outInputChannel);

//注册一个输入通道input channel并将其关联到输入窗口mInputWindowHandle，把它作为输入事件的target， mInputChannel和 mInputWindowHandle都是被inputdispatcher使用的，下面会分析这个注册的详细代码。

mService.mInputManager.registerInputChannel(mInputChannel,mInputWindowHandle);

下面是通道的本地实现，通过socketpare的方式，创建了sockets，一个通道有一个服务端，一个客户端，在这个场景中，服务端提供给InputDispatch-发出事件，客户端提供给应用的输入队列-消费事件，

InputTransport.cpp

status\_tInputChannel::openInputChannelPair(const String8& name,

sp<InputChannel>& outServerChannel,sp<InputChannel>& outClientChannel) \{

int sockets\[2\];

socketpair(AF\_UNIX, SOCK\_SEQPACKET, 0, sockets)

int bufferSize = SOCKET\_BUFFER\_SIZE;

setsockopt(sockets\[0\], SOL\_SOCKET, SO\_SNDBUF, &bufferSize,sizeof(bufferSize));

setsockopt(sockets\[0\], SOL\_SOCKET, SO\_RCVBUF, &bufferSize,sizeof(bufferSize));

setsockopt(sockets\[1\], SOL\_SOCKET, SO\_SNDBUF, &bufferSize,sizeof(bufferSize));

setsockopt(sockets\[1\], SOL\_SOCKET, SO\_RCVBUF, &bufferSize,sizeof(bufferSize));

String8 serverChannelName = name;

serverChannelName.append(" (server)");

outServerChannel = new InputChannel(serverChannelName, sockets\[0\]);

String8 clientChannelName = name;

clientChannelName.append(" (client)");

outClientChannel = new InputChannel(clientChannelName, sockets\[1\]);

return OK;

看下那个注册的详细实现，这个关系到inputDispatch怎么利用通道发布事件。

mService.mInputManager.registerInputChannel(mInputChannel,mInputWindowHandle);

这里的 mInputManager是InputManagerService，所以就到了：

InputManagerService.java

public voidregisterInputChannel(InputChannel inputChannel,

InputWindowHandleinputWindowHandle) \{

nativeRegisterInputChannel(mPtr, inputChannel, inputWindowHandle,false);

最终还是native层来实现的。

com\_android\_server\_input\_InputManagerService.cpp

static voidnativeRegisterInputChannel(JNIEnv\* env, jclass /\* clazz \*/,

jlong ptr, jobject inputChannelObj, jobject inputWindowHandleObj,jboolean monitor) \{

//这里调用了InputDispatch(cpp)的registerInputChannel。

status\_t status = im->registerInputChannel(

env, inputChannel,inputWindowHandle, monitor);

InputDispatcher.cpp

status\_tInputDispatcher::registerInputChannel(const sp<InputChannel>&inputChannel,

const sp<InputWindowHandle>& inputWindowHandle, bool monitor)\{

//这里创建了 Connection，在它的构造函数中会实例化inputPublisher，并传参 inputChannel，其中InputDispatch会通过inputPublisher这个对象发布事件给inputChannel，

sp<Connection>connection = new Connection( inputChannel, inputWindowHandle, monitor);

InputTransport.cpp

InputPublisher把 inputChannel赋值给 mChannel，后面会通过这个 mChannel对象sendMessage。

InputPublisher::InputPublisher(const sp<InputChannel>&channel) :

mChannel(channel) \{

把这些理清后，再回头看InputDispatch的事件分发就好明白了。

InputDispatcher.cpp

voidInputDispatcher::dispatchEventLocked(nsecs\_t currentTime,

EventEntry\* eventEntry, const Vector<InputTarget>&inputTargets) \{

prepareDispatchCycleLocked(currentTime,connection, eventEntry, &inputTarget);

voidInputDispatcher::prepareDispatchCycleLocked(nsecs\_t currentTime,

const sp<Connection>& connection, EventEntry\* eventEntry,const InputTarget\* inputTarget) \{

enqueueDispatchEntriesLocked(currentTime,connection,

splitMotionEntry,inputTarget);

voidInputDispatcher::enqueueDispatchEntriesLocked(nsecs\_t currentTime,

const sp<Connection>& connection, EventEntry\* eventEntry,const InputTarget\* inputTarget) \{

//把eventEntry转成dispatchEntry，并入队到

enqueueDispatchEntryLocked(connection,eventEntry, inputTarget,

InputTarget::FLAG\_DISPATCH\_AS\_HOVER\_EXIT);

//把队列的中事件分发出去，调用的是InputPublisher的publishKeyEvent函数。

startDispatchCycleLocked(currentTime,connection);

InputDispatcher.cpp

status\_tInputPublisher::publishKeyEvent( uint32\_t seq, int32\_tdeviceId, int32\_t

source, int32\_t action, int32\_t flags, int32\_t keyCode, int32\_t scanCode,

int32\_tmetaState, int32\_trepeatCount, nsecs\_tdownTime, nsecs\_t eventTime) \{

InputMessage msg;

//看到了应用程序中keycode，keyAction等。

msg.header.type = InputMessage::TYPE\_KEY;

msg.body.key.seq = seq;

msg.body.key.deviceId = deviceId;

msg.body.key.source = source;

msg.body.key.action = action;

msg.body.key.flags = flags;

msg.body.key.keyCode = keyCode;

msg.body.key.scanCode = scanCode;

msg.body.key.metaState = metaState;

msg.body.key.repeatCount = repeatCount;

msg.body.key.downTime = downTime;

msg.body.key.eventTime = eventTime;

//把inputmessage发送通道的服务端。

return mChannel\->sendMessage(&msg);

到这里事件的发送就完了，接下来就是对事件的接收处理。

android事件处理，把事件通知到焦点窗口，(5)

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 JavaScript 事件类型（键盘事件，鼠标事件，焦点事件）

相关简易焦点事件

相关事件通知

相关 Android事件处理分析+Android事件处理 +Android输入事件流程

相关 JavaScript 焦点事件

相关 Qt获得焦点和失去焦点处理事件（Focus事件）

相关 Qt焦点事件

相关 android事件处理，把事件通知到焦点窗口，(5)

相关 onfocus获取焦点事件与onblur失去焦点事件

相关 Android事件处理