Android应用程序键盘（Keyboard）消息处理机制分析（4）-低调大师

Android应用程序键盘（Keyboard）消息处理机制分析（4）

2017-11-13 580

Step 18. EventHub.getEvent

这个函数定义在frameworks/base/libs/ui/EventHub.cpp文件中：

 
  bool EventHub::getEvent(RawEvent* outEvent)  
{  
    outEvent->deviceId = 0;  
    outEvent->type = 0;  
    outEvent->scanCode = 0;  
    outEvent->keyCode = 0;  
    outEvent->flags = 0;  
    outEvent->value = 0;  
    outEvent->when = 0;  
  
    // Note that we only allow one caller to getEvent(), so don't need  
    // to do locking here...  only when adding/removing devices.  
  
    if (!mOpened) {  
        mError = openPlatformInput() ? NO_ERROR : UNKNOWN_ERROR;  
        mOpened = true;  
        mNeedToSendFinishedDeviceScan = true;  
    }  
  
    for (;;) {  
        // 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;  
            if (device->id == mFirstKeyboardId) {  
                outEvent->deviceId = 0;  
            } else {  
                outEvent->deviceId = device->id;  
            }  
            outEvent->type = DEVICE_REMOVED;  
            outEvent->when = systemTime(SYSTEM_TIME_MONOTONIC);  
            delete device;  
            mNeedToSendFinishedDeviceScan = true;  
            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;  
            if (device->id == mFirstKeyboardId) {  
                outEvent->deviceId = 0;  
            } else {  
                outEvent->deviceId = device->id;  
            }  
            outEvent->type = DEVICE_ADDED;  
            outEvent->when = systemTime(SYSTEM_TIME_MONOTONIC);  
            mNeedToSendFinishedDeviceScan = true;  
            return true;  
        }  
  
        if (mNeedToSendFinishedDeviceScan) {  
            mNeedToSendFinishedDeviceScan = false;  
            outEvent->type = FINISHED_DEVICE_SCAN;  
            outEvent->when = systemTime(SYSTEM_TIME_MONOTONIC);  
            return true;  
        }  
  
        // Grab the next input event.  
        for (;;) {  
            // Consume buffered input events, if any.  
            if (mInputBufferIndex < mInputBufferCount) {  
                const struct input_event& iev = mInputBufferData[mInputBufferIndex++];  
                const device_t* device = mDevices[mInputDeviceIndex];  
  
                LOGV("%s got: t0=%d, t1=%d, type=%d, code=%d, v=%d", device->path.string(),  
                    (int) iev.time.tv_sec, (int) iev.time.tv_usec, iev.type, iev.code, iev.value);  
                if (device->id == mFirstKeyboardId) {  
                    outEvent->deviceId = 0;  
                } else {  
                    outEvent->deviceId = device->id;  
                }  
                outEvent->type = iev.type;  
                outEvent->scanCode = iev.code;  
                if (iev.type == EV_KEY) {  
                    status_t err = device->layoutMap->map(iev.code,  
                        & outEvent->keyCode, & outEvent->flags);  
                    LOGV("iev.code=%d keyCode=%d flags=0x%08x err=%d\n",  
                        iev.code, outEvent->keyCode, outEvent->flags, err);  
                    if (err != 0) {  
                        outEvent->keyCode = AKEYCODE_UNKNOWN;  
                        outEvent->flags = 0;  
                    }  
                } else {  
                    outEvent->keyCode = iev.code;  
                }  
                outEvent->value = iev.value;  
  
                // Use an event timestamp in the same timebase as  
                // java.lang.System.nanoTime() and android.os.SystemClock.uptimeMillis()  
                // as expected by the rest of the system.  
                outEvent->when = systemTime(SYSTEM_TIME_MONOTONIC);  
                return true;  
            }  
  
            // Finish reading all events from devices identified in previous poll().  
            // This code assumes that mInputDeviceIndex is initially 0 and that the  
            // revents member of pollfd is initialized to 0 when the device is first added.  
            // Since mFDs[0] is used for inotify, we process regular events starting at index 1.  
            mInputDeviceIndex += 1;  
            if (mInputDeviceIndex >= mFDCount) {  
                break;  
            }  
  
            const struct pollfd& pfd = mFDs[mInputDeviceIndex];  
            if (pfd.revents & POLLIN) {  
                int32_t readSize = read(pfd.fd, mInputBufferData,  
                    sizeof(struct input_event) * INPUT_BUFFER_SIZE);  
                if (readSize < 0) {  
                    if (errno != EAGAIN && errno != EINTR) {  
                        LOGW("could not get event (errno=%d)", errno);  
                    }  
                } else if ((readSize % sizeof(struct input_event)) != 0) {  
                    LOGE("could not get event (wrong size: %d)", readSize);  
                } else {  
                    mInputBufferCount = readSize / sizeof(struct input_event);  
                    mInputBufferIndex = 0;  
                }  
            }  
        }  
  
        ......  
  
        mInputDeviceIndex = 0;  
  
        // Poll for events.  Mind the wake lock dance!  
        // We hold a wake lock at all times except during poll().  This works due to some  
        // subtle choreography.  When a device driver has pending (unread) events, it acquires  
        // a kernel wake lock.  However, once the last pending event has been read, the device  
        // driver will release the kernel wake lock.  To prevent the system from going to sleep  
        // when this happens, the EventHub holds onto its own user wake lock while the client  
        // is processing events.  Thus the system can only sleep if there are no events  
        // pending or currently being processed.  
        release_wake_lock(WAKE_LOCK_ID);  
  
        int pollResult = poll(mFDs, mFDCount, -1);  
  
        acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_ID);  
  
        if (pollResult <= 0) {  
            if (errno != EINTR) {  
                LOGW("poll failed (errno=%d)\n", errno);  
                usleep(100000);  
            }  
        }  
  
    }  
}  
 
 

