Android事件处理

最新推荐文章于 2024-06-15 17:14:16 发布
最新推荐文章于 2024-06-15 17:14:16 发布
阅读量1.4k 收藏 1
点赞数
文章标签： android keyboard server thread null class

Init-----------zygote---------system-server-------------------windosmanager  ------------------------------------------------------------ UEventObserver
------------------------------------------------------------ InputDeviceRead
-------------------------------------------------------------InputDispatcher
-------------------------------------------------------------DisplayEventThr
-------------------------------------------------------------ActivityManager

EventHub：
而事件的传入是从EventHub开始的，EventHub是事件的抽象结构，维护着系统设备的运行情况，设备类型包括Keyboard、TouchScreen、TraceBall。它在系统启动的时候会通过open_device方法将系统提供的输入设备都增加到这个抽象结构中，并维护一个所有输入设备的文件描述符，如果输入设备是键盘的话还会读取/system/usr/keylayout/目录下对应键盘设备的映射文件，另外getEvent方法是对EventHub中的设备文件描述符使用poll操作等侍驱动层事件的发生，如果发生的事件是键盘事件，则调用Map函数按照映射文件转换成相应的键值并将扫描码和键码返回给KeyInputQueue。
KeyLayoutMap主要是读取键盘映射文件并将键盘扫描码和键码进行转换

frameworks/base/core/jni/server/ com_android_server_KeyInputQueue.cpp
EventHub和KeyinputQueue的JNI接口层


KeyinputQueue：
在线程InputDeviceReader中会根据事件的类型以及事件值进行判断处理，从而确定这个事件对应的设备状态是否发生了改变并相应的改变对这个设备的描述结构InputDevice。
getEvent：在给定时间段时看是否有事件发生，如果有的话返回true否则false。

Windowmanager：
(frameworks/base/services/java/com/android/server/windowmanagerservice.java)
进程Windowmanager会创建一个线程（InputDispatcherThread），在这个线程里从事件队列中读取发生的事件（QueuedEvent ev = mQueue.getEvent（）），并根据读取到事件类型的不同分成三类（KEYBOARD、TOUCHSCREEN、TRACKBALL），分别进行处理，例如键盘事件会调用dispatchKey((KeyEvent)ev.event, 0, 0)以将事件通过Binder发送给具有焦点的窗口应用程序，然后调用 mQueue.recycleEvent(ev)继续等侍键盘事件的发生;如果是触摸屏事件则调用dispatchPointer(ev, (MotionEvent)ev.event, 0, 0)，这里会根据事件的种类（UP、DOWN、MOVE、OUT_SIDE等）进行判断并处理，比如Cancel或将事件发送到具有权限的指定的窗口中去;

Android 输入事件流程

EventHub

EventHub对输入设备进行了封装。输入设备驱动程序对用户空间应用程序提供一些设备文件，这些设备文件放在/dev/input里面。

EventHub扫描/dev/input下所有设备文件，并打开它们。

C代码 复制代码
  1. bool EventHub::openPlatformInput(void)   
  2. {   
  3. ...   
  4.     mFDCount = 1;   
  5.     mFDs = (pollfd *)calloc(1, sizeof(mFDs[0]));   
  6.     mDevices = (device_t **)calloc(1, sizeof(mDevices[0]));   
  7.     mFDs[0].events = POLLIN;   
  8.     mDevices[0] = NULL;   
  9.   
  10.     res = scan_dir(device_path);   
  11. ...   
  12.     return true;   
  13. }  



EventHub对外提供了一个函数用于从输入设备文件中读取数据。

