现在的位置: 首页 > 综合 > 正文

Android输入输出机制之来龙去脉之前生后世

2012年10月13日 ⁄ 综合 ⁄ 共 21695字 ⁄ 字号 小 中 大 ⁄ 评论关闭

 

先讲一下基本一般的输入处理方式的知识。一般的输入输出采用生产者，消费者模式，并构造队列进行处理，如下图

  

这种输入模型在android的系统中很多地方采用，先从最底层说起：

 为了由于触屏事件频率很高，android设计者讲一个循环线程，拆分为两级循环，并做了个队列来进行缓冲。

InputDispatcherThread和InputReaderThread

         InputDispatcherThread在自己的循环中对InputReaderThread请求同步，InputReaderThread收到同步信号后，把事件放入InputDispatcher的队列中。

具体代码如下：

InputReader.cpp中有很多InputMapper,有SwitchInputMapper，KeyBoardInputMapper，TrackballInputMapper，SingleTouchInputMapper，

MultiTouchInputMapper。当线程从EventHub读取到Event后，调用这些InputMapper的pocess方法：

 

 process如下

 

 

Java代码
复制代码 收藏代码
  1. consumeEvent(rawEvent);  

方法是关键，下面继续跟进；

 

Java代码
复制代码 收藏代码

   device->process(rawEvent)行， 跟进去：

Java代码
复制代码 收藏代码

 下面进入了IputMapper，InputMapper是个纯虚类，process是个纯虚方法，随便找个例子跟进去：

 最关键的是

Cpp代码
复制代码 收藏代码
  1. sync(rawEvent->when);  

  展开如下：

 

Cpp代码
复制代码 收藏代码

 

Java代码
复制代码 收藏代码

 

 这两行，一个是虚拟键盘，一个是触摸屏。

      TouchResult touchResult = consumeOffScreenTouches(when, policyFlags);

