AI 助理
文档备案控制台
开发者社区 开发与运维 文章 正文

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

2017-11-14 995
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

       Step 18. EventHub.getEvent

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

  1. bool EventHub::getEvent(RawEvent* outEvent)  
  2. {  
  3.     outEvent->deviceId = 0;  
  4.     outEvent->type = 0;  
  5.     outEvent->scanCode = 0;  
  6.     outEvent->keyCode = 0;  
  7.     outEvent->flags = 0;  
  8.     outEvent->value = 0;  
  9.     outEvent->when = 0;  
  10.   
  11.     // Note that we only allow one caller to getEvent(), so don't need  
  12.     // to do locking here...  only when adding/removing devices.  
  13.   
  14.     if (!mOpened) {  
  15.         mError = openPlatformInput() ? NO_ERROR : UNKNOWN_ERROR;  
  16.         mOpened = true;  
  17.         mNeedToSendFinishedDeviceScan = true;  
  18.     }  
  19.   
  20.     for (;;) {  
  21.         // Report any devices that had last been added/removed.  
  22.         if (mClosingDevices != NULL) {  
  23.             device_t* device = mClosingDevices;  
  24.             LOGV("Reporting device closed: id=0x%x, name=%s\n",  
  25.                 device->id, device->path.string());  
  26.             mClosingDevices = device->next;  
  27.             if (device->id == mFirstKeyboardId) {  
  28.                 outEvent->deviceId = 0;  
  29.             } else {  
  30.                 outEvent->deviceId = device->id;  
  31.             }  
  32.             outEvent->type = DEVICE_REMOVED;  
  33.             outEvent->when = systemTime(SYSTEM_TIME_MONOTONIC);  
  34.             delete device;  
  35.             mNeedToSendFinishedDeviceScan = true;  
  36.             return true;  
  37.         }  
  38.   
  39.         if (mOpeningDevices != NULL) {  
  40.             device_t* device = mOpeningDevices;  
  41.             LOGV("Reporting device opened: id=0x%x, name=%s\n",  
  42.                 device->id, device->path.string());  
  43.             mOpeningDevices = device->next;  
  44.             if (device->id == mFirstKeyboardId) {  
  45.                 outEvent->deviceId = 0;  
  46.             } else {  
  47.                 outEvent->deviceId = device->id;  
  48.             }  
  49.             outEvent->type = DEVICE_ADDED;  
  50.             outEvent->when = systemTime(SYSTEM_TIME_MONOTONIC);  
  51.             mNeedToSendFinishedDeviceScan = true;  
  52.             return true;  
  53.         }  
  54.   
  55.         if (mNeedToSendFinishedDeviceScan) {  
  56.             mNeedToSendFinishedDeviceScan = false;  
  57.             outEvent->type = FINISHED_DEVICE_SCAN;  
  58.             outEvent->when = systemTime(SYSTEM_TIME_MONOTONIC);  
  59.             return true;  
  60.         }  
  61.   
  62.         // Grab the next input event.  
  63.         for (;;) {  
  64.             // Consume buffered input events, if any.  
  65.             if (mInputBufferIndex < mInputBufferCount) {  
  66.                 const struct input_event& iev = mInputBufferData[mInputBufferIndex++];  
  67.                 const device_t* device = mDevices[mInputDeviceIndex];  
  68.   
  69.                 LOGV("%s got: t0=%d, t1=%d, type=%d, code=%d, v=%d", device->path.string(),  
  70.                     (int) iev.time.tv_sec, (int) iev.time.tv_usec, iev.type, iev.code, iev.value);  
  71.                 if (device->id == mFirstKeyboardId) {  
  72.                     outEvent->deviceId = 0;  
  73.                 } else {  
  74.                     outEvent->deviceId = device->id;  
  75.                 }  
  76.                 outEvent->type = iev.type;  
  77.                 outEvent->scanCode = iev.code;  
  78.                 if (iev.type == EV_KEY) {  
  79.                     status_t err = device->layoutMap->map(iev.code,  
  80.                         & outEvent->keyCode, & outEvent->flags);  
  81.                     LOGV("iev.code=%d keyCode=%d flags=0x%08x err=%d\n",  
  82.                         iev.code, outEvent->keyCode, outEvent->flags, err);  
  83.                     if (err != 0) {  
  84.                         outEvent->keyCode = AKEYCODE_UNKNOWN;  
  85.                         outEvent->flags = 0;  
  86.                     }  
  87.                 } else {  
  88.                     outEvent->keyCode = iev.code;  
  89.                 }  
  90.                 outEvent->value = iev.value;  
  91.   
  92.                 // Use an event timestamp in the same timebase as  
  93.                 // java.lang.System.nanoTime() and android.os.SystemClock.uptimeMillis()  
  94.                 // as expected by the rest of the system.  
  95.                 outEvent->when = systemTime(SYSTEM_TIME_MONOTONIC);  
  96.                 return true;  
  97.             }  
  98.   
  99.             // Finish reading all events from devices identified in previous poll().  
  100.             // This code assumes that mInputDeviceIndex is initially 0 and that the  
  101.             // revents member of pollfd is initialized to 0 when the device is first added.  
  102.             // Since mFDs[0] is used for inotify, we process regular events starting at index 1.  
  103.             mInputDeviceIndex += 1;  
  104.             if (mInputDeviceIndex >= mFDCount) {  
  105.                 break;  
  106.             }  
  107.   
  108.             const struct pollfd& pfd = mFDs[mInputDeviceIndex];  
  109.             if (pfd.revents & POLLIN) {  
  110.                 int32_t readSize = read(pfd.fd, mInputBufferData,  
  111.                     sizeof(struct input_event) * INPUT_BUFFER_SIZE);  
  112.                 if (readSize < 0) {  
  113.                     if (errno != EAGAIN && errno != EINTR) {  
  114.                         LOGW("could not get event (errno=%d)", errno);  
  115.                     }  
  116.                 } else if ((readSize % sizeof(struct input_event)) != 0) {  
  117.                     LOGE("could not get event (wrong size: %d)", readSize);  
  118.                 } else {  
  119.                     mInputBufferCount = readSize / sizeof(struct input_event);  
  120.                     mInputBufferIndex = 0;  
  121.                 }  
  122.             }  
  123.         }  
  124.   
  125.         ......  
  126.   
  127.         mInputDeviceIndex = 0;  
  128.   
  129.         // Poll for events.  Mind the wake lock dance!  
  130.         // We hold a wake lock at all times except during poll().  This works due to some  
  131.         // subtle choreography.  When a device driver has pending (unread) events, it acquires  
  132.         // a kernel wake lock.  However, once the last pending event has been read, the device  
  133.         // driver will release the kernel wake lock.  To prevent the system from going to sleep  
  134.         // when this happens, the EventHub holds onto its own user wake lock while the client  
  135.         // is processing events.  Thus the system can only sleep if there are no events  
  136.         // pending or currently being processed.  
  137.         release_wake_lock(WAKE_LOCK_ID);  
  138.   
  139.         int pollResult = poll(mFDs, mFDCount, -1);  
  140.   
  141.         acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_ID);  
  142.   
  143.         if (pollResult <= 0) {  
  144.             if (errno != EINTR) {  
  145.                 LOGW("poll failed (errno=%d)\n", errno);  
  146.                 usleep(100000);  
  147.             }  
  148.         }  
  149.   
  150.     }  
  151. }  

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

 

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

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