C代码 复制代码
  1. bool EventHub::getEvent(int32_t* outDeviceId, int32_t* outType,   
  2.         int32_t* outScancode, int32_t* outKeycode, uint32_t *outFlags,   
  3.         int32_t* outValue, nsecs_t* outWhen)   
  4. {   
  5.     ...   
  6.     while(1) {   
  7.   
  8.         // First, report any devices that had last been added/removed.   
  9.         if (mClosingDevices != NULL) {   
  10.             device_t* device = mClosingDevices;   
  11.             LOGV("Reporting device closed: id=0x%x, name=%s/n",   
  12.                  device->id, device->path.string());   
  13.             mClosingDevices = device->next;   
  14.             *outDeviceId = device->id;   
  15.             if (*outDeviceId == mFirstKeyboardId) *outDeviceId = 0;   
  16.             *outType = DEVICE_REMOVED;   
  17.             delete device;   
  18.             return true;   
  19.         }   
  20.         if (mOpeningDevices != NULL) {   
  21.             device_t* device = mOpeningDevices;   
  22.             LOGV("Reporting device opened: id=0x%x, name=%s/n",   
  23.                  device->id, device->path.string());   
  24.             mOpeningDevices = device->next;   
  25.             *outDeviceId = device->id;   
  26.             if (*outDeviceId == mFirstKeyboardId) *outDeviceId = 0;   
  27.             *outType = DEVICE_ADDED;   
  28.             return true;   
  29.         }   
  30.   
  31.         release_wake_lock(WAKE_LOCK_ID);   
  32.   
  33.         pollres = poll(mFDs, mFDCount, -1);   
  34.   
  35.         acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_ID);   
  36.   
  37.         if (pollres <= 0) {   
  38.             if (errno != EINTR) {   
  39.                 LOGW("select failed (errno=%d)/n", errno);   
  40.                 usleep(100000);   
  41.             }   
  42.             continue;   
  43.         }   
  44.   
  45.         for(i = 1; i < mFDCount; i++) {   
  46.             if(mFDs[i].revents) {   
  47.                 LOGV("revents for %d = 0x%08x", i, mFDs[i].revents);   
  48.                 if(mFDs[i].revents & POLLIN) {   
  49.                     res = read(mFDs[i].fd, &iev, sizeof(iev));   
  50.                     if (res == sizeof(iev)) {   
  51.                         LOGV("%s got: t0=%d, t1=%d, type=%d, code=%d, v=%d",   
  52.                              mDevices[i]->path.string(),   
  53.                              (int) iev.time.tv_sec, (int) iev.time.tv_usec,   
  54.                              iev.type, iev.code, iev.value);   
  55.                         *outDeviceId = mDevices[i]->id;   
  56.                         if (*outDeviceId == mFirstKeyboardId) *outDeviceId = 0;   
  57.                         *outType = iev.type;   
  58.                         *outScancode = iev.code;   
  59.                         if (iev.type == EV_KEY) {   
  60.                             err = mDevices[i]->layoutMap->map(iev.code, outKeycode, outFlags);   
  61.                             LOGV("iev.code=%d outKeycode=%d outFlags=0x%08x err=%d/n",   
  62.                                 iev.code, *outKeycode, *outFlags, err);   
  63.                             if (err != 0) {   
  64.                                 *outKeycode = 0;   
  65.                                 *outFlags = 0;   
  66.                             }   
  67.                         } else {   
  68.                             *outKeycode = iev.code;   
  69.                         }   
  70.                         *outValue = iev.value;   
  71.                         *outWhen = s2ns(iev.time.tv_sec) + us2ns(iev.time.tv_usec);   
  72.                         return true;   
  73.                     } else {   
  74.                         if (res<0) {   
  75.                             LOGW("could not get event (errno=%d)", errno);   
  76.                         } else {   
  77.                             LOGE("could not get event (wrong size: %d)", res);   
  78.                         }   
  79.                         continue;   
  80.                     }   
  81.                 }   
  82.             }   
  83.         }   
  84.     ...   
  85. }  




对于按键事件，调用mDevices[i]->layoutMap->map进行映射。映射实际是由 KeyLayoutMap::map完成的，KeyLayoutMap类里读取配置文件qwerty.kl，由配置 文件 qwerty.kl 决定键值的映射关系。你可以通过修 改./development/emulator/keymaps/qwerty.kl来改变键值的映射关系。
JNI 函数

在frameworks/base/services/jni/com_android_server_KeyInputQueue.cpp文 件中，向 JAVA提供了函数android_server_KeyInputQueue_readEvent，用于读 取输入设备事件。