Java代码
复制代码 收藏代码
  1. dispatchTouches  
  2. Cpp代码
    复制代码     收藏代码
    1. void TouchInputMapper::dispatchTouches(nsecs_t when, uint32_t policyFlags) {   
    2.         // Dispatch pointer down events using the new pointer locations.  
    3.         while (!downIdBits.isEmpty()) {   
    4.             dispatchTouch(when, policyFlags, &mCurrentTouch,   
    5.                     activeIdBits, downId, pointerCount, motionEventAction);   
    6.         }   
    7.     }   
    8. }  

     

    Cpp代码
    复制代码     收藏代码
    1. dispatchTouch(when, policyFlags, &mCurrentTouch,   
    2.                     activeIdBits, downId, pointerCount, motionEventAction);  

    这个方法展开如下：

     

    Java代码
    复制代码     收藏代码
    1. void TouchInputMapper::dispatchTouch(nsecs_t when, uint32_t policyFlags,   
    2.         TouchData* touch, BitSet32 idBits, uint32_t changedId, uint32_t pointerCount,   
    3.         int32_t motionEventAction) {   
    4.     int32_t pointerIds[MAX_POINTERS];   
    5.     PointerCoords pointerCoords[MAX_POINTERS];   
    6.     int32_t motionEventEdgeFlags = 0;   
    7.     float xPrecision, yPrecision;   
    8.   
    9.     {    
    10.     getDispatcher()->notifyMotion(when, getDeviceId(), getSources(), policyFlags,   
    11.             motionEventAction, 0, getContext()->getGlobalMetaState(), motionEventEdgeFlags,   
    12.             pointerCount, pointerIds, pointerCoords,   
    13.             xPrecision, yPrecision, mDownTime);   
    14. }  

     

      这样就到了InputDiaptcher的notifyMotion方法，这个方法很长，都再处理MOVE事件，将无用的删除后，留下如下关键代码：

     

    Java代码
    复制代码     收藏代码
    1.  void InputDispatcher::notifyMotion(nsecs_t eventTime, int32_t deviceId, int32_t source,   
    2.         uint32_t policyFlags, int32_t action, int32_t flags, int32_t metaState, int32_t edgeFlags,   
    3.         uint32_t pointerCount, const int32_t* pointerIds, const PointerCoords* pointerCoords,   
    4.         float xPrecision, float yPrecision, nsecs_t downTime) {         
    5.   
    6.  // Just enqueue a new motion event.
        
    7.         MotionEntry* newEntry = mAllocator.obtainMotionEntry(eventTime,   
    8.                 deviceId, source, policyFlags, action, flags, metaState, edgeFlags,   
    9.                 xPrecision, yPrecision, downTime,   
    10.                 pointerCount, pointerIds, pointerCoords);   
    11.   
    12.         needWake = enqueueInboundEventLocked(newEntry);   
    13. }  

     最后一句：

    Java代码
    复制代码     收藏代码
    1. needWake = enqueueInboundEventLocked(newEntry);  

     

    Cpp代码
    复制代码     收藏代码
    1. bool InputDispatcher::enqueueInboundEventLocked(EventEntry* entry) {   
    2.     bool needWake = mInboundQueue.isEmpty();   
    3.     mInboundQueue.enqueueAtTail(entry);   
    4.   
    5.     switch (entry->type) {   
    6.     case EventEntry::TYPE_KEY: {   
    7.         KeyEntry* keyEntry = static_cast<KeyEntry*>(entry);   
    8.         if (isAppSwitchKeyEventLocked(keyEntry)) {   
    9.             if (keyEntry->action == AKEY_EVENT_ACTION_DOWN) {   
    10.                 mAppSwitchSawKeyDown = true;   
    11.             } else if (keyEntry->action == AKEY_EVENT_ACTION_UP) {   
    12.                 if (mAppSwitchSawKeyDown) {   
    13. #if DEBUG_APP_SWITCH   
    14.                     LOGD("App switch is pending!");   
    15. #endif   
    16.                     mAppSwitchDueTime = keyEntry->eventTime + APP_SWITCH_TIMEOUT;   
    17.                     mAppSwitchSawKeyDown = false;   
    18.                     needWake = true;   
    19.                 }   
    20.             }   
    21.         }   
    22.         break;   
    23.     }   
    24.     }   
    25.   
    26.     return needWake;   
    27. }  

     

    Cpp代码
    复制代码     收藏代码
    1. mInboundQueue正是上面所说的队列。到此为止，从InputReader插入到队列就完成了。  

     那么InputDispatcher又是如何从队列中取出来的呢？累了。

      InputDiapather的

    Cpp代码
    复制代码     收藏代码
    1. dispatchOnce  

    方法如下：

    Cpp代码
    复制代码     收藏代码
    1. void InputDispatcher::dispatchOnce() {   
    2.     nsecs_t keyRepeatTimeout = mPolicy->getKeyRepeatTimeout();   
    3.     nsecs_t keyRepeatDelay = mPolicy->getKeyRepeatDelay();   
    4.   
    5.     nsecs_t nextWakeupTime = LONG_LONG_MAX;   
    6.     { // acquire lock   
    7.         AutoMutex _l(mLock);   
    8.         dispatchOnceInnerLocked(keyRepeatTimeout, keyRepeatDelay, & nextWakeupTime);   
    9.   
    10.         if (runCommandsLockedInterruptible()) {   
    11.             nextWakeupTime = LONG_LONG_MIN;  // force next poll to wake up immediately  
    12.         }   
    13.     } // release lock   
    14.   
    15.     // Wait for callback or timeout or wake.  (make sure we round up, not down)  
    16.     nsecs_t currentTime = now();   
    17.     int32_t timeoutMillis;   
    18.     if (nextWakeupTime > currentTime) {   
    19.         uint64_t timeout = uint64_t(nextWakeupTime - currentTime);   
    20.         timeout = (timeout + 999999LL) / 1000000LL;   
    21.         timeoutMillis = timeout > INT_MAX ? -1 : int32_t(timeout);   
    22.     } else {   
    23.         timeoutMillis = 0;   
    24.     }   
    25.   
    26.     mLooper->pollOnce(timeoutMillis);   
    27. }  

     最关键的是

    Cpp代码
    复制代码     收藏代码
    1. dispatchOnceInnerLocked(keyRepeatTimeout, keyRepeatDelay, & nextWakeupTime);  

    和

    Cpp代码
    复制代码     收藏代码
    1.     mLooper->pollOnce(timeoutMillis);（这个方法在有个回调，与事件有关的是【管道设备的文件描述符】。   
    2.   具体机制在后面讲。这个东西实际上是个跨进程的信号。发送给了Android的用户进程的JNI，又通过JNI调用InputQueue的的   
    3. 静态方法如：dispatchMotionEvent。后面回提到dispatchMotionEvent才是Android用户进程的事件入口函数。）   
    4. ）  

    代码又长又臭

     

     

    Java代码
    复制代码     收藏代码
    1. void InputDispatcher::dispatchOnceInnerLocked(nsecs_t keyRepeatTimeout,   
    2.         nsecs_t keyRepeatDelay, nsecs_t* nextWakeupTime) {   
    3.     case EventEntry::TYPE_MOTION: {   
    4.         MotionEntry* typedEntry = static_cast<MotionEntry*>(mPendingEvent);   
    5.         if (dropReason == DROP_REASON_NOT_DROPPED && isAppSwitchDue) {   
    6.             dropReason = DROP_REASON_APP_SWITCH;   
    7.         }   
    8.         done = dispatchMotionLocked(currentTime, typedEntry,   
    9.                 &dropReason, nextWakeupTime);   
    10.         break;   
    11.     }   
    12.   
    13. }  

     

    Java代码
    复制代码     收藏代码
    1. dispatchMotionLocked  

    方法调用prepareDispatchCycleLocked，调用startDispatchCycleLocked，最终调用

           // Publish the key event.
            status = connection->inputPublisher.publishKeyEvent(keyEntry->deviceId, keyEntry->source,
                    action, flags, keyEntry->keyCode, keyEntry->scanCode,
                    keyEntry->metaState, keyEntry->repeatCount, keyEntry->downTime,
                    keyEntry->eventTime);

    或者 // Publish the motion event and the first motion sample.
            status = connection->inputPublisher.publishMotionEvent(motionEntry->deviceId,
                    motionEntry->source, action, flags, motionEntry->edgeFlags, motionEntry->metaState,
                    xOffset, yOffset,
                    motionEntry->xPrecision, motionEntry->yPrecision,
                    motionEntry->downTime, firstMotionSample->eventTime,
                    motionEntry->pointerCount, motionEntry->pointerIds,
                    firstMotionSample->pointerCoords);

     

    至此，InputDisapatcher也结束了。

    既然发布出去，必然有订阅者：在InputTransport.cpp中

    Java代码
    复制代码     收藏代码
    1. status_t InputConsumer::consume(InputEventFactoryInterface* factory, InputEvent** outEvent) {   
    2. #if DEBUG_TRANSPORT_ACTIONS   
    3.     LOGD("channel '%s' consumer ~ consume",   
    4.             mChannel->getName().string());   
    5. #endif   
    6.   
    7.     *outEvent = NULL;   
    8.   
    9.     int ashmemFd = mChannel->getAshmemFd();   
    10.     int result = ashmem_pin_region(ashmemFd, 0, 0);   
    11.     if (result != ASHMEM_NOT_PURGED) {   
    12.         if (result == ASHMEM_WAS_PURGED) {   
    13.             LOGE("channel '%s' consumer ~ Error %d pinning ashmem fd %d because it was purged "  
    14.                     "which probably indicates that the publisher and consumer are out of sync.",   
    15.                     mChannel->getName().string(), result, ashmemFd);   
    16.             return INVALID_OPERATION;   
    17.         }   
    18.   
    19.         LOGE("channel '%s' consumer ~ Error %d pinning ashmem fd %d.",   
    20.                 mChannel->getName().string(), result, ashmemFd);   
    21.         return UNKNOWN_ERROR;   
    22.     }   
    23.   
    24.     if (mSharedMessage->consumed) {   
    25.         LOGE("channel '%s' consumer ~ The current message has already been consumed.",   
    26.                 mChannel->getName().string());   
    27.         return INVALID_OPERATION;   
    28.     }   
    29.   
    30.     // Acquire but *never release* the semaphore.  Contention on the semaphore is used to signal  
    31.     // to the publisher that the message has been consumed (or is in the process of being  
    32.     // consumed).  Eventually the publisher will reinitialize the semaphore for the next message.  
    33.     result = sem_wait(& mSharedMessage->semaphore);   
    34.     if (result < 0) {   
    35.         LOGE("channel '%s' consumer ~ Error %d in sem_wait.",   
    36.                 mChannel->getName().string(), errno);   
    37.         return UNKNOWN_ERROR;   
    38.     }   
    39.   
    40.     mSharedMessage->consumed = true;   
    41.   
    42.     switch (mSharedMessage->type) {   
    43.     case AINPUT_EVENT_TYPE_KEY: {   
    44.         KeyEvent* keyEvent = factory->createKeyEvent();   
    45.         if (! keyEvent) return NO_MEMORY;   
    46.   
    47.         populateKeyEvent(keyEvent);   
    48.   
    49.         *outEvent = keyEvent;   
    50.         break;   
    51.     }   
    52.   
    53.     case AINPUT_EVENT_TYPE_MOTION: {   
    54.         MotionEvent* motionEvent = factory->createMotionEvent();   
    55.         if (! motionEvent) return NO_MEMORY;   
    56.   
    57.         populateMotionEvent(motionEvent);   
    58.   
    59.         *outEvent = motionEvent;   
    60.         break;   
    61.     }   
    62.   
    63.     default:   
    64.         LOGE("channel '%s' consumer ~ Received message of unknown type %d",   
    65.                 mChannel->getName().string(), mSharedMessage->type);   
    66.         return UNKNOWN_ERROR;   
    67.     }   
    68.   
    69.     return OK;   
    70. }  

     也许我们最关心的是如何订阅的，不得不取看一下JNI的代码，文件android_view_InputQueue.cpp

     聚焦到这里

     

    Cpp代码
    复制代码     收藏代码
    1. status_t NativeInputQueue::registerInputChannel(JNIEnv* env, jobject inputChannelObj,   
    2.         jobject inputHandlerObj, jobject messageQueueObj) {   
    3.     sp<InputChannel> inputChannel = android_view_InputChannel_getInputChannel(env,   
    4.             inputChannelObj);   
    5.     if (inputChannel == NULL) {   
    6.         LOGW("Input channel is not initialized.");   
    7.         return BAD_VALUE;   
    8.     }   
    9.   
    10. #if DEBUG_REGISTRATION   
    11.     LOGD("channel '%s' - Registered", inputChannel->getName().string());   
    12. #endif   
    13.   
    14.     sp<Looper> looper = android_os_MessageQueue_getLooper(env, messageQueueObj);   
    15.   
    16.     { // acquire lock   
    17.         AutoMutex _l(mLock);   
    18.   
    19.         if (getConnectionIndex(inputChannel) >= 0) {   
    20.             LOGW("Attempted to register already registered input channel '%s'",   
    21.                     inputChannel->getName().string());   
    22.             return BAD_VALUE;   
    23.         }   
    24.   
    25.         uint16_t connectionId = mNextConnectionId++;   
    26.         sp<Connection> connection = new Connection(connectionId, inputChannel, looper);   
    27.         status_t result = connection->inputConsumer.initialize();   
    28.         if (result) {   
    29.             LOGW("Failed to initialize input consumer for input channel '%s', status=%d",   
    30.                     inputChannel->getName().string(), result);   
    31.             return result;   
    32.         }   
    33.   
    34.         connection->inputHandlerObjGlobal = env->NewGlobalRef(inputHandlerObj);   
    35.   
    36.         int32_t receiveFd = inputChannel->getReceivePipeFd();   
    37.         mConnectionsByReceiveFd.add(receiveFd, connection);   
    38.   
    39.         looper->addFd(receiveFd, 0, ALOOPER_EVENT_INPUT, handleReceiveCallback, this);   
    40.     } // release lock   
    41.   
    42.     android_view_InputChannel_setDisposeCallback(env, inputChannelObj,   
    43.             handleInputChannelDisposed, this);   
    44.     return OK;   
    45. }  

     

     

      也许更想知道的是消息队列在什么地方，进入InputQueue.java来看

     

    Java代码
    复制代码     收藏代码
    1. public static void registerInputChannel(InputChannel inputChannel, InputHandler inputHandler,   
    2.         MessageQueue messageQueue) {   
    3.     if (inputChannel == null) {   
    4.         throw new IllegalArgumentException("inputChannel must not be null");   
    5.     }   
    6.     if (inputHandler == null) {   
    7.         throw new IllegalArgumentException("inputHandler must not be null");   
    8.     }   
    9.     if (messageQueue == null) {   
    10.         throw new IllegalArgumentException("messageQueue must not be null");   
    11.     }   
    12.        
    13.     synchronized (sLock) {   
    14.         if (DEBUG) {   
    15.             Slog.d(TAG, "Registering input channel '" + inputChannel + "'");   
    16.         }   
    17.            
    18.         nativeRegisterInputChannel(inputChannel, inputHandler, messageQueue);   
    19.     }   
    20. }   

     

    在ViewRoot.java中有这么几行

     

    Cpp代码
    复制代码     收藏代码
    1. InputQueue.registerInputChannel(mInputChannel, mInputHandler,   
    2.         Looper.myQueue());  

     完毕。

    这才牵涉到管道的问题，哪个Java中的Channel对应的正是linux系统的管道。有了管道，才能通过 跨进程方式回调回来，为什么是这个入口，上面进行了解释。具体参照INputQUEUE这个java类的JNI方法

    int NativeInputQueue::handleReceiveCallback(int receiveFd, int events, void* data)

    这个方法被InputQueue的RegisterInputChannel注册给了系统.系统通过回调，回调的是这个ALOOPER_EVENT_INPUT事件。

     

     

    looper就是android中的【用户进程的循环】

    注册的代码为 ：

      looper->addFd(receiveFd, 0, ALOOPER_EVENT_INPUT, handleReceiveCallback, this);

    回调的java函数为

    Java代码
    复制代码     收藏代码
    1.        
    2. 回调的java代码的方法入口为：InputQueue.java中的。   
    3.   
    4. @SuppressWarnings("unused")   
    5.     private static void dispatchMotionEvent(InputHandler inputHandler,   
    6.             MotionEvent event, long finishedToken) {   
    7.         Runnable finishedCallback = FinishedCallback.obtain(finishedToken);   
    8.         inputHandler.handleMotion(event, finishedCallback);   
    9.     }  

     这样就回调到了ViewRoot中

    只说触摸屏，虚拟键类似，触摸屏调用的是  

 

 

返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