本文转自 Luoshengyang 51CTO博客，原文链接：http://blog.51cto.com/shyluo/966613，如需转载请自行联系原作者
文章标签：
Android开发
监控
关键词：
Android机制
Android应用程序
Android应用
Android分析
Android消息处理
余二五
目录
相关文章
卓伊凡
|
7月前
|
存储 消息中间件 人工智能
【08】AI辅助编程完整的安卓二次商业实战-修改消息聊天框背景色-触发聊天让程序异常终止bug牵涉更多聊天消息发送优化处理-优雅草卓伊凡
【08】AI辅助编程完整的安卓二次商业实战-修改消息聊天框背景色-触发聊天让程序异常终止bug牵涉更多聊天消息发送优化处理-优雅草卓伊凡
卓伊凡
499 10
【08】AI辅助编程完整的安卓二次商业实战-修改消息聊天框背景色-触发聊天让程序异常终止bug牵涉更多聊天消息发送优化处理-优雅草卓伊凡
luanpanfei
|
12月前
|
存储 Android开发 数据安全/隐私保护
如何在Android设备上撤销Flutter应用程序的所有权限？
如何在Android设备上撤销Flutter应用程序的所有权限？
luanpanfei
784 64
luanpanfei
|
12月前
|
缓存 Android开发 开发者
Flutter环境配置完成后，如何在Android设备上运行Flutter应用程序？
Flutter环境配置完成后，如何在Android设备上运行Flutter应用程序？
luanpanfei
2231 62
luanpanfei
|
12月前
|
开发工具 Android开发 开发者
在Android设备上运行Flutter应用程序时，如果遇到设备未授权的问题该如何解决？
在Android设备上运行Flutter应用程序时，如果遇到设备未授权的问题该如何解决？
luanpanfei
841 61
游客762btuqu5wybw666
|
存储 安全 Android开发
探索Android与iOS的隐私保护机制
在数字化时代，移动设备已成为我们生活的一部分，而隐私安全是用户最为关注的问题之一。本文将深入探讨Android和iOS两大主流操作系统在隐私保护方面的策略和实现方式，分析它们各自的优势和不足，以及如何更好地保护用户的隐私。
游客762btuqu5wybw666
844 4
计蒙不吃鱼
|
11月前
|
消息中间件 Android开发
Android Handler的使用方式以及其机制的简单介绍
Handler 是 Android 中实现线程间通信的重要机制，可传递任意两线程数据。常用场景包括子线程向主线程（UI 线程）传递结果，以及主线程向子线程发送消息。其核心涉及四个类：Handler（发送/接收消息）、Message（消息载体）、MessageQueue（消息队列）和 Looper（消息循环泵）。基本流程为：Handler 发送 Message 至 MessageQueue，Looper 从队列中按 FIFO 取出并处理。
计蒙不吃鱼
329 0
游客762btuqu5wybw666
|
Linux Android开发 iOS开发
深入探索Android与iOS的多任务处理机制
在移动操作系统领域，Android和iOS各有千秋，尤其在多任务处理上展现出不同的设计理念和技术实现。本文将深入剖析两大平台在后台管理、资源分配及用户体验方面的策略差异，揭示它们如何平衡性能与电池寿命，为用户带来流畅而高效的操作体验。通过对比分析，我们不仅能够更好地理解各自系统的工作机制，还能为开发者优化应用提供参考。
游客762btuqu5wybw666
889 6
萝卜带泥
|
算法 Linux 调度
深入探索安卓系统的多任务处理机制
【10月更文挑战第21天】 本文旨在为读者提供一个关于Android系统多任务处理机制的全面解析。我们将从Android操作系统的核心架构出发，探讨其如何管理多个应用程序的同时运行，包括进程调度、内存管理和电量优化等方面。通过深入分析，本文揭示了Android在处理多任务时所面临的挑战以及它如何通过创新的解决方案来提高用户体验和设备性能。
萝卜带泥
909 1
mrq4nk6ni2neg
|
Java API Android开发
安卓应用程序开发的新手指南：从零开始构建你的第一个应用
【10月更文挑战第20天】在这个数字技术不断进步的时代，掌握移动应用开发技能无疑打开了一扇通往创新世界的大门。对于初学者来说，了解并学习如何从无到有构建一个安卓应用是至关重要的第一步。本文将为你提供一份详尽的入门指南，帮助你理解安卓开发的基础知识，并通过实际示例引导你完成第一个简单的应用项目。无论你是编程新手还是希望扩展你的技能集，这份指南都将是你宝贵的资源。
mrq4nk6ni2neg
979 5
sealin
|
Android开发
Android--退出整个应用程序
版权声明：本文为博主原创文章，转载请标明出处。 https://blog.csdn.net/chaoyu168/article/details/52229304 在写android应用程序时，经常会遇到想退出当前Acitivity，或者直接退出应用程序.我之前的一般操作是按返回键，或者直接按home键直接返回，其实这两种操作都没有关闭当前应用程序，没有释放系统资源。
sealin
974 0