C代码 复制代码
  1. static jboolean   
  2. android_server_KeyInputQueue_readEvent(JNIEnv* env, jobject clazz,   
  3.                                           jobject event)   
  4. {   
  5.     gLock.lock();   
  6.     sp hub = gHub;   
  7.     if (hub == NULL) {   
  8.         hub = new EventHub;   
  9.         gHub = hub;   
  10.     }   
  11.     gLock.unlock();   
  12.   
  13.     int32_t deviceId;   
  14.     int32_t type;   
  15.     int32_t scancode, keycode;   
  16.     uint32_t flags;   
  17.     int32_t value;   
  18.     nsecs_t when;   
  19.     bool res = hub->getEvent(&deviceId, &type, &scancode, &keycode,   
  20.             &flags, &value, &when);   
  21.   
  22.     env->SetIntField(event, gInputOffsets.mDeviceId, (jint)deviceId);   
  23.     env->SetIntField(event, gInputOffsets.mType, (jint)type);   
  24.     env->SetIntField(event, gInputOffsets.mScancode, (jint)scancode);   
  25.     env->SetIntField(event, gInputOffsets.mKeycode, (jint)keycode);   
  26.     env->SetIntField(event, gInputOffsets.mFlags, (jint)flags);   
  27.     env->SetIntField(event, gInputOffsets.mValue, value);   
  28.     env->SetLongField(event, gInputOffsets.mWhen,   
  29.                         (jlong)(nanoseconds_to_milliseconds(when)));   
  30.   
  31.     return res;   
  32. }  



readEvent调用hub->getEvent读了取事件，然后转换成JAVA的结构。
事件中转线程

在frameworks/base/services/java/com/android/server/KeyInputQueue.java 里创建了一个线程，它循环的读取事件，然后把事件放入事件队列里。

