Android6.0 按键流程 KeyboardInputMapper扫描码转成键盘码 (二)

我们详细分析了InputReader中读取设备事件,到processEventsLocked函数处理事件(包括设备事件,设备添加、删除等),再到ProcessEventsForDeviceLocked处理设备事件,最后到InputDevice的process函数,去遍历各个InputMapper执行process函数。

今天我们继续从这里开始分析,Input设备有很多种类,其消息格式各不相同,因此就有很多InputMapper对各个不同的RawEvent进行处理。

我们今天主要从按键的KeyboardInputMapper来讲解。


一、KeyboardInputMapper

下面我们主要从按键,比如音量键、power键的这个InputMapper说起:

[cpp] view plain copy
  1. void KeyboardInputMapper::process(const RawEvent* rawEvent) {  
  2.     switch (rawEvent->type) {  
  3.           
  4.     case EV_KEY: {  
  5.         int32_t scanCode = rawEvent->code;  
  6.         int32_t usageCode = mCurrentHidUsage;  
  7.         mCurrentHidUsage = 0;  
  8.   
  9.         if (isKeyboardOrGamepadKey(scanCode)) {  
  10.             int32_t keyCode;  
  11.             uint32_t flags;  
  12.             if (getEventHub()->mapKey(getDeviceId(), scanCode, usageCode, &keyCode, &flags)) {//扫描码对应成按键码  
  13.                 keyCode = AKEYCODE_UNKNOWN;  
  14.                 flags = 0;  
  15.             }  
  16.             processKey(rawEvent->when, rawEvent->value != 0, keyCode, scanCode, flags);  
  17.         }  
  18.         break;  
  19.     }  
  20.     case EV_MSC: {  
  21.         if (rawEvent->code == MSC_SCAN) {  
  22.             mCurrentHidUsage = rawEvent->value;  
  23.         }  
  24.         break;  
  25.     }  
  26.     case EV_SYN: {  
  27.         if (rawEvent->code == SYN_REPORT) {  
  28.             mCurrentHidUsage = 0;  
  29.         }  
  30.     }  
  31.     }  
  32. }  


1.1 EventHub的mapKey函数

我们先来看下EventHub的mapKey函数,这个函数中outKeycode是入参,但是传的是指针,会往里面写值。

[cpp] view plain copy
  1. status_t EventHub::mapKey(int32_t deviceId, int32_t scanCode, int32_t usageCode,  
  2.         int32_t* outKeycode, uint32_t* outFlags) const {  
  3.     AutoMutex _l(mLock);  
  4.     Device* device = getDeviceLocked(deviceId);  
  5.   
  6.     if (device) {  
  7.         // Check the key character map first.  
  8.         sp kcm = device->getKeyCharacterMap();  
  9.         if (kcm != NULL) {  
  10.             if (!kcm->mapKey(scanCode, usageCode, outKeycode)) {  
  11.                     scanCode, *outKeycode);  
  12.                 *outFlags = 0;  
  13.                 return NO_ERROR;  
  14.             }  
  15.         }  
  16.   
  17.         // Check the key layout next.  
  18.         if (device->keyMap.haveKeyLayout()) {  
  19.             if (!device->keyMap.keyLayoutMap->mapKey(  
  20.                     scanCode, usageCode, outKeycode, outFlags)) {  
  21.                 return NO_ERROR;  
  22.             }  
  23.         }  
  24.     }  
  25.   
  26.     *outKeycode = 0;  
  27.     *outFlags = 0;  
  28.     return NAME_NOT_FOUND;  
  29. }  
我们看到还是通过device中的成员变量,由此可知肯定是在EventHub的openDeviceLocked函数中,
[cpp] view plain copy
  1. status_t keyMapStatus = NAME_NOT_FOUND;  
  2. if (device->classes & (INPUT_DEVICE_CLASS_KEYBOARD | INPUT_DEVICE_CLASS_JOYSTICK)) {  
  3.     // Load the keymap for the device.  
  4.     keyMapStatus = loadKeyMapLocked(device);  
  5. }  

果然在openDeviceLocked中有上面这段代码。