这个函数比较长，我们一步一步来分析。

首先，如果是第一次进入到这个函数中时，成员变量mOpened的值为false，于是就会调用openPlatformInput函数来打开系统输入设备，在本文中，我们主要讨论的输入设备就是键盘了。打开了这些输入设备文件后，就可以对这些输入设备进行是监控了。如果不是第一次进入到这个函数，那么就会分析当前有没有输入事件发生，如果有，就返回这个事件，否则就会进入等待状态，等待下一次输入事件的发生。在我们这个场景中，就是等待下一次键盘事件的发生了。

我们先分析openPlatformInput函数的实现，然后回过头来分析这个getEvent函数的具体的实现。

本文转自 Luoshengyang 51CTO博客，原文链接：http://blog.51cto.com/shyluo/966613，如需转载请自行联系原作者

微信关注我们

原文链接：https://yq.aliyun.com/articles/407307

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

android在当前app该文件下创建一个文件夹

/********************************************************************* * Author : Samson * Date : 04/22/2014 * Test platform: * 3.11.0-12-generic #19-Ubuntu * GNU bash, version 4.2.45 * *******************************************************************/ package com.example.listfile; import java.io.File; import java.io.IOException; import android.app.Activity; import android.content.Context; import android.widget.TextView; import android.os.Bundle; import android.os.Process; public class MainAct...

2017-11-14

473

深入Android 【六】 —— 界面构造

界面构造 UI界面，对于每个应用而言，是它与用户进行交互的门脸。好的门脸，不只是是要亮丽可人，最好还能秀色可餐过目不忘，甚至还应该有涵养有气质，彬彬有理温柔耐心。对于开发者来说，锻造这样的面容，不但需要高超的技艺，也需要有称手的工具和对得起党的料子。俗话说，朽木不可雕也，芙蓉不是一日炼成的，不是什么平台都能叫特能书。有套好用的UI框架，对于开发者而言，真有如沙漠中的甘露，而要是撞见了杯具的UI套件，整个界面开发就有如梦魇了。 Android的UI框架，最核心的，是资源和 Layout 体系，然后，通过完善的控件库，简明的接口设计，进一步帮助开发者，能够最快的搭建自己需要界面（听到这里，Symbian同学开始钻土...）。 UI控件做UI，有时候就像搭积木，在Android中，这个最原子的积木块，就是 View。所有其他的UI元素，都是派生于此类的子孙类们。又从SDK中偷来张图，用来描述Android的UI控件结构，在每一个window下，这都是一个标准而完整的树结构。View有一个子类ViewGroup，它相当于一个容器类或者是复合控件，所有派生与ViewGroup的子类...

2017-11-14

466

发表评论

资源下载

更多资源

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。