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

向右看齐 2022-07-16 14:50 282阅读 0赞

# Android事件处理分析 #

http://blog.csdn.net/linweig/archive/2010/02/27/5330391.aspx

**按键事件**

对于按键事件，调用mDevices->layoutMap->map进行映射。映射实际是由 KeyLayoutMap::map完成的，K**eyLayoutMap类里读取配置文件qwerty.kl** ，由配置 文件 qwerty.kl 决定键值的映射关系。你可以通过修 改./development/emulator/keymaps/qwerty.kl来改变键值的映射关系。   
  
**JNI 函数 **  
在 frameworks/base/services/j**ni** /com\_android\_server\_KeyInputQueue.cpp文 件中，向 JAVA提供了函数android\_server\_KeyInputQueue\_**readEvent，用于读 取输入设备事件** 。   
C代码：

![ExpandedBlockStart.gif][]

static jboolean android\_server\_KeyInputQueue\_readEvent(JNIEnv\* env, jobject clazz,   
                                           jobject event)  
\{   
    gLock.lock();   
    sp hub = gHub;   
    if (hub == NULL) \{   
        hub = new EventHub;   
        gHub = hub;   
    \}   
    gLock.unlock();   
    int32\_t deviceId;   
    int32\_t type;   
    int32\_t scancode, keycode;   
    uint32\_t flags;   
    int32\_t value;   
    nsecs\_t when;   
    bool res = hub->getEvent(&deviceId, &type, &scancode, &keycode,   
            &flags, &value, &when);   
    env->SetIntField(event, gInputOffsets.mDeviceId, (jint)deviceId);   
    env->SetIntField(event, gInputOffsets.mType, (jint)type);   
    env->SetIntField(event, gInputOffsets.mScancode, (jint)scancode);   
    env->SetIntField(event, gInputOffsets.mKeycode, (jint)keycode);   
    env->SetIntField(event, gInputOffsets.mFlags, (jint)flags);   
    env->SetIntField(event, gInputOffsets.mValue, value);   
    env->SetLongField(event, gInputOffsets.mWhen,   
                       (jlong)(nanoseconds\_to\_milliseconds(when)));   
    return res;   
\}

** readEvent调用hub->getEvent读了取事件，然后转换成JAVA的结构** 。   
  