[cpp] view plain copy
  1. status_t EventHub::loadKeyMapLocked(Device* device) {  
  2.     return device->keyMap.load(device->identifier, device->configuration);  
  3. }  

再来看下load函数,先通过deviceConfiguration获取keyLayoutName,deviceConfiguration肯定也是前面openDeviceLocked的时候创建的,这里就不分析了。

[cpp] view plain copy
  1. status_t KeyMap::load(const InputDeviceIdentifier& deviceIdenfifier,  
  2.         const PropertyMap* deviceConfiguration) {  
  3.     // Use the configured key layout if available.  
  4.     if (deviceConfiguration) {  
  5.         String8 keyLayoutName;  
  6.         if (deviceConfiguration->tryGetProperty(String8("keyboard.layout"),  
  7.                 keyLayoutName)) {//通过deviceConfiguration获取keyLayoutName  
  8.             status_t status = loadKeyLayout(deviceIdenfifier, keyLayoutName);  
  9.             if (status == NAME_NOT_FOUND) {  
  10.                 ALOGE("Configuration for keyboard device '%s' requested keyboard layout '%s' but "  
  11.                         "it was not found.",  
  12.                         deviceIdenfifier.name.string(), keyLayoutName.string());  
  13.             }  
  14.         }  
  15.   
  16.         String8 keyCharacterMapName;  
  17.         if (deviceConfiguration->tryGetProperty(String8("keyboard.characterMap"),  
  18.                 keyCharacterMapName)) {  
  19.             status_t status = loadKeyCharacterMap(deviceIdenfifier, keyCharacterMapName);  
  20.             if (status == NAME_NOT_FOUND) {  
  21.                 ALOGE("Configuration for keyboard device '%s' requested keyboard character "  
  22.                         "map '%s' but it was not found.",  
  23.                         deviceIdenfifier.name.string(), keyLayoutName.string());  
  24.             }  
  25.         }  
  26.   
  27.         if (isComplete()) {  
  28.             return OK;  
  29.         }  
  30.     }  
  31.   
  32.     // Try searching by device identifier.  
  33.     if (probeKeyMap(deviceIdenfifier, String8::empty())) {  
  34.         return OK;  
  35.     }  
  36.   
  37.     // Fall back on the Generic key map.  
  38.     // TODO Apply some additional heuristics here to figure out what kind of  
  39.     //      generic key map to use (US English, etc.) for typical external keyboards.  
  40.     if (probeKeyMap(deviceIdenfifier, String8("Generic"))) {  
  41.         return OK;  
  42.     }  
  43.   
  44.     // Try the Virtual key map as a last resort.  
  45.     if (probeKeyMap(deviceIdenfifier, String8("Virtual"))) {  
  46.         return OK;  
  47.     }  
  48.   
  49.     // Give up!  
  50.     ALOGE("Could not determine key map for device '%s' and no default key maps were found!",  
  51.             deviceIdenfifier.name.string());  
  52.     return NAME_NOT_FOUND;  
  53. }  
我们再来看loadKeyLayout函数
[cpp] view plain copy
  1. status_t KeyMap::loadKeyLayout(const InputDeviceIdentifier& deviceIdentifier,  
  2.         const String8& name) {  
  3.     String8 path(getPath(deviceIdentifier, name,  
  4.             INPUT_DEVICE_CONFIGURATION_FILE_TYPE_KEY_LAYOUT));  
  5.     if (path.isEmpty()) {  
  6.         return NAME_NOT_FOUND;  
  7.     }  
  8.   
  9.     status_t status = KeyLayoutMap::load(path, &keyLayoutMap);  
  10.     if (status) {  
  11.         return status;  
  12.     }  
  13.   
  14.     keyLayoutFile.setTo(path);  
  15.     return OK;  
  16. }  

我们先来分析下getPath函数,看它是如何获取path的

[cpp] view plain copy
  1. String8 KeyMap::getPath(const InputDeviceIdentifier& deviceIdentifier,  
  2.         const String8& name, InputDeviceConfigurationFileType type) {  
  3.     return name.isEmpty()  
  4.             ? getInputDeviceConfigurationFilePathByDeviceIdentifier(deviceIdentifier, type)  
  5.             : getInputDeviceConfigurationFilePathByName(name, type);  
  6. }  

