android系统按键从linux到java流程

android系统按键从linux到java流程

概述:

android系统的键值转换，从linux到java共经历3个层次，分别是：

1 linux系统层，原始ir键值读取,转变为linux层键值 2 framework层,linux层键值转换为android键值 3 framework层,android键值上报java层 关系图: InputManager InputReaderThread InputDispatcherThreagetevents() mapkey() framework层: linux层键值转换为android键值 interceptKeyBeforeQueueing() interceptKeyBeforeDispatch ing() linux层: 转变为linux层键值 dev/input 原始ir键值读取,dev/vinput 最终输出：framework层: phonewindowmanger.java framework层: android键值上报java层

剩余疑问：dev/vinput和dev/input之间到底怎么关联的

间造成数据异常；二者由系统负责同步。 后续查到相关资料再补充.

目前没查到这二者是怎么关联的，但是从用户组可以看出，vinput应该是input的输入。 猜测：这二者之间类似一个软连接处理，避免键值读写都在同一个文件，在不同进程之

1 原始ir键值读取,转变为linux层键值 核心输入: 系统启动android_ir_user后台进程 核心输出: 虚拟设备dev/vinput,写入linux键值

1.1 流程图

key.xml:定义原始硬件码值和对应linux层通用键名： < key value =\name=\UTE\> linux_key.h: 定义linux层通用键名和linux层键值的对应关系 {\13} \桥梁 key_pars.c:提供 get_keycode接口，解析key.xml，结合linux_key.h，建立原始码值和linux层键值的映射数组 调用get_keycode 输出dev/vinput： 读取原始码值，根据keyarry转换为linux层键值，通过ReportKeyEvent写入虚拟设备dev/vinput设备,其他进程再从这读取linux键值 系统启动android_ir_user后台进程，执行ir_user.cpp的main入口 keyarry键值全局数组 原始键读取线程ir_sample_thread keyarry：桥梁

1.2转换流程详细说明：

1.2.1/device/hisilicon/bigfish/system/ir_user/key_pars/key.xml: 该文件编译后输出到/etc目录下。

定义原始硬件码值和对应linux层通用键名：

< key value=\

1.2.2/device/hisilicon/bigfish/system/ir_user/key_pars/linux_key.h: 定义linux层通用键名和linux层键值的对应关系： {\

1.2.3/device/hisilicon/bigfish/system/ir_user/key_pars/ key_pars.c: 提供接口get_keycode解析xml建立原始码值和linux层键值的映射数组 get_keycode(_key_arry *keyarry, int keyarry_num)解析： a:调用readXml读取/etc/ key.xml，返回xml根节点：

key.xml中和分别各一个节点，我们的遥控器原始键值配置在中。

b:调用Pars_Key解析每个节点下的所有按键：

解析节点下的所有children节点，通过value属性获取xml定义的原始键值，通过name属性获取xml定义的键名字符串，再调用find_linux_key_code查询这个字符串对应的linux层键值。

把这个映射关系存储到：

keyarry->hi_keycode[keynum].ir_keycode = ir_keycode; keyarry->hi_keycode[keynum].linux_keycode = linux_keycode;

c: find_linux_key_code函数遍历在linux_key.h定义的Linux_KeyCode_Ary数组，找到参数str（即键名字符串）对应的linux层键值。

1.2.4/device/hisilicon/bigfish/system/ir_user/ir_user.cpp: 1)编译为后台进程android_ir_user独立运行；

2)进程启动，执行main入口函数，调用get_keycode完成key.xml存储原始码值和linux层键值的映射关系到数组keyarry；

3)建立ir_sample_thread线程读取原始码值，根据keyarry转换为linux层键值，通过ReportKeyEvent写入dev/vinput设备,其他进程可以读取键值 1.3总结

出差拷机，如果不想其他厂家操作我们的盒子，只需要离开的时候删除/system/bin下面的android_ir_user这个bin文件即可。

113 },

结构linux_keycode_ary类型的数组Linux_KeyCode_Ary[512].