事件中转线程   
在frameworks/base/services/**java** /com/android/server/KeyInputQueue.java 里创建了一个线程，它循环的读取事件，然后把事件放入事件队列里。   
Java代码:·

![ExpandedBlockStart.gif][]

Thread mThread = new Thread("InputDeviceReader") \{  
        public void run() \{  
            android.os.Process.setThreadPriority(  
                    android.os.Process.THREAD\_PRIORITY\_URGENT\_DISPLAY);  
              
            try \{  
                RawInputEvent ev = new RawInputEvent();  
                while (true) \{  
                    InputDevice di;

// block, doesn't release the monitor  
                    readEvent(ev);

boolean send = false;  
                    boolean configChanged = false;  
                      
                    if (false) \{  
                        Log.i(TAG, "Input event: dev=0x"  
                                + Integer.toHexString(ev.deviceId)  
                                + " type=0x" + Integer.toHexString(ev.type)  
                                + " scancode=" + ev.scancode  
                                + " keycode=" + ev.keycode  
                                + " value=" + ev.value);  
                    \}  
                      
                    if (ev.type == RawInputEvent.EV\_DEVICE\_ADDED) \{  
                        synchronized (mFirst) \{  
                            di = newInputDevice(ev.deviceId);  
                            mDevices.put(ev.deviceId, di);  
                            configChanged = true;  
                        \}  
                    \}

......

\};

**按键、触摸屏流、轨迹球程分析**

输入事件分发线程   
在frameworks/base/services/java/com/android/server/**WindowManagerService.java里创建了一个输入事件分发线程，它负责把事件分发到相应的窗口上去。**

按键触摸屏流程分析:   
  
    WindowManagerService类的构造函数

WindowManagerService()

mQueue = new KeyQ();   
  
因为 WindowManagerService.java (frameworks/base/services/java/com/android/server)中有：

private class KeyQ extends KeyInputQueue implements KeyInputQueue.FilterCallback

KeyQ 是抽象类 KeyInputQueue 的实现，所以 new KeyQ类的时候实际上在 KeyInputQueue 类中创建了一个线程 InputDeviceReader 专门用来从设备读取按键事件，

代码：   
![ExpandedBlockStart.gif][]

Thread mThread = new Thread("InputDeviceReader") \{   
  
    public void run() \{   
  
        // 在循环中调用：

readEvent(ev);   
        ...   
        send = preprocessEvent(di, ev);

//实际调用的是 KeyQ 类的 preprocessEvent 函数   
         ...   
        int keycode = rotateKeyCodeLocked(ev.keycode);

int\[\] map = mKeyRotationMap;  
 
        for (int i=0; i<N; i+=2) \{  
 
            if (map == keyCode)   
 
            return map\[i+1\];  
 
        \} //  
 
        addLocked(di, curTime, ev.flags,RawInputEvent.CLASS\_KEYBOARD, 
                  newKeyEvent(di, di.mDownTime, curTime, down,keycode, 0, scancode,...));  
 
        QueuedEvent ev = obtainLocked(device, when, flags, classType, event);  
    \}  
\};

readEvent() 实际上调用的是 com\_android\_server\_KeyInputQueue.cpp (frameworks/base/services/jni)中的

static jboolean android\_server\_KeyInputQueue\_readEvent(JNIEnv\* env, jobject clazz,jobject event) 来读取事件，

bool res = hub->getEvent(&deviceId, &type, &scancode, &keycode,&flags, &value, &when)调用的是EventHub.cpp (frameworks/base/libs/ui)中的：   
  
    bool EventHub::getEvent (int32\_t\* outDeviceId, int32\_t\* outType,   
  
            int32\_t\* outScancode, int32\_t\* outKeycode, uint32\_t \*outFlags,   
  
            int32\_t\* outValue, nsecs\_t\* outWhen)   
  
在函数中调用了读设备操作：res = read(mFDs.fd, &iev, sizeof(iev));   
  
在构造函数 WindowManagerService()调用 new KeyQ() 以后接着调用了：   
  
    mInputThread = new InputDispatcherThread();         
    ...

mInputThread.start();   
  
来启动一个线程 InputDispatcherThread   
  
    run()   
    process();   
    QueuedEvent ev = mQueue.getEvent(...)   
  
因为WindowManagerService类中： final KeyQ mQueue;   
  
所以实际上 InputDispatcherThread 线程实际上从 KeyQ 的事件队列中读取按键事件，在process() 方法中进行处理事件。  
  
    switch (ev.classType)   
    case RawInputEvent.CLASS\_KEYBOARD:   
        ...   
        dispatchKey((KeyEvent)ev.event, 0, 0);   
        mQueue.recycleEvent(ev);   
        break;   
    case RawInputEvent.CLASS\_TOUCHSCREEN:   
        //Log.i(TAG, "Read next event " + ev);   
        dispatchPointer(ev, (MotionEvent)ev.event, 0, 0);   
        break;

case RawInputEvent.CLASS\_TRACKBALL:  
        dispatchTrackball(ev, (MotionEvent)ev.event, 0, 0);  
        break;

===============================================================

补充一些内容：

在写程序时，需要捕获KEYCODE\_HOME、KEYCODE\_ENDCALL、KEYCODE\_POWER这几个按键，但是这几个按键系统做了特殊处理，在进行dispatch之前做了一些操作，HOME除了Keygaurd之外，不分发给任何其他APP，ENDCALL和POWER也类似，所以需要我们系统处理之前进行处理。

我的做法是自己定义一个FLAG，在自己的程序中添加此FLAG，然后在WindowManagerServices.java中获取当前窗口的FLAG属性，如果是我们自己设置的那个FLAG，则不进行特殊处理，直接分发按键消息到我们的APP当中，由APP自己处理。

这部分代码最好添加在

@Override  
boolean preprocessEvent(InputDevice device, RawInputEvent event)

方法中，这个方法是KeyInputQueue中的一个虚函数，在处理按键事件之前的一个“预处理”。

PS:对HOME键的处理好像必需要修改PhoneWindowManager.java中的interceptKeyTi方法，具体可以参考对KeyGuard程序的处理。

===============================================================

**系统底层事件处理过程**

在系统启动后，android 会通过   
  
    static const char \*device\_path = "/dev/input";

bool EventHub::penPlatformInput(void)

res = scan\_dir(device\_path);   
  
通过下面的函数打开设备。

![ExpandedBlockStart.gif][]

int EventHub::pen\_device(const char \*deviceName)   
\{   
    ...   
    fd = open(deviceName, O\_RDWR);   
    ...    
    mFDs\[mFDCount\].fd = fd;   
    mFDs\[mFDCount\].events = POLLIN;   
    ...   
     **ioctl** (mFDs\[mFDCount\].fd, EVIOCGNAME(sizeof(devname)-1), devname);   
    ...   
    const char\* root = getenv("ANDROID\_ROOT");   
    snprintf(keylayoutFilename, sizeof(keylayoutFilename),   
                 "%s/usr/keylayout/%s.kl", root, tmpfn);   
    ...   
    device->layoutMap->load(keylayoutFilename);   
    ...   
\}

打开设备的时候，如果 device->classes&CLASS\_KEYBOARD 不等于 0 表明是键盘。   
  
常用输入设备的定义有：   
  
enum \{   
        CLASS\_KEYBOARD      = 0x00000001, //键盘

CLASS\_ALPHAKEY      = 0x00000002, //

CLASS\_TOUCHSCREEN   = 0x00000004, //触摸屏

CLASS\_TRACKBALL     = 0x00000008 //轨迹球   
\};   
  
打开键盘设备的时候通过上面的 ioctl 获得设备名称，命令字 EVIOCGNAME 的定义在文件：   
  
kernel/include/linux/input.h 中。   
  
\#define EVIOCGNAME(len)   \_IOC(\_IOC\_READ, 'E', 0x06, len) /\* get device name \*/   
  
在**内核键盘驱动文件 drivers/input/keyboard/pxa27x\_keypad.c 中定义了设备名称** ：pxa27x-keypad   
  
static struct platform\_driver pxa27x\_keypad\_driver = \{   
  
    .probe        = pxa27x\_keypad\_probe,   
  
    .remove        = \_\_devexit\_p(pxa27x\_keypad\_remove),   
  
    .suspend    = pxa27x\_keypad\_suspend,   
  
    .resume        = pxa27x\_keypad\_resume,   
  
    .driver        = \{   
  
        .name    = "pxa27x-keypad",   
  
        .owner    = THIS\_MODULE,   
  
    \},   
  
\};   
  
ANDROID\_ROOT 为环境变量，在android的命令模式下通过 printenv 可以知道它为： system   
  
**所以 keylayoutFilename 为：/system/usr/ keylayout/pxa27x-keypad.kl **  
  
pxa27x-keypad.kl 定义了按键映射，具体内容如下：

![ExpandedBlockStart.gif][]

\# NUMERIC KEYS 3x4   
key 2   1   
key 3   2   
key 4   3   
key 5   4   
key 6   5   
key 7   6   
key 8   7   
key 9   8   
key 10 9   
key 11 0   
key 83 POUND   
key 55 STAR   
  