我们再看getInputDeviceConfigurationFilePathByName函数,到system/usr目录下

[cpp] view plain copy
  1. String8 getInputDeviceConfigurationFilePathByName(  
  2.         const String8& name, InputDeviceConfigurationFileType type) {  
  3.     // Search system repository.  
  4.     String8 path;  
  5.     path.setTo(getenv("ANDROID_ROOT"));  
  6.     path.append("/usr/");  
  7.     appendInputDeviceConfigurationFileRelativePath(path, name, type);  
  8. #if DEBUG_PROBE  
  9.     ALOGD("Probing for system provided input device configuration file: path='%s'", path.string());  
  10. #endif  
  11.     if (!access(path.string(), R_OK)) {  
  12. #if DEBUG_PROBE  
  13.         ALOGD("Found");  
  14. #endif  
  15.         return path;  
  16.     }  
再看appendInputDeviceConfigurationFileRelativePath函数
[cpp] view plain copy
  1. static void appendInputDeviceConfigurationFileRelativePath(String8& path,  
  2.         const String8& name, InputDeviceConfigurationFileType type) {  
  3.     path.append(CONFIGURATION_FILE_DIR[type]);  
  4.     for (size_t i = 0; i < name.length(); i++) {  
  5.         char ch = name[i];  
  6.         if (!isValidNameChar(ch)) {  
  7.             ch = '_';  
  8.         }  
  9.         path.append(&ch, 1);  
  10.     }  
  11.     path.append(CONFIGURATION_FILE_EXTENSION[type]);  
  12. }  

CONFIGURATION_FILE_DIR是各个 type对应的各个目录

[cpp] view plain copy
  1. static const char* CONFIGURATION_FILE_DIR[] = {  
  2.         "idc/",  
  3.         "keylayout/",  
  4.         "keychars/",  
  5. };  
而CONFIGURATION_FILE_EXTENSION是各个type对应的文件后缀
[cpp] view plain copy
  1. static const char* CONFIGURATION_FILE_EXTENSION[] = {  
  2.         ".idc",  
  3.         ".kl",  
  4.         ".kcm",  
  5. };  

我们再结合手机里的文件看下:

[html] view plain copy
  1. root@lte26007:/system/usr/keylayout # ls  
  2. ls  
  3. AVRCP.kl  
  4. Generic.kl  
  5. Vendor_0079_Product_0011.kl  
  6. Vendor_045e_Product_028e.kl  
  7. Vendor_046d_Product_b501.kl  
  8. Vendor_046d_Product_c216.kl  
  9. Vendor_046d_Product_c219.kl  
  10. Vendor_046d_Product_c21d.kl  
  11. Vendor_046d_Product_c21f.kl  
  12. Vendor_046d_Product_c294.kl  
  13. Vendor_046d_Product_c299.kl  
  14. Vendor_046d_Product_c532.kl  
  15. Vendor_054c_Product_0268.kl  
  16. Vendor_0583_Product_2060.kl  
  17. Vendor_05ac_Product_0239.kl  
  18. Vendor_0b05_Product_4500.kl  
  19. Vendor_1038_Product_1412.kl  
  20. Vendor_12bd_Product_d015.kl  
  21. Vendor_1532_Product_0900.kl  
  22. Vendor_1689_Product_fd00.kl  
  23. Vendor_1689_Product_fd01.kl  
  24. Vendor_1689_Product_fe00.kl  
  25. Vendor_18d1_Product_2c40.kl  
  26. Vendor_1949_Product_0401.kl  
  27. Vendor_1bad_Product_f016.kl  
  28. Vendor_1bad_Product_f023.kl  
  29. Vendor_1bad_Product_f027.kl  
  30. Vendor_1bad_Product_f036.kl  
  31. Vendor_1d79_Product_0009.kl  
  32. Vendor_22b8_Product_093d.kl  
  33. Vendor_2378_Product_1008.kl  
  34. Vendor_2378_Product_100a.kl  
  35. comip-gpio-keys.kl  
  36. comip-keypad.kl  
  37. ft5x06.kl  
  38. h2w_headset.kl  
  39. qwerty.kl  
  40. sensor00fn11.kl  

我们再来看下Generic.kl这个文件,截取部分如下:扫描码对应的键值。

[html] view plain copy
  1. .....  
  2. key 108   DPAD_DOWN  
  3. key 109   PAGE_DOWN  
  4. key 110   INSERT  
  5. key 111   FORWARD_DEL  
  6. # key 112 "KEY_MACRO"  
  7. key 113   VOLUME_MUTE  
  8. key 114   VOLUME_DOWN  
  9. key 115   VOLUME_UP  
  10. key 116   POWER  
  11. key 117   NUMPAD_EQUALS  
  12. # key 118 "KEY_KPPLUSMIN  
  13. key 119   BREAK  
  14. # key 120 (undefined)  
  15. key 121   NUMPAD_COMMA  
  16. key 122   KANA  
  17. key 123   EISU  
  18. key 124   YEN  
  19. key 125   META_LEFT  
  20. key 126   META_RIGHT  
  21. key 127   MENU  
  22. key 128   MEDIA_STOP  

我们继续看下KeyLayoutMap::load这个函数,这个函数我们就不细说了。

[cpp] view plain copy
  1. status_t KeyLayoutMap::load(const String8& filename, sp* outMap) {  
  2.     outMap->clear();  
  3.   
  4.     Tokenizer* tokenizer;  
  5.     status_t status = Tokenizer::open(filename, &tokenizer);//通过这个函数获取Tokenizer  
  6.     if (status) {  
  7.         ALOGE("Error %d opening key layout map file %s.", status, filename.string());  
  8.     } else {  
  9.         sp map = new KeyLayoutMap();  
  10.         if (!map.get()) {  
  11.             ALOGE("Error allocating key layout map.");  
  12.             status = NO_MEMORY;  
  13.         } else {  
  14. #if DEBUG_PARSER_PERFORMANCE  
  15.             nsecs_t startTime = systemTime(SYSTEM_TIME_MONOTONIC);  
  16. #endif  
  17.             Parser parser(map.get(), tokenizer);//解析  
  18.             status = parser.parse();  
  19. #if DEBUG_PARSER_PERFORMANCE  
  20.             nsecs_t elapsedTime = systemTime(SYSTEM_TIME_MONOTONIC) - startTime;  
  21.             ALOGD("Parsed key layout map file '%s' %d lines in %0.3fms.",  
  22.                     tokenizer->getFilename().string(), tokenizer->getLineNumber(),  
  23.                     elapsedTime / 1000000.0);  
  24. #endif  
  25.             if (!status) {  
  26.                 *outMap = map;  
  27.             }  
  28.         }  
  29.         delete tokenizer;  
  30.     }  
  31.     return status;  
  32. }  


1.2 KeyboardInputMapper的processKey函数

下面我们再来看KeyboardInputMapper::process中的processKey函数

[cpp] view plain copy
  1. void KeyboardInputMapper::processKey(nsecs_t when, bool down, int32_t keyCode,  
  2.         int32_t scanCode, uint32_t policyFlags) {  
  3.   
  4.     if (down) {  
  5.         // Rotate key codes according to orientation if needed.  
  6.         if (mParameters.orientationAware && mParameters.hasAssociatedDisplay) {  
  7.             keyCode = rotateKeyCode(keyCode, mOrientation);  
  8.         }  
  9.   
  10.         // Add key down.  
  11.         ssize_t keyDownIndex = findKeyDown(scanCode);  
  12.         if (keyDownIndex >= 0) {  
  13.             // key repeat, be sure to use same keycode as before in case of rotation  
  14.             keyCode = mKeyDowns.itemAt(keyDownIndex).keyCode;  
  15.         } else {  
  16.             // key down  
  17.             if ((policyFlags & POLICY_FLAG_VIRTUAL)  
  18.                     && mContext->shouldDropVirtualKey(when,  
  19.                             getDevice(), keyCode, scanCode)) {  
  20.                 return;  
  21.             }  
  22.             if (policyFlags & POLICY_FLAG_GESTURE) {  
  23.                 mDevice->cancelTouch(when);  
  24.             }  
  25.   
  26.             mKeyDowns.push();  
  27.             KeyDown& keyDown = mKeyDowns.editTop();  
  28.             keyDown.keyCode = keyCode;  
  29.             keyDown.scanCode = scanCode;  
  30.         }  
  31.   
  32.         mDownTime = when;  
  33.     } else {  
  34.         // Remove key down.  
  35.         ssize_t keyDownIndex = findKeyDown(scanCode);  
  36.         if (keyDownIndex >= 0) {  
  37.             // key up, be sure to use same keycode as before in case of rotation  
  38.             keyCode = mKeyDowns.itemAt(keyDownIndex).keyCode;  
  39.             mKeyDowns.removeAt(size_t(keyDownIndex));  
  40.         } else {  
  41.             // key was not actually down  
  42.             ALOGI("Dropping key up from device %s because the key was not down.  "  
  43.                     "keyCode=%d, scanCode=%d",  
  44.                     getDeviceName().string(), keyCode, scanCode);  
  45.             return;  
  46.         }  
  47.     }  
  48.   
  49.     int32_t oldMetaState = mMetaState;  
  50.     int32_t newMetaState = updateMetaState(keyCode, down, oldMetaState);  
  51.     bool metaStateChanged = oldMetaState != newMetaState;  
  52.     if (metaStateChanged) {  
  53.         mMetaState = newMetaState;  
  54.         updateLedState(false);  
  55.     }  
  56.   
  57.     nsecs_t downTime = mDownTime;  
  58.   
  59.     // Key down on external an keyboard should wake the device.  
  60.     // We don't do this for internal keyboards to prevent them from waking up in your pocket.  
  61.     // For internal keyboards, the key layout file should specify the policy flags for  
  62.     // each wake key individually.  
  63.     // TODO: Use the input device configuration to control this behavior more finely.  
  64.     if (down && getDevice()->isExternal()) {  
  65.         policyFlags |= POLICY_FLAG_WAKE;  
  66.     }  
  67.   
  68.     if (mParameters.handlesKeyRepeat) {  
  69.         policyFlags |= POLICY_FLAG_DISABLE_KEY_REPEAT;  
  70.     }  
  71.   
  72.     if (metaStateChanged) {  
  73.         getContext()->updateGlobalMetaState();  
  74.     }  
  75.   
  76.     if (down && !isMetaKey(keyCode)) {  
  77.         getContext()->fadePointer();  
  78.     }  
  79.   
  80.     NotifyKeyArgs args(when, getDeviceId(), mSource, policyFlags,  
  81.             down ? AKEY_EVENT_ACTION_DOWN : AKEY_EVENT_ACTION_UP,  
  82.             AKEY_EVENT_FLAG_FROM_SYSTEM, keyCode, scanCode, newMetaState, downTime);  
  83.     getListener()->notifyKey(&args);  
  84. }  

这个函数,一开始还是再把扫描码转成键盘码,后面主要调用了notifyKey函数。

getListener函数如下

[cpp] view plain copy
  1. InputListenerInterface* InputReader::ContextImpl::getListener() {  
  2.     return mReader->mQueuedListener.get();  
  3. }  

而notifyKey函数如下,就是把对象放在一个变量中。

[cpp] view plain copy
  1. void QueuedInputListener::notifyKey(const NotifyKeyArgs* args) {  
  2.     mArgsQueue.push(new NotifyKeyArgs(*args));  
  3. }  

二、InputReader的loopOnce函数

最后我们再回到InputReader的loopOnce函数,我们主要看最后mQueuedListener->flush函数。

[cpp] view plain copy
  1. void InputReader::loopOnce() {  
  2.     int32_t oldGeneration;  
  3.     int32_t timeoutMillis;  
  4.     bool inputDevicesChanged = false;  
  5.     Vector inputDevices;  
  6.     { // acquire lock  
  7.         AutoMutex _l(mLock);  
  8.   
  9.         oldGeneration = mGeneration;  
  10.         timeoutMillis = -1;  
  11.   
  12.         uint32_t changes = mConfigurationChangesToRefresh;  
  13.         if (changes) {  
  14.             mConfigurationChangesToRefresh = 0;  
  15.             timeoutMillis = 0;  
  16.             refreshConfigurationLocked(changes);  
  17.         } else if (mNextTimeout != LLONG_MAX) {  
  18.             nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);  
  19.             timeoutMillis = toMillisecondTimeoutDelay(now, mNextTimeout);  
  20.         }  
  21.     } // release lock  
  22.   
  23.     size_t count = mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE);  
  24.   
  25.     { // acquire lock  
  26.         AutoMutex _l(mLock);  
  27.         mReaderIsAliveCondition.broadcast();  
  28.   
  29.         if (count) {  
  30.             processEventsLocked(mEventBuffer, count);  
  31.         }  
  32.   
  33.         if (mNextTimeout != LLONG_MAX) {  
  34.             nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);  
  35.             if (now >= mNextTimeout) {  
  36. #if DEBUG_RAW_EVENTS  
  37.                 ALOGD("Timeout expired, latency=%0.3fms", (now - mNextTimeout) * 0.000001f);  
  38. #endif  
  39.                 mNextTimeout = LLONG_MAX;  
  40.                 timeoutExpiredLocked(now);  
  41.             }  
  42.         }  
  43.   
  44.         if (oldGeneration != mGeneration) {  
  45.             inputDevicesChanged = true;  
  46.             getInputDevicesLocked(inputDevices);  
  47.         }  
  48.     } // release lock  
  49.   
  50.     // Send out a message that the describes the changed input devices.  
  51.     if (inputDevicesChanged) {  
  52.         mPolicy->notifyInputDevicesChanged(inputDevices);  
  53.     }  
  54.   
  55.     // Flush queued events out to the listener.  
  56.     // This must happen outside of the lock because the listener could potentially call  
  57.     // back into the InputReader's methods, such as getScanCodeState, or become blocked  
  58.     // on another thread similarly waiting to acquire the InputReader lock thereby  
  59.     // resulting in a deadlock.  This situation is actually quite plausible because the  
  60.     // listener is actually the input dispatcher, which calls into the window manager,  
  61.     // which occasionally calls into the input reader.  
  62.     mQueuedListener->flush();  
  63. }  