热门文章

最新文章

  • 1
    Tomcat 7优化配置参数
  • 2
    安卓4.0系统8寸高分电容屏 蓝魔音悦汇W13HD将发布
  • 3
    《Cloud Native 》云原生技术汇总
  • 4
    Windows 10 MSDN官方原版ISO镜像(简体中文)下载
  • 5
    免费安装HEVC视频扩展
  • 6
    对比MySQL，一文看透HBase的能力及使用场景
  • 7
    [UML]UML系列——用例图中的各种关系（include、extend）
  • 8
    Android Gradle插件对应的Gradle所需版本
  • 9
    Android中SQLiteOpenHelper类的onUpgrade方法浅谈
  • 10
    Android 13这些权限废弃，你的应用受影响了吗？
  • 1
    Android与iOS的比较：哪个更适合你？
    757
  • 2
    Android 生成jar installable 控制生成的是dex还是class
    622
  • 3
    探索Android与iOS平台的安全性：一场永无止境的较量
    621
  • 4
    构建高效Android应用：Kotlin协程的实践指南
    252
  • 5
    构建高效Android应用：Kotlin协程的全面指南
    220
  • 6
    构建高效Android应用：采用Kotlin协程优化网络请求
    419
  • 7
    构建高效Android应用：Kotlin与Jetpack的实践之路未来技术的融合潮流：区块链、物联网与虚拟现实的交汇点
    204
  • 8
    提升Android应用性能的实用策略
    255
  • 9
    提升安卓应用性能的十大技巧
    345
  • 10
    Android 开发中的内存优化策略
    284

    • 相关课程

    更多
  • 开源Android容器化框架Atlas开发者指南

    • 相关电子书

    更多
  • 58同城Android客户端Walle框架演进与实践之路
  • Android组件化实现
  • 蚂蚁聚宝Android秒级编译——Freeline
    • 下一篇
    PHP：将本地文件上传到阿里云OSS存储