2 linux层键值转换为android键值

核心输入: /dev/input, 输入linux键值

核心输出: 1）getEvents(),输出RawEvent* buffer，存储linux层键值； 2）mapKey(),将linux层键值转换为android键值

2.1流程图

getEvents():,输出RawEvent* buffer mapKey(): 将linux层键值转换为android键值

Vendor_0001_Product _0001.kl： 定义linux键值和对应的键名字符串 key 113 MUTE KeycodeLabels.h： 定义键名字符串和android的java层键值对应关系结构数组KEYCODES： { \Keyboard.cpp： 定位linux到android键第一转换映射文件为Vendor_0001_Product_0001.kl KeyLayoutMap.cpp： 1）解析Vendor_0001_Product_0001.kl，并结合KeycodeLabels.h最终建立里建立linux层键值到android键值 的映射集合map 2）提供mapKey EventHub.cpp： 1 getEvents() 2 mapKey() 1）建立linux层键值到android键值 2）读取/dev/input设备上的 的映射集合map 键值到RawEvent* buffer 2.2详细说明

2.2.1 /device/hisilicon/bigfish/prebuilts/Vendor_0001_Product_0001.kl: 定义linux键值和对应的键名字符串 key 113 MUTE

2.2.2 /frameworks/native/include/input/KeycodeLabels.h

定义键名字符串和android的java层键值对应关系结构数组KEYCODES： { \

2.2.3\\frameworks\\native\\libs\\input\\ Keyboard.cpp

提供函数loadKeyLayout和getPath，定位linux到android键第一转换映射文件为Vendor_0001_Product_0001.kl:

提供函数getKeyCodeByLabel，从KeycodeLabels.h的KEYCODES数组中，查询返回android的java键值。

2.2.4\\frameworks\\native\\libs\\input\\ KeyLayoutMap.cpp

提供函数load和parse等解析Vendor_0001_Product_0001.kl，并调用

Keyboard.cpp的getKeyCodeByLabel，通过“linux键值---键名字符串---android的java层键值”的直接建立“linux键值--- android的java层键值”map集合； 提供函数mapKey基于此集合供上层转换linux键值为android的java键值

2.2.5 \\frameworks\\base\\services\\input\\EventHub.cpp

1 提供getEvents,完成两个事:

1):建立linux键值--- android的java层键值”map集合。 2):扫描linux键值，存储到参数RawEvent* buffer。

2 提供mapKey，调用KeyLayoutMap.cpp的mapKey函数，完成转换linux

键值为android的java键值。

2.2.6关于建立linux键值--- android的java层键值”map集合，代码流程: 1）\\frameworks\\base\\services\\input\\EventHub.cpp a)getEvents（）-> scanDevicesLocked():

b)scanDevicesLocked-> scanDirLocked(): static const char *DEVICE_PATH = \

c)scanDirLocked()->openDeviceLocked()

d) openDeviceLocked()->loadKeyMapLocked()

e) loadKeyMapLocked调用Keyboard.cpp下load()函数:

2）\\frameworks\\native\\libs\\input\\ Keyboard.cpp f) load()->probeKeyMap():

g) probeKeyMap ()->loadKeyLayout():

h) loadKeyLayout()->getPath():

这里才确定path为：./system/usr/keylayout/Vendor_0001_Product_0001.kl 再继续调用KeyLayoutMap::load加载并解析

3） \\frameworks\\native\\libs\\input\\ KeyLayoutMap.cpp i) load()->parse()

j) parse ()->parseKey()

解析Vendor_0001_Product_0001.kl得到linux层code，

再调用getKeyCodeByLabel查询code对应的android层键值keyCode

将两个键值存入map集合

到此完成linux层键值到android的java层键值的转换并存储为map集合；后面真正扫描到 linux键值后，调用mapKey根据存储的map集成转换为android键值进行上报。 2.3总结:

这个部分可以看出，其完全是个中间过程，如果我们要修改某个键在android的表现，完全不用改这其中相关的任何文件，只需要在java层（后面会讲到，keyevent.java）对收到的android键进行再转换即可。

3 Android键值上报java层

核心输入 : eventhub.cpp的getEvents()和mapkey()

核心输出：PhoneWindowManager.java的interceptKeyBeforeQueueing和 interceptKeyBeforeDispatching

3.1流程图

太多，省略....

3.2详细说明

3.2.1\\frameworks\\base\\services\\input\\InputReader.cpp 该文件主要负责： linux按键的读取； 转换为android键值；

通过listener启动按键上报，注意这里仅仅是启动按键上报。 1）InputReader 类构造函数InputReader

两个极其重要的参数:

eventHub和listener，前者用来读取linux键值，后者用来分发上报按键。

说明：

参数eventHub，赋值给变量mEventHub；listener作为参数创建了mQueuedListener。 2) loopOnce函数及其调用的一连串函数

调用mEventHub->getEvents读取linux按键到RawEvent 类型的mEventBuffer成员变量；

调用processEventsLocked分发上报。

3）重点阐述processEventsLocked是如何分发上报按键的： a)processEventsLocked调用processEventsForDeviceLocked

b) processEventsForDeviceLocked从InputReader 的（InputDevice类型）变量mDevices变量中找出当前对应的device，调用其process

c) process调用InputDevice的变量(InputMapper类型)mMappers的process函数

d)这里的mapper是KeyboardInputMapper类

这里process开始调用eventhub类的mapKey()启动参数rawEvent中的linux键值scanCode的转换,变为android键值keyCode，继续调用processKey上传.

e) processKey调用 getListener()->notifyKey(&args); 完成键值上报到其他模块

注意这里的getListener就是取得inputreader类初始化时用参数“const sp& listener”初始化的mQueuedListener。

到这里，inputread.cpp模块的按键分发上报全部完成，后续只要搞清楚

sp& listener”到底是谁，就知道按键分发到哪里去了。

4）阐述按键分发中的关键衔接一环：

上述C)步的mMappers是如何和KeyboardInputMapper关联的？ 为什么KeyboardInputMapper的getListener()是inputreader的mQueuedListener？

仍然是从loopOnce 调用processEventsLocked开始：

a) processEventsLocked找不到按键rawEvents的设备来源时调用addDeviceLocked：

b) addDeviceLocked调用createDeviceLocked：

(所以上面第3）点钟的B）步能找到有效的device) c) createDeviceLocked调用device->addMapper

到这里就完成了inputreadr----inputdevice---mappers的关联.

getListener的来源：

InputReader构造函数用参数sp& listener创建了mQueuedListener对象实例，mQueuedListener是InputReader的成员变量； mContext也是InputReader对象的成员，其类型是InputReader的内部类ContextImpl，该类继承自InputReaderContext，ContextImpl的getListener函数直接返回mQueuedListener。

createDeviceLocked在 添加inputdevice设备时，使用mContext转换为InputReaderContext作为参数创建了device，直接赋值给inpudevice的成员变量mContext。

createDeviceLocked继续addMapper创建了KeyboardInputMapper实例,即(new KeyboardInputMapper(device, keyboardSource, keyboardType)); device用于创建InputMapper对象，device的mContext成员赋值给InputMapper的mContext；KeyboardInputMapper又继承自InputMapper。

所以KeyboardInputMapper的成员mContext等价于InputReader的mContext；getListener等价于调用InputReader的mContext->getListener即mQueuedListener。 5）InputReaderThread线程类

构造函数InputReaderThread使用InputReader 类对象作为参数，赋值给变量mReader。

threadLoop方法中调用mReader->loopOnce();

只要创建了InputReader实例，并以此启动InputReaderThread线程，就会反复mEventHub->getEvents读键和调用processEventsLocked分发上报。

3.2.2\\frameworks\\base\\services\\input\\InputDispatcher.cpp

该文件是真正的按键数据上报的起点，InputReader中的listener实际就是这个InputDispatcher，该类继承自接口InputDispatcherInterface。 完成3个事情:

interceptKeyBeforeQueueing,按键入列前的截获处理

interceptKeyBeforeDispatching，按键从队列分发上层app前的截获处理 startDispatchCycleLocked，完成按键最终分发上报 1）InputDispatcher类

a)构造函数以参数policy直接初始化成员变量mpolicy。

b) notifyKey函数被之前的inputreader调用，notifyKey调用interceptKeyBeforeQueueing

进行第一次按键上报，供上层截获按键，在按键被压入队列前进行必要的处理，如设置，桌面等在keyfuntion.xml中配置的快捷键，或待机键等的处理。

到这里完成按键进入Queue队列前的上报处理，如果interceptKeyBeforeQueueing没有处理这个按键，将会继续调用步骤c)。

c) enqueueInboundEventLocked将按键结构参数entry压入队列

d) InputDispatcherThread线程类不断循环，检测到队列中的按键 InputDispatcherThread调用InputDispatcher的dispatchOnce。

e) dispatchOnce调用dispatchOnceInnerLocked

f) dispatchOnceInnerLocked调用dispatchKeyLocked

g) dispatchKeyLocked调用

doInterceptKeyBeforeDispatchingLockedInterruptible

h) doInterceptKeyBeforeDispatchingLockedInterruptible调用 mPolicy->interceptKeyBeforeDispatching

到这里完成进入队列的按键在上报app前的截获处理,比如特殊处理home键，添加工装菜单的按键调用等,如果这些按键仍然没被截获，将继续进行分发，继续下面的步骤i). i) dispatchKeyLocked调用addMonitoringTargetsLocked，获取所有上层注册过需要按键的channel,创建目标通道集合inputTargets； 继续调用dispatchEventLocked开始按键分发。

j) dispatchEventLocked对每一个通道获取其connection,再调用prepareDispatchCycleLocked

k) prepareDispatchCycleLocked调用enqueueDispatchEntriesLocked l) enqueueDispatchEntriesLocked调用enqueueDispatchEntryLocked把按键eventEntry和目标通道inputTarget写入connection 再调用startDispatchCycleLocked开始分发

m) startDispatchCycleLocked调用connection->inputPublisher.publishKeyEvent完成最终分发按键。

2）InputDispatcherThread线程类

构造函数InputDispatcherThread使用InputDispatcherInterface类对象作为参数，赋值给变量mDispatcher。

threadLoop方法中调用mDispatcher->dispatchOnce();

只要创建了mDispatcher实例，并以此启动InputReaderThread线程，就会反复mDispatcher->dispatchOnce()，完成按键分发。

3.2.3\\ frameworks\\base\\services\\input\\InputManager.cpp

该文件负责启动前面阐述的InputReader和InputDispatcher。

1）创建InputReader和InputDispatcher实例，初始化到mDispatcher和mReader。

2)创建InputReaderThread和InputDispatcherThread两个线程

3）启动线程循环运行start

3.2.4 \\frameworks\\base\\services\\jni\\

com_android_server_input_InputManagerService.cpp (InputManagerService.java的JNI)

1）nativeInit()调用NativeInputManager()，后者调用new

InputManager(eventHub, this, this);完成创建InputManager对象的实例mInputManager。

//////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////

NativeInputManager 是多重继承，其父类之一为虚类自己；

InputDispatcherPolicyInterface,所以最后一个this参数实际就是NativeInputManager InputManager运行InputDispatcher，后者调用的interceptKeyBeforeQueueing和

interceptKeyBeforeDispatching 实际就是NativeInputManager的同名函数。

也就是说从JNI初始化InputManager，启动InputReader和InputDispatcher，而InputDispatcher最终回调JNI的interceptKeyBeforeQueueing和

interceptKeyBeforeDispatching完成按键截获处理。

2）nativeStart调用mInputManager的start启动两个线程InputReaderThread

和InputDispatcherThread.

本文来源：https://www.bwwdw.com/article/opk6.html