QueuedInputListener::flush函数在文件InputListener.cpp中。

[cpp] view plain copy
  1. void QueuedInputListener::flush() {  
  2.     size_t count = mArgsQueue.size();  
  3.     for (size_t i = 0; i < count; i++) {  
  4.         NotifyArgs* args = mArgsQueue[i];  
  5.         args->notify(mInnerListener);  
  6.         delete args;  
  7.     }  
  8.     mArgsQueue.clear();  
  9. }  

这个函数中遍历之前我们在每个InputMapper存入的NotifyArgs对象,最后调用了NotifyArgs对象的notify函数

之前我们的NotifyArgs对象是NotifyKeyArgs对象,这个notify是个虚函数,就到NotifyKeyArgs::notify

[cpp] view plain copy
  1. void NotifyKeyArgs::notify(const sp& listener) const {  
  2.     listener->notifyKey(this);  
  3. }  

而这个listener,是新建QueuedInputListener的时候传进来的

[cpp] view plain copy
  1. mQueuedListener = new QueuedInputListener(listener);  

listener是InputReader里面传过来的,所以我们知道InputReader是在InputManager中创建的

[cpp] view plain copy
  1. InputReader::InputReader(const sp& eventHub,  
  2.         const sp& policy,  
  3.         const sp& listener) :  

我们看下InputManager的构造函数,传进来的InputDispatcher

[cpp] view plain copy
  1. InputManager::InputManager(  
  2.         const sp& eventHub,  
  3.         const sp& readerPolicy,  
  4.         const sp& dispatcherPolicy) {  
  5.     mDispatcher = new InputDispatcher(dispatcherPolicy);  
  6.     mReader = new InputReader(eventHub, readerPolicy, mDispatcher);  
  7.     initialize();  
  8. }  
所以最后这个listener是InputDispatcher,因此最后就是调用的InputDispatcher的notifyKey函数。

你可能感兴趣的:(Android,基础业务分析,INPUT)