\# FUNCTIONAL KEYS   
key 231 MENU        WAKE\_DROPPED   
key 192 BACK           WAKE\_DROPPED   
key 193 HOME       WAKE   
key 107 DEL        WAKE   
key 102 CALL        WAKE\_DROPPED   
key 158 ENDCALL     WAKE\_DROPPED   
key 28   DPAD\_CENTER     WAKE   
key 115 VOLUME\_UP   
key 114 VOLUME\_DOWN

如果没有定义键盘映射文件，那么默认使用系统的 /system/usr/keylayout/qwerty.kl 可以修改 /system/usr/keylayout/qwerty.kl 文件改变Android公司的按键映射。   
  
device->layoutMap->load(keylayoutFilename) 调用的是文件 KeyLayoutMap.cpp (frameworks/base/libs/ui)中的函数：

status\_t KeyLayoutMap::load(const char\* filename)通过解析 pxa27x-keypad.kl  
把按键的映射关系保存在 ：KeyedVector<int32\_t,Key> m\_keys; 中。  
 
当获得按键事件以后调用：  
status\_t KeyLayoutMap::map(int32\_t scancode, int32\_t \*keycode, uint32\_t \*flags)  
 
由映射关系 KeyedVector<int32\_t,Key> m\_keys 把扫描码转换成andorid上层可以识别的按键。

#     #

# Android事件处理   #

Init-----------zygote---------system-server-------------------windosmanager  ------------------------------------------------------------ UEventObserver  
\------------------------------------------------------------ InputDeviceRead  
\-------------------------------------------------------------InputDispatcher  
\-------------------------------------------------------------DisplayEventThr  
\-------------------------------------------------------------ActivityManager

EventHub：  
而事件的传入是从EventHub开始的，EventHub是事件的抽象结构，维护着系统设备的运行情况，设备类型包 括Keyboard、TouchScreen、TraceBall。它在系统启动的时候会通过open\_device方法将系统提供的输入设备都增加到这 个抽象结构中，并维护一个所有输入设备的文件描述符，如果输入设备是键盘的话还会读取/system/usr/keylayout/目录下对应键盘设备的 映射文件，另外getEvent方法是对EventHub中的设备文件描述符使用poll操作等侍驱动层事件的发生，如果发生的事件是键盘事件，则调用 Map函数按照映射文件转换成相应的键值并将扫描码和键码返回给KeyInputQueue。  
KeyLayoutMap主要是读取键盘映射文件并将键盘扫描码和键码进行转换

frameworks/base/core/jni/server/ com\_android\_server\_KeyInputQueue.cpp  
EventHub和KeyinputQueue的JNI接口层

KeyinputQueue：  
在线程InputDeviceReader中会根据事件的类型以及事件值进行判断处理，从而确定这个事件对应的设备状态是否发生了改变并相应的改变对这个设备的描述结构InputDevice。  
getEvent：在给定时间段时看是否有事件发生，如果有的话返回true否则false。

Windowmanager：  
(frameworks/base/services/java/com/android/server/windowmanagerservice.java)  
进 程Windowmanager会创建一个线程（InputDispatcherThread），在这个线程里从事件队列中读取发生的事件 （QueuedEvent ev = mQueue.getEvent（）），并根据读取到事件类型的不同分成三类（KEYBOARD、TOUCHSCREEN、TRACKBALL），分别进 行处理，例如键盘事件会调用dispatchKey((KeyEvent)ev.event, 0, 0)以将事件通过Binder发送给具有焦点的窗口应用程序，然后调用 mQueue.recycleEvent(ev)继续等侍键盘事件的发生;如果是触摸屏事件则调用dispatchPointer(ev, (MotionEvent)ev.event, 0, 0)，这里会根据事件的种类（UP、DOWN、MOVE、OUT\_SIDE等）进行判断并处理，比如Cancel或将事件发送到具有权限的指定的窗口中 去;

Android 输入事件流程

EventHub

EventHub对输入设备进行了封装。输入设备驱动程序对用户空间应用程序提供一些设备文件，这些设备文件放在/dev/input里面。

EventHub扫描/dev/input下所有设备文件，并打开它们。

C代码  
bool EventHub::openPlatformInput(void)     
\{     
...     
    mFDCount = 1;     
    mFDs = (pollfd \*)calloc(1, sizeof(mFDs\[0\]));     
    mDevices = (device\_t \*\*)calloc(1, sizeof(mDevices\[0\]));     
    mFDs\[0\].events = POLLIN;     
    mDevices\[0\] = NULL;     
    
    res = scan\_dir(device\_path);     
...     
    return true;     
\}    
bool EventHub::openPlatformInput(void)  
\{  
...  
    mFDCount = 1;  
    mFDs = (pollfd \*)calloc(1, sizeof(mFDs\[0\]));  
    mDevices = (device\_t \*\*)calloc(1, sizeof(mDevices\[0\]));  
    mFDs\[0\].events = POLLIN;  
    mDevices\[0\] = NULL;

res = scan\_dir(device\_path);  
...  
    return true;  
\}

EventHub对外提供了一个函数用于从输入设备文件中读取数据。

C代码 
bool EventHub::getEvent(int32\_t\* outDeviceId, int32\_t\* outType,    
        int32\_t\* outScancode, int32\_t\* outKeycode, uint32\_t \*outFlags,    
        int32\_t\* outValue, nsecs\_t\* outWhen)    