Java代码 复制代码
  1. Thread mThread = new Thread("InputDeviceReader") {   
  2.         public void run() {   
  3.             android.os.Process.setThreadPriority(   
  4.                     android.os.Process.THREAD_PRIORITY_URGENT_DISPLAY);   
  5.   
  6.             try {   
  7.                 RawInputEvent ev = new RawInputEvent();   
  8.                 while (true) {   
  9.                     InputDevice di;   
  10.   
  11.                     readEvent(ev);   
  12.   
  13.                     send = preprocessEvent(di, ev);   
  14.                     addLocked(di, curTime, ev.flags, ..., me);   
  15.                 }   
  16.         }   
  17.     };  
Thread mThread = new Thread("InputDeviceReader") {
        public void run() {
            android.os.Process.setThreadPriority(
                    android.os.Process.THREAD_PRIORITY_URGENT_DISPLAY);

            try {
                RawInputEvent ev = new RawInputEvent();
                while (true) {
                    InputDevice di;

                    readEvent(ev);

                    send = preprocessEvent(di, ev);
                    addLocked(di, curTime, ev.flags, ..., me);
                }
        }
    };



输入事件分发线程

在frameworks/base/services/java/com/android/server/WindowManagerService.java里创建了一个输入事件分发线程，它负责把事件分发到相应的窗口上去。

Java代码 复制代码
  1. mQueue.getEvent   
  2. dispatchKey/dispatchPointer/dispatchTrackball  
mQueue.getEvent
dispatchKey/dispatchPointer/dispatchTrackball





按键,触摸屏流程分析

按键触摸屏流程分析:
WindowManagerService类的构造函数
WindowManagerService()
  mQueue = new KeyQ();
因为 WindowManagerService.java (frameworks/base/services/java/com/android/server)中有：   
private class KeyQ extends KeyInputQueue
KeyQ 是抽象类  KeyInputQueue 的实现，所以 new KeyQ类的时候实际上在 KeyInputQueue 类中创建了
一个线程  InputDeviceReader 专门用来冲设备读取按键事件，代码：
Thread mThread = new Thread("InputDeviceReader") {
  public void run()
  {
        在循环中调用：readEvent(ev);
    ...
    send = preprocessEvent(di, ev);
        实际调用的是 KeyQ 类的 preprocessEvent 函数
    ...
    int keycode = rotateKeyCodeLocked(ev.keycode);
      int[] map = mKeyRotationMap;
      for (int i=0; i<N; i+=2)
      {
        if (map[i] == keyCode)
          return map[i+1];
      } //
    addLocked(di, curTime, ev.flags,RawInputEvent.CLASS_KEYBOARD,newKeyEvent(di, di.mDownTime, curTime, down,keycode, 0, scancode,...));
      QueuedEvent ev = obtainLocked(device, when, flags, classType, event);
  }
}

readEvent() 实际上调用的是 com_android_server_KeyInputQueue.cpp (frameworks/base/services/jni)中的：
static jboolean android_server_KeyInputQueue_readEvent(JNIEnv* env, jobject clazz,jobject event)
  bool res = hub->getEvent(&deviceId, &type, &scancode, &keycode,&flags, &value, &when);
调用的是 EventHub.cpp (frameworks/base/libs/ui)中的：
bool EventHub::getEvent(int32_t* outDeviceId, int32_t* outType,
        int32_t* outScancode, int32_t* outKeycode, uint32_t *outFlags,
        int32_t* outValue, nsecs_t* outWhen)
在函数中调用了读设备操作：res = read(mFDs[i].fd, &iev, sizeof(iev));


在构造函数 WindowManagerService()调用 new KeyQ() 以后接着调用了：
  mInputThread = new InputDispatcherThread();      
  ...    
  mInputThread.start();
来启动一个线程  InputDispatcherThread
run()
  process();
    QueuedEvent ev = mQueue.getEvent(...)
因为WindowManagerService类中： final KeyQ mQueue;
所以实际上 InputDispatcherThread 线程实际上从  KeyQ 的事件队列中读取按键事件。
switch (ev.classType)
  case RawInputEvent.CLASS_KEYBOARD:
    ...
    dispatchKey((KeyEvent)ev.event, 0, 0);
    mQueue.recycleEvent(ev);
    break;
  case RawInputEvent.CLASS_TOUCHSCREEN:
    //Log.i(TAG, "Read next event " + ev);
    dispatchPointer(ev, (MotionEvent)ev.event, 0, 0);
    break;

===============================================================


KeyInputQueue.java (frameworks/base/services/java/com/android/server):
的线程  Thread mThread = new Thread("InputDeviceReader") 本地调用：
readEvent(ev);读取按键。readEvent 调用的是文件：
com_android_server_KeyInputQueue.cpp (frameworks/base/services/jni)中的函数：
static jboolean android_server_KeyInputQueue_readEvent(JNIEnv* env, jobject clazz,
                                          jobject event)
android_server_KeyInputQueue_readEvent中有：
hub = new EventHub;
bool res = hub->getEvent(&deviceId, &type, &scancode, &keycode,
            &flags, &value, &when);

hub->getEvent 调用的是
EventHub.cpp (frameworks/base/libs/ui) 文件中的函数：
bool EventHub::getEvent(int32_t* outDeviceId, int32_t* outType,
        int32_t* outScancode, int32_t* outKeycode, uint32_t *outFlags,
        int32_t* outValue, nsecs_t* outWhen)
读取按键。

class RefBase::weakref_impl : public RefBase::weakref_type



在系统启动后，android 会通过
static const char *device_path = "/dev/input";
bool EventHub::openPlatformInput(void)
  res = scan_dir(device_path);


通过下面的函数打开设备。
int EventHub::open_device(const char *deviceName)
{
  ...
  fd = open(deviceName, O_RDWR);
  ...
  mFDs[mFDCount].fd = fd;
  mFDs[mFDCount].events = POLLIN;
  ...
  ioctl(mFDs[mFDCount].fd, EVIOCGNAME(sizeof(devname)-1), devname);
  ...
  const char* root = getenv("ANDROID_ROOT");
  snprintf(keylayoutFilename, sizeof(keylayoutFilename),
                 "%s/usr/keylayout/%s.kl", root, tmpfn);
  ...
  device->layoutMap->load(keylayoutFilename);
  ...
}
打开设备的时候，如果 device->classes&CLASS_KEYBOARD 不等于 0 表明是键盘。
常用输入设备的定义有：
enum {
        CLASS_KEYBOARD      = 0x00000001, //键盘
        CLASS_ALPHAKEY      = 0x00000002, //
        CLASS_TOUCHSCREEN   = 0x00000004, //触摸屏
        CLASS_TRACKBALL     = 0x00000008  //轨迹球
    };
打开键盘设备的时候通过上面的  ioctl 获得设备名称，命令字 EVIOCGNAME 的定义在文件：
kernel/include/linux/input.h 中。
#define EVIOCGNAME(len)   _IOC(_IOC_READ, 'E', 0x06, len) /* get device name */
在内核键盘驱动文件 drivers/input/keyboard/pxa27x_keypad.c 中定义了设备名称：pxa27x-keypad
static struct platform_driver pxa27x_keypad_driver = {
    .probe        = pxa27x_keypad_probe,
    .remove        = __devexit_p(pxa27x_keypad_remove),
    .suspend    = pxa27x_keypad_suspend,
    .resume        = pxa27x_keypad_resume,
    .driver        = {
        .name    = "pxa27x-keypad",
        .owner    = THIS_MODULE,
    },
};
ANDROID_ROOT 为环境变量，在android的命令模式下通过 printenv 可以知道它为： system
所以 keylayoutFilename 为：/system/usr/keylayout/pxa27x-keypad.kl
pxa27x-keypad.kl 定义了按键映射，具体内容如下：
－－－－－－－－－－－－－－－－－－－－－－
# NUMERIC KEYS 3x4
key 2   1
key 3   2
key 4   3
key 5   4
key 6   5
key 7   6
key 8   7
key 9   8
key 10  9
key 11  0
key 83  POUND
key 55  STAR

# FUNCTIONAL KEYS
key 231  MENU        WAKE_DROPPED
key 192  BACK           WAKE_DROPPED
key 193  HOME       WAKE
key 107  DEL        WAKE
key 102  CALL        WAKE_DROPPED
key 158  ENDCALL     WAKE_DROPPED
key 28   DPAD_CENTER     WAKE
key 115  VOLUME_UP
key 114  VOLUME_DOWN
－－－－－－－－－－－－－－－－－－－－－－
如果没有定义键盘映射文件，那么默认使用系统的 /system/usr/keylayout/qwerty.kl
可以修改 /system/usr/keylayout/qwerty.kl 文件改变Android公司的按键映射。

device->layoutMap->load(keylayoutFilename) 调用的是文件：
KeyLayoutMap.cpp (frameworks/base/libs/ui)中的函数：
status_t KeyLayoutMap::load(const char* filename)通过解析 pxa27x-keypad.kl
把按键的映射关系保存在 ：KeyedVector<int32_t,Key> m_keys; 中。
当获得按键事件以后调用：
status_t KeyLayoutMap::map(int32_t scancode, int32_t *keycode, uint32_t *flags)
由映射关系 KeyedVector<int32_t,Key> m_keys 把扫描码转换成andorid上层可以识别的按键。

sijiangong
关注
android keyevent事件
12-22
android keyevent事件分析
android key事件分发,巧用事件分发机制，和我一起hold住android外围设备
weixin_39566593的博客
05-29 221
外围输入设备，例如：蓝牙键盘，usb键盘，barcode扫码枪...由于平时都是在做纯软件程序的开发，博主在需求遇到android设备与外围设备交互时有点不知所措。我最初的思路是这样：既然是蓝牙连接，那不就是socket吗，那么截获他的I/O流然后解析里面的内容...那不就ok啦？然而事情并没有那么简单，首先解析数据流是一个难点，再一个万一我蓝牙连接换成usb连接，或者wifi，那不就得再改了？参...
从源码角度分析：Andriod系统KeyEvent分发流程
snailyy
11-15 444
1、简介 焦点查找源码分析是基于Android7.0。写了一个自定义的CustomButton继承Button如下： public class CustomButton extends Button { private static final String TAG = "CustomButton"; public CustomButton(Context context) { super(context); } public CustomButton(Context context, At
Android事件
09-29
Activity和View都能接收触摸和按键，如果响应事件只需要在继承类里复写事件函数即可；当一个视图（如一个按钮）被触摸时，该对象上的 onTouchEvent() 方法会被调用。不过，为了侦听这个事件，你必须扩展这个类并重写该方法，当一些物理按钮被按下时会调用onKeyDown()方法；
Android中Key Event流程
micro9981的专栏
04-12 112
http://blog.csdn.net/yihua0001/article/details/5708030  Android中Key Event流程
Android 事件处理机制
05-17
Android事件处理机制
详解Android的两种事件处理机制
01-05
UI编程通常都会伴随事件处理，Android也不例外，它提供了两种方式的事件处理：基于回调的事件处理和基于监听器的事件处理。 对于基于监听器的事件处理而言，主要就是为Android界面组件绑定特定的事件监听器；对于...
Android 事件处理与交互式PPT
02-04
（1）理解Android的应用组件及其功能、特点 ...（3）理解并掌握Android的事件处理机制，掌握基于监听的事件处理机制和基于回调的事件处理机制使用方法 （4）了解Android的对话框与消息框，掌握Android的Toast。
[Android开发-TV]按键KeyEvent分发流程
Sansecy的博客
10-12 790
按键分发流程 研究按键的分发和触摸事件一样，我们需要知道从哪里接收到输入事件 接收事件 android.view.ViewRootImpl.java mInputEventReceiver = new WindowInputEventReceiver(mInputChannel, Looper.myLooper()); 从Activity与Window和ViewRootImpl绑定会调用android.view.ViewRootImpl#setVi
Android Framework层KeyEvent按键添加流程
DevGlider的博客
08-12 436
其次，我们找到了Framework层中处理KeyEvent的路径，并在WindowManagerService类中添加了自定义的按键处理逻辑。通过这些步骤，我们可以在Android系统中定制和扩展按键事件的处理能力，为用户提供更丰富和个性化的操作体验。一旦找到了WindowManagerService中处理KeyEvent按键的方法，我们可以添加自定义的按键事件处理逻辑。通过以上的步骤，我们可以在Android Framework层中成功添加和处理自定义的KeyEvent按键事件。
android的keyevent方法,浅析Android KeyEvent事件分发流程
weixin_30062415的博客
05-26 1658
Android里面KeyEvent事件在TV开发时经常都需要接触到，作为交互设备如遥控器、手柄等和Android UI交互时都是通过KeyEvent事件。下面来讲一下KeyEvent的分发流程。为了加深理解，建一个demo工程。布局文件如下图所示：View1、View2、View3是我分别继承RelativeLayout写的三个布局，模拟平时开发时的各种ViewGroup。最顶层的Button模拟...
Android中的KeyEvent详解
最新发布
FlyingFish868的博客
06-15 2540
在Android中，KeyEvent 是用来表示按键事件的类，可根据对应的事件来处理按键输入，具体包含了关于按键事件的信息，例如按键的代码、动作（按下或释放）以及事件的时间戳，KeyEvent 对象通常在用户与设备上的物理或软件键盘交互时产生，KeyEvent可以帮助开发者创建更加互动和响应式的应用程序
Android Input输入系统之二：KeyEvent注入事件及事件分发流程
Sunxiaolin2016的博客
12-27 4290
相关参考： Android Input输入系统之一：KeyEvent事件监听及事件分发流程 Android Input输入系统之二：KeyEvent注入事件及事件分发流程 在上一篇文章中，《Android Input输入系统之一：KeyEvent事件监听及事件分发流程》，讲解的是读取设备节点/dev/input/event0，并且将事件上应用层分发的流程。 这篇文章讲解模拟按键消息，通过注入事件的...
Android 监听键盘输入（实现搜索、发送、完成等等）
Android 领域开发程序员，希望通过写博客的方式不断的总结提升自己，大家共同进步哦！
05-31 9716
在Android App的实际开发中，时常会需要监听软键盘的输入事件。 可通过三种方法进行监听，即dispatchEvent，KeyListener，setOnEditorActionListener这三种方式 例如：微信和QQ聊天的消息发送，你会发现他的聊天框并没有发送的控件，软键盘的换行或者某个按钮会变成发送；在某些浏览器的输入框，输入内容后，软件盘的某个按钮会有搜索的字样，还有填写内容时的完成按钮等等，这些都可以通过监听键盘和输入框的一些配置实现这些功能。
Android按键事件处理流程 KeyEvent
pengjin1985的专栏
09-12 6283
刚接触Android开发的时候，对touch、key事件的处理总是一知半解，一会是Activity里的方法，一会是各种View 中的，自己始终不清楚到底哪个在先哪个在后，总之对整个处理流程没能很好的把握。每次写这部分代码的时候都有些心虚， 因为我不是很清楚什么时候、以什么样的顺序被调用，大都是打下log看看，没问题就算ok了。但随着时间流逝，这种感觉一直 折磨着我。期间也在网上搜
android服务监听keyevent,Android Input输入系统之一：KeyEvent事件监听
weixin_39880632的博客
05-30 1685
《Android按键Input KeyEvent》《Android Input输入系统之一：KeyEvent事件监听》《Android Input输入系统之二：KeyEvent注入事件及事件分发流程》《Android Input输入系统之三：KeyEvent事件分发和上层应用层对事件的接收》《Android Input输入系统之四：KeyEvent事件中的InputChannel通信》《Andro...
android的keyevent方法,Android keyevent按键和值的对应
weixin_42576804的博客
05-26 2280
Android keyevent 中的各个值，在使用adb shell input 的时候用得到。是从http://blog.csdn.net/huiguixian/article/details/8550170转过来的。KEYCODE_UNKNOWN=0;KEYCODE_SOFT_LEFT=1;KEYCODE_SOFT_RIGHT=2;KEYCODE_HOME=3;KEYCODE_BACK=4;...
Android KeyEvent 点击事件分发处理流程（简写）
vistaup的博客
06-15 2686
Android 按键事件分发
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值