执行getevent可以看到上报到/dev/input/eventX设备节点的各种事件，下面是点击了power键输出，0074是system上报的scancode，可以在system/usr/keylayout/mtk-kpd.kl中找到，74是16进制，刚好对应116，Linux input子系统负责读取/dev/input/eventX所有设备节点的事件封装成NotifyKeyArgs,再由InputDispatcher分发给上层应用。
djtang:/data1/localProject/Tokyo_TF$adb shell
Seoul_TF:/ $ getevent
add device 1: /dev/input/event2
name: "mtk-tpd"
add device 2: /dev/input/event0
name: "ACCDET"
add device 3: /dev/input/event1
name: "mtk-kpd"
/dev/input/event1: 0001 0074 00000001
/dev/input/event1: 0000 0000 00000000
/dev/input/event1: 0001 0074 00000000
/dev/input/event1: 0000 0000 00000000
Seoul_TF:/ $ cat system/usr/keylayout/mtk-kpd.kl |grep -i power
key 116 POWER
Seoul_TF:/ $
SystemServer进程创建InputManagerService服务并注册到ServiceManager
frameworks/base/services/java/com/android/server/SystemServer.java
private void startOtherServices() {
......
traceBeginAndSlog("StartInputManagerService");
inputManager = new InputManagerService(context);
traceEnd();
traceBeginAndSlog("StartWindowManagerService");
// WMS needs sensor service ready
ConcurrentUtils.waitForFutureNoInterrupt(mSensorServiceStart, START_SENSOR_SERVICE);
mSensorServiceStart = null;
wm = WindowManagerService.main(context, inputManager, !mFirstBoot, mOnlyCore,
new PhoneWindowManager(), mActivityManagerService.mActivityTaskManager);
ServiceManager.addService(Context.WINDOW_SERVICE, wm, /* allowIsolated= */ false,
DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PROTO);
ServiceManager.addService(Context.INPUT_SERVICE, inputManager,/* allowIsolated= */ false, DUMP_FLAG_PRIORITY_CRITICAL)
traceEnd();
traceBeginAndSlog("StartInputManager"); inputManager.setWindowManagerCallbacks(wm.getInputManagerCallback());
inputManager.start();
......
}
frameworks/base/services/core/java/com/android/server/input/InputManagerService.java
// Pointer to native input manager service object.
private final long mPtr;
public InputManagerService(Context context) {
this.mContext = context;
this.mHandler = new InputManagerHandler(DisplayThread.get().getLooper());
mUseDevInputEventForAudioJack = context.getResources().getBoolean(R.bool.config_useDevInputEventForAudioJack);
mPtr = nativeInit(this, mContext, mHandler.getLooper().getQueue());
......
}
InputManagerService的构造方法调用了nativeInit方法,创建了一个NativeInputManager
/frameworks/base/services/core/jni/com_android_server_input_InputManagerService.cpp
1317 static jlong nativeInit(JNIEnv* env, jclass /* clazz */,
1318 jobject serviceObj, jobject contextObj, jobject messageQueueObj) {
1319 sp<MessageQueue> messageQueue = android_os_MessageQueue_getMessageQueue(env, messageQueueObj);
1320 if (messageQueue == nullptr) {
1321 jniThrowRuntimeException(env, "MessageQueue is not initialized.");
1322 return 0;
1323 }
1324 //用java层传下来的InputManagerService,context,以及Looper创建NativeInputManager对象，共用同一个Looper
1325 NativeInputManager* im = new NativeInputManager(contextObj, serviceObj,
1326 messageQueue->getLooper());
1327 im->incStrong(0);
1328 return reinterpret_cast<jlong>(im);
1329 }
NativeInputMnager构造函数中创建了InputManager对象并添加到Native层的ServiceManager，叫"inputflinger"
/frameworks/base/services/core/jni/com_android_server_input_InputManagerService.cpp
333 NativeInputManager::NativeInputManager(jobject contextObj,
334 jobject serviceObj, const sp<Looper>& looper) :
335 mLooper(looper), mInteractive(true) {
336 JNIEnv* env = jniEnv();
338 mServiceObj = env->NewGlobalRef(serviceObj);
340 {
341 AutoMutex _l(mLock);
342 mLocked.systemUiVisibility = ASYSTEM_UI_VISIBILITY_STATUS_BAR_VISIBLE;
343 mLocked.pointerSpeed = 0;
344 mLocked.pointerGesturesEnabled = true;
345 mLocked.showTouches = false;
346 mLocked.pointerCapture = false;
347 mLocked.pointerDisplayId = ADISPLAY_ID_DEFAULT;
348 }
349 mInteractive = true;
351 mInputManager = new InputManager(this, this);
352 defaultServiceManager()->addService(String16("inputflinger"),
353 mInputManager, false);
354 }
InputManager中创建了一个InputDispatcher和一个InputReader
/frameworks/native/services/inputflinger/InputManager.cpp
33 InputManager::InputManager(
34 const sp<InputReaderPolicyInterface>& readerPolicy,
35 const sp<InputDispatcherPolicyInterface>& dispatcherPolicy) {
36 mDispatcher = new InputDispatcher(dispatcherPolicy);
37 mClassifier = new InputClassifier(mDispatcher);
//创建InputReader
38 mReader = createInputReader(readerPolicy, mClassifier);
39 initialize();
40 }
/frameworks/native/services/inputflinger/InputReaderFactory.cpp
22 sp<InputReaderInterface> createInputReader(
23 const sp<InputReaderPolicyInterface>& policy,
24 const sp<InputListenerInterface>& listener) {
//参数中传入了一个EventHub
25 return new InputReader(new EventHub(), policy, listener);
26 }
之后调用initialize方法初始化了两个线程InputReaderThread和InputDispatcherThread
46 void InputManager::initialize() {
47 mReaderThread = new InputReaderThread(mReader);
48 mDispatcherThread = new InputDispatcherThread(mDispatcher);
49 }
到这里java层的InputManagerService构造函数中的nativeInit方法执行完了,
再看SystemServer在创建完InputManagerService之后会调用inputManager.start();
/frameworks/base/services/core/java/com/android/server/input/InputManagerService.java
337 public void start() {
338 Slog.i(TAG, "Starting input manager");
339 nativeStart(mPtr);
340 ......
360 }
看native层的实现
/frameworks/base/services/core/jni/com_android_server_input_InputManagerService.cpp
1331 static void nativeStart(JNIEnv* env, jclass /* clazz */, jlong ptr) {
1332 NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
1333 //调用InputManager的start方法
1334 status_t result = im->getInputManager()->start();
1335 if (result) {
1336 jniThrowRuntimeException(env, "Input manager could not be started.");
1337 }
1338 }
im->getInputManager()->start(),这个方法主要就是启动两个线程mDispatcherThread->run和mReaderThread->run
51 status_t InputManager::start() {
52 status_t result = mDispatcherThread->run("InputDispatcher", PRIORITY_URGENT_DISPLAY);
53 if (result) {
54 ALOGE("Could not start InputDispatcher thread due to error %d.", result);
55 return result;
56 }
58 result = mReaderThread->run("InputReader", PRIORITY_URGENT_DISPLAY);
59 if (result) {
60 ALOGE("Could not start InputReader thread due to error %d.", result);
62 mDispatcherThread->requestExit();
63 return result;
64 }
66 return OK;
67 }
接着看InputReaderThread启动之后做了什么
/frameworks/native/services/inputflinger/InputReaderBase.cpp
45 bool InputReaderThread::threadLoop() {
46 mReader->loopOnce();
47 return true;
48 }
省略了一些代码，mEventHub->getEvents读取事件，processEventsLocked处理事件，先看读取事件，传入了一个mEventBuffer和EVENT_BUFFER_SIZE，mEventBuffer放原始事件的数组大小256
/frameworks/native/services/inputflinger/InputReader.cpp
321 void InputReader::loopOnce() {
322 int32_t oldGeneration;
323 int32_t timeoutMillis;
324 bool inputDevicesChanged = false;
......
343 size_t count = mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE);
344
345 { // acquire lock
346 AutoMutex _l(mLock);
347 mReaderIsAliveCondition.broadcast();
349 if (count) {
350 processEventsLocked(mEventBuffer, count);
351 }
......
383 }
/frameworks/native/services/inputflinger/InputReader.h
193 // The event queue.
194 static const int EVENT_BUFFER_SIZE = 256;
195 RawEvent mEventBuffer[EVENT_BUFFER_SIZE];
mEventHub->getEvents
/frameworks/native/services/inputflinger/EventHub.cpp
851 size_t EventHub::getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSize) {
852 ALOG_ASSERT(bufferSize >= 1);
854 AutoMutex _l(mLock);
//放事件的数组
856 struct input_event readBuffer[bufferSize];
857 //原始事件
858 RawEvent* event = buffer;
859 size_t capacity = bufferSize;
860 bool awoken = false;
861 for (;;) {
862 nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
863 ......
875 // Report any devices that had last been added/removed.
876 while (mClosingDevices) {
877 ......
893 if (mNeedToScanDevices) {
894 mNeedToScanDevices = false;
//打开dev/input/设备节点
895 scanDevicesLocked();
896 mNeedToSendFinishedDeviceScan = true;
897 }
......
// This must be an input event
981 if (eventItem.events & EPOLLIN) {
//不断读取事件放入readBuffer
982 int32_t readSize = read(device->fd, readBuffer,
983 sizeof(struct input_event) * capacity);
984 if (readSize == 0 || (readSize < 0 && errno == ENODEV)) {
988 device->fd, readSize, bufferSize, capacity, errno);
989 deviceChanged = true;
990 closeDeviceLocked(device);
991 } else if (readSize < 0) {
992 if (errno != EAGAIN && errno != EINTR) {
993 ALOGW("could not get event (errno=%d)", errno);
994 }
995 } else if ((readSize % sizeof(struct input_event)) != 0) {
996 ALOGE("could not get event (wrong size: %d)", readSize);
997 } else {
998 int32_t deviceId = device->id == mBuiltInKeyboardId ? 0 : device->id;
1000 size_t count = size_t(readSize) / sizeof(struct input_event);
1001 for (size_t i = 0; i < count; i++) {
//从readBuffer中取出全部读到的事件，封装成RawEvent
1002 struct input_event& iev = readBuffer[i];
1003 event->when = processEventTimestamp(iev);
1004 event->deviceId = deviceId;
1005 event->type = iev.type;
1006 event->code = iev.code;
1008 ......
1022 }
1023 }
上面的mEventHub->getEvents主要做的事有，打开设备节点/dev/input/，不断的读取事件，放入readBuffer，再将readBuffer中的所有input_event封装成RawEvent
52 struct RawEvent {
53 nsecs_t when;
54 int32_t deviceId;
55 int32_t type;
56 int32_t code;
57 int32_t value;
58 };
接着对获取到的RawEvent开始处理
/frameworks/native/services/inputflinger/EventHub.cpp
343 size_t count = mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE);
344
345 { // acquire lock
346 AutoMutex _l(mLock);
347 mReaderIsAliveCondition.broadcast();
348
349 if (count) {
350 processEventsLocked(mEventBuffer, count);
351 }
//正式处理事件
385 void InputReader::processEventsLocked(const RawEvent* rawEvents, size_t count) {
386 for (const RawEvent* rawEvent = rawEvents; count;) {
387 int32_t type = rawEvent->type;
388 size_t batchSize = 1;
389 if (type < EventHubInterface::FIRST_SYNTHETIC_EVENT) {
390 int32_t deviceId = rawEvent->deviceId;
391 while (batchSize < count) {
392 if (rawEvent[batchSize].type >= EventHubInterface::FIRST_SYNTHETIC_EVENT
393 || rawEvent[batchSize].deviceId != deviceId) {
394 break;
395 }
396 batchSize += 1;
397 }
//具体事件处理
401 processEventsForDeviceLocked(deviceId, rawEvent, batchSize);
402 } else {
403 switch (rawEvent->type) {
404 case EventHubInterface::DEVICE_ADDED:
405 addDeviceLocked(rawEvent->when, rawEvent->deviceId);
406 break;
407 case EventHubInterface::DEVICE_REMOVED:
408 removeDeviceLocked(rawEvent->when, rawEvent->deviceId);
409 break;
410 case EventHubInterface::FINISHED_DEVICE_SCAN:
411 handleConfigurationChangedLocked(rawEvent->when);
412 break;
413 default:
414 ALOG_ASSERT(false); // can't happen
415 break;
416 }
417 }
418 count -= batchSize;
419 rawEvent += batchSize;
420 }
421 }
具体看processEventsForDeviceLocked函数
557 void InputReader::processEventsForDeviceLocked(int32_t deviceId,
558 const RawEvent* rawEvents, size_t count) {
559 ssize_t deviceIndex = mDevices.indexOfKey(deviceId);
560 if (deviceIndex < 0) {
561 ALOGW("Discarding event for unknown deviceId %d.", deviceId);
562 return;
563 }
565 InputDevice* device = mDevices.valueAt(deviceIndex);
566 if (device->isIgnored()) {
567 //ALOGD("Discarding event for ignored deviceId %d.", deviceId);
568 return;
569 }
570 //事件继续传递
571 device->process(rawEvents, count);
572 }
接着看device->process，device是InputDevice
/frameworks/native/services/inputflinger/InputReader.cpp
1167 void InputDevice::process(const RawEvent* rawEvents, size_t count) {
1168 // Process all of the events in order for each mapper.
1169 // We cannot simply ask each mapper to process them in bulk because mappers may
1170 // have side-effects that must be interleaved. For example, joystick movement events and
1171 // gamepad button presses are handled by different mappers but they should be dispatched
1172 // in the order received.
1173 for (const RawEvent* rawEvent = rawEvents; count != 0; rawEvent++) {
1180 if (mDropUntilNextSync) {
1181 if (rawEvent->type == EV_SYN && rawEvent->code == SYN_REPORT) {
1182 mDropUntilNextSync = false;
......
1190 }
1191 } else if (rawEvent->type == EV_SYN && rawEvent->code == SYN_DROPPED) {
1192 ALOGI("Detected input event buffer overrun for device %s.", getName().c_str());
1193 mDropUntilNextSync = true;
1194 reset(rawEvent->when);
1195 } else {
1196 for (InputMapper* mapper : mMappers) {
1197 mapper->process(rawEvent);
1198 }
1199 }
1200 --count;
1201 }
1202 }
上面函数主要是将RawEvents中的所有事件拿出来调用
mapper->process(rawEvent);
让mMappers里面的所有InputMapper都能对事件进行处理,mMappers中添加了各种类型的InputMapper，这就是根据事件的类型来的，键盘事件，触摸事件等
/frameworks/native/services/inputflinger/InputReader.cpp
1098 void InputDevice::addMapper(InputMapper* mapper) {
1099 mMappers.push_back(mapper);
1100 }
482 InputDevice* InputReader::createDeviceLocked(int32_t deviceId, int32_t controllerNumber,
483 const InputDeviceIdentifier& identifier, uint32_t classes) {
496 .......
497 // Switch-like devices.
498 if (classes & INPUT_DEVICE_CLASS_SWITCH) {
499 device->addMapper(new SwitchInputMapper(device));
500 }
502 // Scroll wheel-like devices.
503 if (classes & INPUT_DEVICE_CLASS_ROTARY_ENCODER) {
504 device->addMapper(new RotaryEncoderInputMapper(device));
505 }
507 // Vibrator-like devices.
508 if (classes & INPUT_DEVICE_CLASS_VIBRATOR) {
509 device->addMapper(new VibratorInputMapper(device));
510 }
515 ......
528 if (keyboardSource != 0) {
529 device->addMapper(new KeyboardInputMapper(device, keyboardSource, keyboardType));
530 }
532 // Cursor-like devices.
533 if (classes & INPUT_DEVICE_CLASS_CURSOR) {
534 device->addMapper(new CursorInputMapper(device));
535 }
537 // Touchscreens and touchpad devices.
538 if (classes & INPUT_DEVICE_CLASS_TOUCH_MT) {
539 device->addMapper(new MultiTouchInputMapper(device));
540 } else if (classes & INPUT_DEVICE_CLASS_TOUCH) {
541 device->addMapper(new SingleTouchInputMapper(device));
542 }
544 // Joystick-like devices.
545 if (classes & INPUT_DEVICE_CLASS_JOYSTICK) {
546 device->addMapper(new JoystickInputMapper(device));
547 }
549 // External stylus-like devices.
550 if (classes & INPUT_DEVICE_CLASS_EXTERNAL_STYLUS) {
551 device->addMapper(new ExternalStylusInputMapper(device));
552 }
554 return device;
555 }
我们基于按键事件进行分析，使用的KeyboardInputMapper
/frameworks/native/services/inputflinger/InputReader.cpp
2331 void KeyboardInputMapper::process(const RawEvent* rawEvent) {
2332 switch (rawEvent->type) {
2333 case EV_KEY: {
2334 int32_t scanCode = rawEvent->code;
2335 int32_t usageCode = mCurrentHidUsage;
2336 mCurrentHidUsage = 0;
2337
2338 if (isKeyboardOrGamepadKey(scanCode)) {
2339 processKey(rawEvent->when, rawEvent->value != 0, scanCode, usageCode);
2340 }
2341 break;
2342 }
2343 case EV_MSC: {
2344 if (rawEvent->code == MSC_SCAN) {
2345 mCurrentHidUsage = rawEvent->value;
2346 }
2347 break;
2348 }
2349 case EV_SYN: {
2350 if (rawEvent->code == SYN_REPORT) {
2351 mCurrentHidUsage = 0;
2352 }
2353 }
2354 }
2355 }
看这个方法processKey
/frameworks/native/services/inputflinger/InputReader.cpp
2393 void KeyboardInputMapper::processKey(nsecs_t when, bool down, int32_t scanCode,
2394 int32_t usageCode) {
2395 int32_t keyCode;
2396 int32_t keyMetaState;
2397 uint32_t policyFlags;
2398 //该方法里面会根据/dev/input/eventX获取到的scancode得到keycode
2399 if (getEventHub()->mapKey(getDeviceId(), scanCode, usageCode, mMetaState,
2400 &keyCode, &keyMetaState, &policyFlags)) {
2401 keyCode = AKEYCODE_UNKNOWN;
2402 keyMetaState = mMetaState;
2403 policyFlags = 0;
2404 }
2406 if (down) {
2407 .......
2472 ......
2473 //创建NotifyKeyArgs
2474 NotifyKeyArgs args(mContext->getNextSequenceNum(), when, getDeviceId(), mSource,
2475 getDisplayId(), policyFlags, down ? AKEY_EVENT_ACTION_DOWN : AKEY_EVENT_ACTION_UP,
2476 AKEY_EVENT_FLAG_FROM_SYSTEM, keyCode, scanCode, keyMetaState, downTime);
//调用InputDispatcher将NotifyKeyArgs分发出去
2477 getListener()->notifyKey(&args);
2478 }
该方法主要做的事，将scancode映射为keycode，创建NotifyKeyArgs，调用InputDispatcher的notifyKey进行进一步事件分发
这篇文章还有很多细节没有分析，只是从一个大概来看InputReader是如何读取事件，封装事件，然后给到InputDispatcher的，后续会对InputDispatcher进行分析