\{    
    ...    
    while(1) \{    
   
        // First, report any devices that had last been added/removed.    
        if (mClosingDevices != NULL) \{    
            device\_t\* device = mClosingDevices;    
            LOGV("Reporting device closed: id=0x%x, name=%s/n",    
                 device->id, device->path.string());    
            mClosingDevices = device->next;    
            \*outDeviceId = device->id;    
            if (\*outDeviceId == mFirstKeyboardId) \*outDeviceId = 0;    
            \*outType = DEVICE\_REMOVED;    
            delete device;    
            return true;    
        \}    
        if (mOpeningDevices != NULL) \{    
            device\_t\* device = mOpeningDevices;    
            LOGV("Reporting device opened: id=0x%x, name=%s/n",    
                 device->id, device->path.string());    
            mOpeningDevices = device->next;    
            \*outDeviceId = device->id;    
            if (\*outDeviceId == mFirstKeyboardId) \*outDeviceId = 0;    
            \*outType = DEVICE\_ADDED;    
            return true;    
        \}    
   
        release\_wake\_lock(WAKE\_LOCK\_ID);    
   
        pollres = poll(mFDs, mFDCount, -1);    
   
        acquire\_wake\_lock(PARTIAL\_WAKE\_LOCK, WAKE\_LOCK\_ID);    
   
        if (pollres <= 0) \{    
            if (errno != EINTR) \{    
                LOGW("select failed (errno=%d)/n", errno);    
                usleep(100000);    
            \}    
            continue;    
        \}    
   
        for(i = 1; i < mFDCount; i++) \{    
            if(mFDs\[i\].revents) \{    
                LOGV("revents for %d = 0x%08x", i, mFDs\[i\].revents);    
                if(mFDs\[i\].revents & POLLIN) \{    
                    res = read(mFDs\[i\].fd, &iev, sizeof(iev));    
                    if (res == sizeof(iev)) \{    
                        LOGV("%s got: t0=%d, t1=%d, type=%d, code=%d, v=%d",    
                             mDevices\[i\]->path.string(),    
                             (int) iev.time.tv\_sec, (int) iev.time.tv\_usec,    
                             iev.type, iev.code, iev.value);    
                        \*outDeviceId = mDevices\[i\]->id;    
                        if (\*outDeviceId == mFirstKeyboardId) \*outDeviceId = 0;    
                        \*outType = iev.type;    
                        \*outScancode = iev.code;    
                        if (iev.type == EV\_KEY) \{    
                            err = mDevices\[i\]->layoutMap->map(iev.code, outKeycode, outFlags);    
                            LOGV("iev.code=%d outKeycode=%d outFlags=0x%08x err=%d/n",    
                                iev.code, \*outKeycode, \*outFlags, err);    
                            if (err != 0) \{    
                                \*outKeycode = 0;    
                                \*outFlags = 0;    
                            \}    
                        \} else \{    
                            \*outKeycode = iev.code;    
                        \}    
                        \*outValue = iev.value;    
                        \*outWhen = s2ns(iev.time.tv\_sec) + us2ns(iev.time.tv\_usec);    
                        return true;    
                    \} else \{    
                        if (res<0) \{    
                            LOGW("could not get event (errno=%d)", errno);    
                        \} else \{    
                            LOGE("could not get event (wrong size: %d)", res);    
                        \}    
                        continue;    
                    \}    
                \}    
            \}    
        \}    
    ...    
\}   
bool EventHub::getEvent(int32\_t\* outDeviceId, int32\_t\* outType, 
        int32\_t\* outScancode, int32\_t\* outKeycode, uint32\_t \*outFlags, 
        int32\_t\* outValue, nsecs\_t\* outWhen) 
\{ 
 ... 
    while(1) \{

// First, report any devices that had last been added/removed.  
        if (mClosingDevices != NULL) \{  
            device\_t\* device = mClosingDevices;  
            LOGV("Reporting device closed: id=0x%x, name=%s/n",  
                 device->id, device->path.string());  
            mClosingDevices = device->next;  
            \*outDeviceId = device->id;  
            if (\*outDeviceId == mFirstKeyboardId) \*outDeviceId = 0;  
            \*outType = DEVICE\_REMOVED;  
            delete device;  
            return true;  
        \}  
        if (mOpeningDevices != NULL) \{  
            device\_t\* device = mOpeningDevices;  
            LOGV("Reporting device opened: id=0x%x, name=%s/n",  
                 device->id, device->path.string());  
            mOpeningDevices = device->next;  
            \*outDeviceId = device->id;  
            if (\*outDeviceId == mFirstKeyboardId) \*outDeviceId = 0;  
            \*outType = DEVICE\_ADDED;  
            return true;  
        \}

release\_wake\_lock(WAKE\_LOCK\_ID);

pollres = poll(mFDs, mFDCount, -1);

acquire\_wake\_lock(PARTIAL\_WAKE\_LOCK, WAKE\_LOCK\_ID);

if (pollres <= 0) \{ 
            if (errno != EINTR) \{ 
                LOGW("select failed (errno=%d)/n", errno); 
                usleep(100000); 
            \} 
            continue; 
        \}

for(i = 1; i < mFDCount; i++) \{ 
            if(mFDs\[i\].revents) \{ 
                LOGV("revents for %d = 0x%08x", i, mFDs\[i\].revents); 
                if(mFDs\[i\].revents & POLLIN) \{ 
                    res = read(mFDs\[i\].fd, &iev, sizeof(iev)); 
                    if (res == sizeof(iev)) \{ 
                        LOGV("%s got: t0=%d, t1=%d, type=%d, code=%d, v=%d", 
                             mDevices\[i\]->path.string(), 
                             (int) iev.time.tv\_sec, (int) iev.time.tv\_usec, 
                             iev.type, iev.code, iev.value); 
                        \*outDeviceId = mDevices\[i\]->id; 
                        if (\*outDeviceId == mFirstKeyboardId) \*outDeviceId = 0; 
                        \*outType = iev.type; 
                        \*outScancode = iev.code; 
                        if (iev.type == EV\_KEY) \{ 
                            err = mDevices\[i\]->layoutMap->map(iev.code, outKeycode, outFlags); 
                            LOGV("iev.code=%d outKeycode=%d outFlags=0x%08x err=%d/n", 
                                iev.code, \*outKeycode, \*outFlags, err); 
                            if (err != 0) \{ 
                                \*outKeycode = 0; 
                                \*outFlags = 0; 
                            \} 
                        \} else \{ 
                            \*outKeycode = iev.code; 
                        \} 
                        \*outValue = iev.value; 
                        \*outWhen = s2ns(iev.time.tv\_sec) + us2ns(iev.time.tv\_usec); 
                        return true; 
                    \} else \{ 
                        if (res<0) \{ 
                            LOGW("could not get event (errno=%d)", errno); 
                        \} else \{ 
                            LOGE("could not get event (wrong size: %d)", res); 
                        \} 
                        continue; 
                    \} 
                \} 
            \} 
        \} 
 ... 
\}

对于按键事件，调用mDevices\[i\]->layoutMap->map进行映射。映射实际是由 KeyLayoutMap::map完成的，KeyLayoutMap类里读取配置文件qwerty.kl，由配置 文件 qwerty.kl 决定键值的映射关系。你可以通过修 改./development/emulator/keymaps/qwerty.kl来改变键值的映射关系。  
JNI 函数

在frameworks/base/services/jni/com\_android\_server\_KeyInputQueue.cpp文 件中，向 JAVA提供了函数android\_server\_KeyInputQueue\_readEvent，用于读 取输入设备事件。

C代码  
static jboolean     
android\_server\_KeyInputQueue\_readEvent(JNIEnv\* env, jobject clazz,     
                                          jobject event)     
\{     
    gLock.lock();     
    sp hub = gHub;     
    if (hub == NULL) \{     
        hub = new EventHub;     
        gHub = hub;     
    \}     
    gLock.unlock();     
    
    int32\_t deviceId;     
    int32\_t type;     
    int32\_t scancode, keycode;     
    uint32\_t flags;     
    int32\_t value;     
    nsecs\_t when;     
    bool res = hub->getEvent(&deviceId, &type, &scancode, &keycode,     
            &flags, &value, &when);     
    
    env->SetIntField(event, gInputOffsets.mDeviceId, (jint)deviceId);     
    env->SetIntField(event, gInputOffsets.mType, (jint)type);     
    env->SetIntField(event, gInputOffsets.mScancode, (jint)scancode);     
    env->SetIntField(event, gInputOffsets.mKeycode, (jint)keycode);     
    env->SetIntField(event, gInputOffsets.mFlags, (jint)flags);     
    env->SetIntField(event, gInputOffsets.mValue, value);     
    env->SetLongField(event, gInputOffsets.mWhen,     
                        (jlong)(nanoseconds\_to\_milliseconds(when)));     
    
    return res;     
\}    
static jboolean  
android\_server\_KeyInputQueue\_readEvent(JNIEnv\* env, jobject clazz,  
                                          jobject event)  
\{  
    gLock.lock();  
    sp hub = gHub;  
    if (hub == NULL) \{  
        hub = new EventHub;  
        gHub = hub;  
    \}  
    gLock.unlock();

int32\_t deviceId;  
    int32\_t type;  
    int32\_t scancode, keycode;  
    uint32\_t flags;  
    int32\_t value;  
    nsecs\_t when;  
    bool res = hub->getEvent(&deviceId, &type, &scancode, &keycode,  
            &flags, &value, &when);

env->SetIntField(event, gInputOffsets.mDeviceId, (jint)deviceId);  
    env->SetIntField(event, gInputOffsets.mType, (jint)type);  
    env->SetIntField(event, gInputOffsets.mScancode, (jint)scancode);  
    env->SetIntField(event, gInputOffsets.mKeycode, (jint)keycode);  
    env->SetIntField(event, gInputOffsets.mFlags, (jint)flags);  
    env->SetIntField(event, gInputOffsets.mValue, value);  
    env->SetLongField(event, gInputOffsets.mWhen,  
                        (jlong)(nanoseconds\_to\_milliseconds(when)));

return res;  
\}

readEvent调用hub->getEvent读了取事件，然后转换成JAVA的结构。  
事件中转线程

在frameworks/base/services/java/com/android/server/KeyInputQueue.java 里创建了一个线程，它循环的读取事件，然后把事件放入事件队列里。

Java代码  
Thread mThread = new Thread("InputDeviceReader") \{     
        public void run() \{     
            android.os.Process.setThreadPriority(     
                    android.os.Process.THREAD\_PRIORITY\_URGENT\_DISPLAY);     
    
            try \{     
                RawInputEvent ev = new RawInputEvent();     
                while (true) \{     
                    InputDevice di;     
    
                    readEvent(ev);     
    
                    send = preprocessEvent(di, ev);     
                    addLocked(di, curTime, ev.flags, ..., me);     
                \}     
        \}     
    \};    
Thread mThread = new Thread("InputDeviceReader") \{  
        public void run() \{  
            android.os.Process.setThreadPriority(  
                    android.os.Process.THREAD\_PRIORITY\_URGENT\_DISPLAY);

try \{  
                RawInputEvent ev = new RawInputEvent();  
                while (true) \{  
                    InputDevice di;

readEvent(ev);

send = preprocessEvent(di, ev);  
                    addLocked(di, curTime, ev.flags, ..., me);  
                \}  
        \}  
    \};

输入事件分发线程

在frameworks/base/services/java/com/android/server/WindowManagerService.java里创建了一个输入事件分发线程，它负责把事件分发到相应的窗口上去。

Java代码  
mQueue.getEvent     
dispatchKey/dispatchPointer/dispatchTrackball    
mQueue.getEvent  
dispatchKey/dispatchPointer/dispatchTrackball

**按键,触摸屏流程分析**

按键触摸屏流程分析: 
WindowManagerService类的构造函数 
WindowManagerService() 
  mQueue = new KeyQ(); 
因为 WindowManagerService.java (frameworks/base/services/java/com/android/server)中有：    
private class KeyQ extends KeyInputQueue 
KeyQ 是抽象类  KeyInputQueue 的实现，所以 new KeyQ类的时候实际上在 KeyInputQueue 类中创建了 
一个线程  InputDeviceReader 专门用来冲设备读取按键事件，代码： 
Thread mThread = new Thread("InputDeviceReader") \{ 
  public void run() 
  \{ 
        在循环中调用：readEvent(ev); 
    ... 
    send = preprocessEvent(di, ev); 
        实际调用的是 KeyQ 类的 preprocessEvent 函数 
    ... 
    int keycode = rotateKeyCodeLocked(ev.keycode); 
      int\[\] map = mKeyRotationMap; 
      for (int i=0; i<N; i+=2) 
      \{ 
        if (map\[i\] == keyCode) 
          return map\[i+1\]; 
      \} // 
    addLocked(di, curTime, ev.flags,RawInputEvent.CLASS\_KEYBOARD,newKeyEvent(di, di.mDownTime, curTime, down,keycode, 0, scancode,...)); 
      QueuedEvent ev = obtainLocked(device, when, flags, classType, event); 
  \} 
\}

readEvent() 实际上调用的是 com\_android\_server\_KeyInputQueue.cpp (frameworks/base/services/jni)中的：  
static jboolean android\_server\_KeyInputQueue\_readEvent(JNIEnv\* env, jobject clazz,jobject event)  
  bool res = hub->getEvent(&deviceId, &type, &scancode, &keycode,&flags, &value, &when);  
调用的是 EventHub.cpp (frameworks/base/libs/ui)中的：  
bool EventHub::getEvent(int32\_t\* outDeviceId, int32\_t\* outType,  
        int32\_t\* outScancode, int32\_t\* outKeycode, uint32\_t \*outFlags,  
        int32\_t\* outValue, nsecs\_t\* outWhen)  
在函数中调用了读设备操作：res = read(mFDs\[i\].fd, &iev, sizeof(iev));

在构造函数 WindowManagerService()调用 new KeyQ() 以后接着调用了：  
  mInputThread = new InputDispatcherThread();        
  ...      
  mInputThread.start();  
来启动一个线程  InputDispatcherThread  
run()  
  process();  
    QueuedEvent ev = mQueue.getEvent(...)  
因为WindowManagerService类中： final KeyQ mQueue;  
所以实际上 InputDispatcherThread 线程实际上从  KeyQ 的事件队列中读取按键事件。  
switch (ev.classType)  
  case RawInputEvent.CLASS\_KEYBOARD:  
    ...  
    dispatchKey((KeyEvent)ev.event, 0, 0);  
    mQueue.recycleEvent(ev);  
    break;  
  case RawInputEvent.CLASS\_TOUCHSCREEN:  
    //Log.i(TAG, "Read next event " + ev);  
    dispatchPointer(ev, (MotionEvent)ev.event, 0, 0);  
    break;

===============================================================

KeyInputQueue.java (frameworks/base/services/java/com/android/server):  
的线程  Thread mThread = new Thread("InputDeviceReader") 本地调用：  
readEvent(ev);读取按键。readEvent 调用的是文件：  
com\_android\_server\_KeyInputQueue.cpp (frameworks/base/services/jni)中的函数：  
static jboolean android\_server\_KeyInputQueue\_readEvent(JNIEnv\* env, jobject clazz,  
                                          jobject event)  
android\_server\_KeyInputQueue\_readEvent中有：  
hub = new EventHub;  
bool res = hub->getEvent(&deviceId, &type, &scancode, &keycode,  
            &flags, &value, &when);

hub->getEvent 调用的是  
EventHub.cpp (frameworks/base/libs/ui) 文件中的函数：  
bool EventHub::getEvent(int32\_t\* outDeviceId, int32\_t\* outType,  
        int32\_t\* outScancode, int32\_t\* outKeycode, uint32\_t \*outFlags,  
        int32\_t\* outValue, nsecs\_t\* outWhen)  
读取按键。

class RefBase::weakref\_impl : public RefBase::weakref\_type

在系统启动后，android 会通过  
static const char \*device\_path = "/dev/input";  
bool EventHub::openPlatformInput(void)  
  res = scan\_dir(device\_path);

通过下面的函数打开设备。  
int EventHub::open\_device(const char \*deviceName)  
\{  
  ...  
  fd = open(deviceName, O\_RDWR);  
  ...  
  mFDs\[mFDCount\].fd = fd;  
  mFDs\[mFDCount\].events = POLLIN;  
  ...  
  ioctl(mFDs\[mFDCount\].fd, EVIOCGNAME(sizeof(devname)-1), devname);  
  ...  
  const char\* root = getenv("ANDROID\_ROOT");  
  snprintf(keylayoutFilename, sizeof(keylayoutFilename),  
                 "%s/usr/keylayout/%s.kl", root, tmpfn);  
  ...  
  device->layoutMap->load(keylayoutFilename);  
  ...  
\}  
打开设备的时候，如果 device->classes&CLASS\_KEYBOARD 不等于 0 表明是键盘。  
常用输入设备的定义有：  
enum \{  
        CLASS\_KEYBOARD      = 0x00000001, //键盘  
        CLASS\_ALPHAKEY      = 0x00000002, //  
        CLASS\_TOUCHSCREEN   = 0x00000004, //触摸屏  
        CLASS\_TRACKBALL     = 0x00000008  //轨迹球  
    \};  
打开键盘设备的时候通过上面的  ioctl 获得设备名称，命令字 EVIOCGNAME 的定义在文件：  
kernel/include/linux/input.h 中。  
\#define EVIOCGNAME(len)   \_IOC(\_IOC\_READ, 'E', 0x06, len) /\* get device name \*/  
在内核键盘驱动文件 drivers/input/keyboard/pxa27x\_keypad.c 中定义了设备名称：pxa27x-keypad  
static struct platform\_driver pxa27x\_keypad\_driver = \{  
    .probe        = pxa27x\_keypad\_probe,  
    .remove        = \_\_devexit\_p(pxa27x\_keypad\_remove),  
    .suspend    = pxa27x\_keypad\_suspend,  
    .resume        = pxa27x\_keypad\_resume,  
    .driver        = \{  
        .name    = "pxa27x-keypad",  
        .owner    = THIS\_MODULE,  
    \},  
\};  
ANDROID\_ROOT 为环境变量，在android的命令模式下通过 printenv 可以知道它为： system  
所以 keylayoutFilename 为：/system/usr/keylayout/pxa27x-keypad.kl  
pxa27x-keypad.kl 定义了按键映射，具体内容如下：  
－－－－－－－－－－－－－－－－－－－－－－  
\# NUMERIC KEYS 3x4  
key 2   1  
key 3   2  
key 4   3  
key 5   4  
key 6   5  
key 7   6  
key 8   7  
key 9   8  
key 10  9  
key 11  0  
key 83  POUND  
key 55  STAR

\# FUNCTIONAL KEYS  
key 231  MENU        WAKE\_DROPPED  
key 192  BACK           WAKE\_DROPPED  
key 193  HOME       WAKE  
key 107  DEL        WAKE  
key 102  CALL        WAKE\_DROPPED  
key 158  ENDCALL     WAKE\_DROPPED  
key 28   DPAD\_CENTER     WAKE  
key 115  VOLUME\_UP  
key 114  VOLUME\_DOWN  
－－－－－－－－－－－－－－－－－－－－－－  
如果没有定义键盘映射文件，那么默认使用系统的 /system/usr/keylayout/qwerty.kl  
可以修改 /system/usr/keylayout/qwerty.kl 文件改变Android公司的按键映射。

device->layoutMap->load(keylayoutFilename) 调用的是文件： 
KeyLayoutMap.cpp (frameworks/base/libs/ui)中的函数： 
status\_t KeyLayoutMap::load(const char\* filename)通过解析 pxa27x-keypad.kl 
把按键的映射关系保存在 ：KeyedVector<int32\_t,Key> m\_keys; 中。 
当获得按键事件以后调用： 
status\_t KeyLayoutMap::map(int32\_t scancode, int32\_t \*keycode, uint32\_t \*flags) 
由映射关系 KeyedVector<int32\_t,Key> m\_keys 把扫描码转换成andorid上层可以识别的按键。

本文来自CSDN博客，转载请标明出处：[http://blog.csdn.net/sijiangong/archive/2009/08/04/4407193.aspx][http_blog.csdn.net_sijiangong_archive_2009_08_04_4407193.aspx]

# Android输入事件流程   #

转载时请注明出处和作者联系方式 
文章出处：[http://www.limodev.cn/blog][http_www.limodev.cn_blog] 
作者联系方式：李先静 <xianjimli at hotmail dot com>

EventHub对输入设备进行了封装。输入设备驱动程序对用户空间应用程序提供一些设备文件，这些设备文件放在/dev/input里面。

EventHub扫描/dev/input下所有设备文件，并打开它们。

<table style="width: 90%;"> 
 <tbody> 
 <tr> 
 <td> <pre>bool EventHub::openPlatformInput(void) 
{
 
... 
 mFDCount = 1; 
 mFDs = (pollfd *)calloc(1, sizeof(mFDs[0])); 
 mDevices = (device_t **)calloc(1, sizeof(mDevices[0])); 
 mFDs[0].events = POLLIN; 
 mDevices[0] = NULL; 
 
 res = scan_dir(device_path); 
... 
 return true; 
} 
</pre> </td> 
 </tr> 
 </tbody> 
</table>

EventHub对外提供了一个函数用于从输入设备文件中读取数据。

<table style="width: 90%;"> 
 <tbody> 
 <tr> 
 <td> <pre>bool EventHub::getEvent(int32_t* outDeviceId, int32_t* outType, 
 int32_t* outScancode, int32_t* outKeycode, uint32_t *outFlags, 
 int32_t* outValue, nsecs_t* outWhen) 
{
 
	... 
 while(1) {
 
 
 // First, report any devices that had last been added/removed. 
 if (mClosingDevices != NULL) {
 
 device_t* device = mClosingDevices; 
 LOGV("Reporting device closed: id=0x%x, name=%s/n", 
 device-&gt;id, device-&gt;path.string()); 
 mClosingDevices = device-&gt;next; 
 *outDeviceId = device-&gt;id; 
 if (*outDeviceId == mFirstKeyboardId) *outDeviceId = 0; 
 *outType = DEVICE_REMOVED; 
 delete device; 
 return true; 
 } 
 if (mOpeningDevices != NULL) {
 
 device_t* device = mOpeningDevices; 
 LOGV("Reporting device opened: id=0x%x, name=%s/n", 
 device-&gt;id, device-&gt;path.string()); 
 mOpeningDevices = device-&gt;next; 
 *outDeviceId = device-&gt;id; 
 if (*outDeviceId == mFirstKeyboardId) *outDeviceId = 0; 
 *outType = DEVICE_ADDED; 
 return true; 
 } 
 
 release_wake_lock(WAKE_LOCK_ID); 
 
 pollres = poll(mFDs, mFDCount, -1); 
 
 acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_ID); 
 
 if (pollres &lt;= 0) {
 
 if (errno != EINTR) {
 
 LOGW("select failed (errno=%d)/n", errno); 
 usleep(100000); 
 } 
 continue; 
 } 
 
 for(i = 1; i &lt; mFDCount; i++) {
 
 if(mFDs[i].revents) {
 
 LOGV("revents for %d = 0x%08x", i, mFDs[i].revents); 
 if(mFDs[i].revents &amp; POLLIN) {
 
 res = read(mFDs[i].fd, &amp;iev, sizeof(iev)); 
 if (res == sizeof(iev)) {
 
 LOGV("%s got: t0=%d, t1=%d, type=%d, code=%d, v=%d", 
 mDevices[i]-&gt;path.string(), 
 (int) iev.time.tv_sec, (int) iev.time.tv_usec, 
 iev.type, iev.code, iev.value); 
 *outDeviceId = mDevices[i]-&gt;id; 
 if (*outDeviceId == mFirstKeyboardId) *outDeviceId = 0; 
 *outType = iev.type; 
 *outScancode = iev.code; 
 if (iev.type == EV_KEY) {
 
 err = mDevices[i]-&gt;layoutMap-&gt;map(iev.code, outKeycode, outFlags); 
 LOGV("iev.code=%d outKeycode=%d outFlags=0x%08x err=%d/n", 
 iev.code, *outKeycode, *outFlags, err); 
 if (err != 0) {
 
 *outKeycode = 0; 
 *outFlags = 0; 
 } 
 } else {
 
 *outKeycode = iev.code; 
 } 
 *outValue = iev.value; 
 *outWhen = s2ns(iev.time.tv_sec) + us2ns(iev.time.tv_usec); 
 return true; 
 } else {
 
 if (res&lt;0) {
 
 LOGW("could not get event (errno=%d)", errno); 
 } else {
 
 LOGE("could not get event (wrong size: %d)", res); 
 } 
 continue; 
 } 
 } 
 } 
 } 
	... 
} 
</pre> </td> 
 </tr> 
 </tbody> 
</table>

对于按键事件，调用mDevices\[i\]->layoutMap->map进行映射。映射实际是由 KeyLayoutMap::map完成的，KeyLayoutMap类里读取配置文件qwerty.kl，由配置文件qwerty.kl决定键值的映射 关系。你可以通过修改./development/emulator/keymaps/qwerty.kl来改变键值的映射关系。

**JNI函数**

在frameworks/base/services/jni/com\_android\_server\_KeyInputQueue.cpp文件 中，向JAVA提供了函数android\_server\_KeyInputQueue\_readEvent，用于读取输入设备事件。

<table style="width: 90%;"> 
 <tbody> 
 <tr> 
 <td> <pre>static jboolean 
android_server_KeyInputQueue_readEvent(JNIEnv* env, jobject clazz, 
 jobject event) 
{
 
 gLock.lock(); 
 sp hub = gHub; 
 if (hub == NULL) {
 
 hub = new EventHub; 
 gHub = hub; 
 } 
 gLock.unlock(); 
 
 int32_t deviceId; 
 int32_t type; 
 int32_t scancode, keycode; 
 uint32_t flags; 
 int32_t value; 
 nsecs_t when; 
 bool res = hub-&gt;getEvent(&amp;deviceId, &amp;type, &amp;scancode, &amp;keycode, 
 &amp;flags, &amp;value, &amp;when); 
 
 env-&gt;SetIntField(event, gInputOffsets.mDeviceId, (jint)deviceId); 
 env-&gt;SetIntField(event, gInputOffsets.mType, (jint)type); 
 env-&gt;SetIntField(event, gInputOffsets.mScancode, (jint)scancode); 
 env-&gt;SetIntField(event, gInputOffsets.mKeycode, (jint)keycode); 
 env-&gt;SetIntField(event, gInputOffsets.mFlags, (jint)flags); 
 env-&gt;SetIntField(event, gInputOffsets.mValue, value); 
 env-&gt;SetLongField(event, gInputOffsets.mWhen, 
 (jlong)(nanoseconds_to_milliseconds(when))); 
 
 return res; 
} 
</pre> </td> 
 </tr> 
 </tbody> 
</table>

readEvent调用hub->getEvent读了取事件，然后转换成JAVA的结构。  
  
  
  
  
**o 事件中转线程**

在frameworks/base/services/java/com/android/server/KeyInputQueue.java里创建了一个线程，它循环的读取事件，然后把事件放入事件队列里。

<table style="width: 90%;"> 
 <tbody> 
 <tr> 
 <td> <pre> Thread mThread = new Thread("InputDeviceReader") {
 
 public void run() {
 
 android.os.Process.setThreadPriority( 
 android.os.Process.THREAD_PRIORITY_URGENT_DISPLAY); 
 
 try {
 
 RawInputEvent ev = new RawInputEvent(); 
 while (true) {
 
 InputDevice di; 
 
 readEvent(ev); 
 
 send = preprocessEvent(di, ev); 
 addLocked(di, curTime, ev.flags, ..., me); 
 } 
 } 
 }; 
</pre> </td> 
 </tr> 
 </tbody> 
</table>

**o 输入事件分发线程**

在frameworks/base/services/java/com/android/server/WindowManagerService.java里创建了一个输入事件分发线程，它负责把事件分发到相应的窗口上去。

mQueue.getEvent
    
    dispatchKey/dispatchPointer/dispatchTrackball

[ExpandedBlockStart.gif]: /images/20220709/183363dab09b4be79abdfbfce837f786.png
[http_blog.csdn.net_sijiangong_archive_2009_08_04_4407193.aspx]: http://blog.csdn.net/sijiangong/archive/2009/08/04/4407193.aspx
[http_www.limodev.cn_blog]: http://www.limodev.cn/blog