Android輸入輸出機制之來龍去脈之前生后世

本文轉載自查看原文 2011-11-24 21:17 3613 輸入子系統

先講一下基本一般的輸入處理方式的知識。一般的輸入輸出采用生產者，消費者模式，並構造隊列進行處理，如下圖

這種輸入模型在android的系統中很多地方采用，先從最底層說起：

為了由於觸屏事件頻率很高，android設計者講一個循環線程，拆分為兩級循環，並做了個隊列來進行緩沖。

InputDispatcherThread和InputReaderThread

InputDispatcherThread在自己的循環中對InputReaderThread請求同步，InputReaderThread收到同步信號后，把事件放入InputDispatcher的隊列中。

具體代碼如下：

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

MultiTouchInputMapper。當線程從EventHub讀取到Event后，調用這些InputMapper的pocess方法：

文件InputReader.cpp中：

bool InputReaderThread::threadLoop() {
    mReader->loopOnce();
    return true;
}


void InputReader::loopOnce() {
    RawEvent rawEvent;
    mEventHub->getEvent(& rawEvent);

#if DEBUG_RAW_EVENTS
    LOGD("Input event: device=0x%x type=0x%x scancode=%d keycode=%d value=%d",
            rawEvent.deviceId, rawEvent.type, rawEvent.scanCode, rawEvent.keyCode,
            rawEvent.value);
#endif

    process(& rawEvent);
}

process如下

void InputReader::process(const RawEvent* rawEvent) {
    switch (rawEvent->type) {
        consumeEvent(rawEvent);
        break;
    }
}

Java代碼

consumeEvent(rawEvent);

consumeEvent(rawEvent);

方法是關鍵，下面繼續跟進；

Java代碼

void InputReader::consumeEvent(const RawEvent* rawEvent) {
    int32_t deviceId = rawEvent->deviceId;

    { 
        device->process(rawEvent);
    } // release device registry reader lock
}

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

Java代碼

void InputDevice::process(const RawEvent* rawEvent) {
    size_t numMappers = mMappers.size();
    for (size_t i = 0; i < numMappers; i++) {
        InputMapper* mapper = mMappers[i];
        mapper->process(rawEvent);
    }
}

下面進入了IputMapper，InputMapper是個純虛類，process是個純虛方法，隨便找個例子跟進去：

void SingleTouchInputMapper::process(const RawEvent* rawEvent) {
    switch (rawEvent->type) {
    case EV_KEY:
        switch (rawEvent->scanCode) {
        case BTN_TOUCH:
            mAccumulator.fields |= Accumulator::FIELD_BTN_TOUCH;
            mAccumulator.btnTouch = rawEvent->value != 0;
            // Don't sync immediately.  Wait until the next SYN_REPORT since we might
            // not have received valid position information yet.  This logic assumes that
            // BTN_TOUCH is always followed by SYN_REPORT as part of a complete packet.
            break;
        }
        break;
    case EV_SYN:
        switch (rawEvent->scanCode) {
        case SYN_REPORT:
            sync(rawEvent->when);
            break;
        }
        break;
    }
}

最關鍵的是

Cpp代碼

sync(rawEvent->when);

 sync(rawEvent->when);

展開如下：

Cpp代碼

void SingleTouchInputMapper::sync(nsecs_t when) {

    syncTouch(when, true);

 
}

Java代碼

void TouchInputMapper::syncTouch(nsecs_t when, bool havePointerIds) {
   
    if (touchResult == DISPATCH_TOUCH) {
        detectGestures(when);
        dispatchTouches(when, policyFlags);
    }
}

這兩行，一個是虛擬鍵盤，一個是觸摸屏。

TouchResult touchResult = consumeOffScreenTouches(when, policyFlags);

Java代碼

dispatchTouches
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. }
void TouchInputMapper::dispatchTouches(nsecs_t when, uint32_t policyFlags) { // Dispatch pointer down events using the new pointer locations. while (!downIdBits.isEmpty()) { dispatchTouch(when, policyFlags, &mCurrentTouch, activeIdBits, downId, pointerCount, motionEventAction); } } }
Cpp代碼
1. dispatchTouch(when, policyFlags, &mCurrentTouch,
2. activeIdBits, downId, pointerCount, motionEventAction);
dispatchTouch(when, policyFlags, &mCurrentTouch, 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;
9. {
10. getDispatcher()->notifyMotion(when, getDeviceId(), getSources(), policyFlags,
11. motionEventAction, 0, getContext()->getGlobalMetaState(), motionEventEdgeFlags,
12. pointerCount, pointerIds, pointerCoords,
13. xPrecision, yPrecision, mDownTime);
14. }
void TouchInputMapper::dispatchTouch(nsecs_t when, uint32_t policyFlags, TouchData* touch, BitSet32 idBits, uint32_t changedId, uint32_t pointerCount, int32_t motionEventAction) { int32_t pointerIds[MAX_POINTERS]; PointerCoords pointerCoords[MAX_POINTERS]; int32_t motionEventEdgeFlags = 0; float xPrecision, yPrecision; { getDispatcher()->notifyMotion(when, getDeviceId(), getSources(), policyFlags, motionEventAction, 0, getContext()->getGlobalMetaState(), motionEventEdgeFlags, pointerCount, pointerIds, pointerCoords, xPrecision, yPrecision, mDownTime); }
這樣就到了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) {
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);
12. needWake = enqueueInboundEventLocked(newEntry);
13. }
void InputDispatcher::notifyMotion(nsecs_t eventTime, int32_t deviceId, int32_t source, uint32_t policyFlags, int32_t action, int32_t flags, int32_t metaState, int32_t edgeFlags, uint32_t pointerCount, const int32_t* pointerIds, const PointerCoords* pointerCoords, float xPrecision, float yPrecision, nsecs_t downTime) { // Just enqueue a new motion event. MotionEntry* newEntry = mAllocator.obtainMotionEntry(eventTime, deviceId, source, policyFlags, action, flags, metaState, edgeFlags, xPrecision, yPrecision, downTime, pointerCount, pointerIds, pointerCoords); needWake = enqueueInboundEventLocked(newEntry); }
最后一句：
Java代碼
1. needWake = enqueueInboundEventLocked(newEntry);
needWake = enqueueInboundEventLocked(newEntry);
Cpp代碼
1. bool InputDispatcher::enqueueInboundEventLocked(EventEntry* entry) {
2. bool needWake = mInboundQueue.isEmpty();
3. mInboundQueue.enqueueAtTail(entry);
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. }
26. return needWake;
27. }
bool InputDispatcher::enqueueInboundEventLocked(EventEntry* entry) { bool needWake = mInboundQueue.isEmpty(); mInboundQueue.enqueueAtTail(entry); switch (entry->type) { case EventEntry::TYPE_KEY: { KeyEntry* keyEntry = static_cast<KeyEntry*>(entry); if (isAppSwitchKeyEventLocked(keyEntry)) { if (keyEntry->action == AKEY_EVENT_ACTION_DOWN) { mAppSwitchSawKeyDown = true; } else if (keyEntry->action == AKEY_EVENT_ACTION_UP) { if (mAppSwitchSawKeyDown) { #if DEBUG_APP_SWITCH LOGD("App switch is pending!"); #endif mAppSwitchDueTime = keyEntry->eventTime + APP_SWITCH_TIMEOUT; mAppSwitchSawKeyDown = false; needWake = true; } } } break; } } return needWake; }
Cpp代碼
1. mInboundQueue正是上面所說的隊列。到此為止，從InputReader插入到隊列就完成了。
mInboundQueue正是上面所說的隊列。到此為止，從InputReader插入到隊列就完成了。
那么InputDispatcher又是如何從隊列中取出來的呢？累了。

InputDiapather的
Cpp代碼
1. dispatchOnce
dispatchOnce
方法如下：
Cpp代碼
1. void InputDispatcher::dispatchOnce() {
2. nsecs_t keyRepeatTimeout = mPolicy->getKeyRepeatTimeout();
3. nsecs_t keyRepeatDelay = mPolicy->getKeyRepeatDelay();
5. nsecs_t nextWakeupTime = LONG_LONG_MAX;
6. { // acquire lock
7. AutoMutex _l(mLock);
8. dispatchOnceInnerLocked(keyRepeatTimeout, keyRepeatDelay, & nextWakeupTime);
10. if (runCommandsLockedInterruptible()) {
11. nextWakeupTime = LONG_LONG_MIN; // force next poll to wake up immediately
12. }
13. } // release lock
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. }
26. mLooper->pollOnce(timeoutMillis);
27. }
void InputDispatcher::dispatchOnce() { nsecs_t keyRepeatTimeout = mPolicy->getKeyRepeatTimeout(); nsecs_t keyRepeatDelay = mPolicy->getKeyRepeatDelay(); nsecs_t nextWakeupTime = LONG_LONG_MAX; { // acquire lock AutoMutex _l(mLock); dispatchOnceInnerLocked(keyRepeatTimeout, keyRepeatDelay, & nextWakeupTime); if (runCommandsLockedInterruptible()) { nextWakeupTime = LONG_LONG_MIN; // force next poll to wake up immediately } } // release lock // Wait for callback or timeout or wake. (make sure we round up, not down) nsecs_t currentTime = now(); int32_t timeoutMillis; if (nextWakeupTime > currentTime) { uint64_t timeout = uint64_t(nextWakeupTime - currentTime); timeout = (timeout + 999999LL) / 1000000LL; timeoutMillis = timeout > INT_MAX ? -1 : int32_t(timeout); } else { timeoutMillis = 0; } mLooper->pollOnce(timeoutMillis); }
最關鍵的是
Cpp代碼
1. dispatchOnceInnerLocked(keyRepeatTimeout, keyRepeatDelay, & nextWakeupTime);
dispatchOnceInnerLocked(keyRepeatTimeout, keyRepeatDelay, & nextWakeupTime);
和
Cpp代碼
1. mLooper->pollOnce(timeoutMillis);（這個方法在有個回調，與事件有關的是【管道設備的文件描述符】。
2. 具體機制在后面講。這個東西實際上是個跨進程的信號。發送給了Android的用戶進程的JNI，又通過JNI調用InputQueue的的
3. 靜態方法如：dispatchMotionEvent。后面回提到dispatchMotionEvent才是Android用戶進程的事件入口函數。）
4. ）
mLooper->pollOnce(timeoutMillis);（這個方法在有個回調，與事件有關的是【管道設備的文件描述符】。具體機制在后面講。這個東西實際上是個跨進程的信號。發送給了Android的用戶進程的JNI，又通過JNI調用InputQueue的的靜態方法如：dispatchMotionEvent。后面回提到dispatchMotionEvent才是Android用戶進程的事件入口函數。））
代碼又長又臭
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. }
13. }
void InputDispatcher::dispatchOnceInnerLocked(nsecs_t keyRepeatTimeout, nsecs_t keyRepeatDelay, nsecs_t* nextWakeupTime) { case EventEntry::TYPE_MOTION: { MotionEntry* typedEntry = static_cast<MotionEntry*>(mPendingEvent); if (dropReason == DROP_REASON_NOT_DROPPED && isAppSwitchDue) { dropReason = DROP_REASON_APP_SWITCH; } done = dispatchMotionLocked(currentTime, typedEntry, &dropReason, nextWakeupTime); break; } }
Java代碼
1. dispatchMotionLocked
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
7. *outEvent = NULL;
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. }
19. LOGE("channel '%s' consumer ~ Error %d pinning ashmem fd %d.",
20. mChannel->getName().string(), result, ashmemFd);
21. return UNKNOWN_ERROR;
22. }
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. }
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. }
40. mSharedMessage->consumed = true;
42. switch (mSharedMessage->type) {
43. case AINPUT_EVENT_TYPE_KEY: {
44. KeyEvent* keyEvent = factory->createKeyEvent();
45. if (! keyEvent) return NO_MEMORY;
47. populateKeyEvent(keyEvent);
49. *outEvent = keyEvent;
50. break;
51. }
53. case AINPUT_EVENT_TYPE_MOTION: {
54. MotionEvent* motionEvent = factory->createMotionEvent();
55. if (! motionEvent) return NO_MEMORY;
57. populateMotionEvent(motionEvent);
59. *outEvent = motionEvent;
60. break;
61. }
63. default:
64. LOGE("channel '%s' consumer ~ Received message of unknown type %d",
65. mChannel->getName().string(), mSharedMessage->type);
66. return UNKNOWN_ERROR;
67. }
69. return OK;
70. }
status_t InputConsumer::consume(InputEventFactoryInterface* factory, InputEvent** outEvent) { #if DEBUG_TRANSPORT_ACTIONS LOGD("channel '%s' consumer ~ consume", mChannel->getName().string()); #endif *outEvent = NULL; int ashmemFd = mChannel->getAshmemFd(); int result = ashmem_pin_region(ashmemFd, 0, 0); if (result != ASHMEM_NOT_PURGED) { if (result == ASHMEM_WAS_PURGED) { LOGE("channel '%s' consumer ~ Error %d pinning ashmem fd %d because it was purged " "which probably indicates that the publisher and consumer are out of sync.", mChannel->getName().string(), result, ashmemFd); return INVALID_OPERATION; } LOGE("channel '%s' consumer ~ Error %d pinning ashmem fd %d.", mChannel->getName().string(), result, ashmemFd); return UNKNOWN_ERROR; } if (mSharedMessage->consumed) { LOGE("channel '%s' consumer ~ The current message has already been consumed.", mChannel->getName().string()); return INVALID_OPERATION; } // Acquire but *never release* the semaphore. Contention on the semaphore is used to signal // to the publisher that the message has been consumed (or is in the process of being // consumed). Eventually the publisher will reinitialize the semaphore for the next message. result = sem_wait(& mSharedMessage->semaphore); if (result < 0) { LOGE("channel '%s' consumer ~ Error %d in sem_wait.", mChannel->getName().string(), errno); return UNKNOWN_ERROR; } mSharedMessage->consumed = true; switch (mSharedMessage->type) { case AINPUT_EVENT_TYPE_KEY: { KeyEvent* keyEvent = factory->createKeyEvent(); if (! keyEvent) return NO_MEMORY; populateKeyEvent(keyEvent); *outEvent = keyEvent; break; } case AINPUT_EVENT_TYPE_MOTION: { MotionEvent* motionEvent = factory->createMotionEvent(); if (! motionEvent) return NO_MEMORY; populateMotionEvent(motionEvent); *outEvent = motionEvent; break; } default: LOGE("channel '%s' consumer ~ Received message of unknown type %d", mChannel->getName().string(), mSharedMessage->type); return UNKNOWN_ERROR; } return OK; }
也許我們最關心的是如何訂閱的，不得不取看一下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. }
10. #if DEBUG_REGISTRATION
11. LOGD("channel '%s' - Registered", inputChannel->getName().string());
12. #endif
14. sp<Looper> looper = android_os_MessageQueue_getLooper(env, messageQueueObj);
16. { // acquire lock
17. AutoMutex _l(mLock);
19. if (getConnectionIndex(inputChannel) >= 0) {
20. LOGW("Attempted to register already registered input channel '%s'",
21. inputChannel->getName().string());
22. return BAD_VALUE;
23. }
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. }
34. connection->inputHandlerObjGlobal = env->NewGlobalRef(inputHandlerObj);
36. int32_t receiveFd = inputChannel->getReceivePipeFd();
37. mConnectionsByReceiveFd.add(receiveFd, connection);
39. looper->addFd(receiveFd, 0, ALOOPER_EVENT_INPUT, handleReceiveCallback, this);
40. } // release lock
42. android_view_InputChannel_setDisposeCallback(env, inputChannelObj,
43. handleInputChannelDisposed, this);
44. return OK;
45. }
status_t NativeInputQueue::registerInputChannel(JNIEnv* env, jobject inputChannelObj, jobject inputHandlerObj, jobject messageQueueObj) { sp<InputChannel> inputChannel = android_view_InputChannel_getInputChannel(env, inputChannelObj); if (inputChannel == NULL) { LOGW("Input channel is not initialized."); return BAD_VALUE; } #if DEBUG_REGISTRATION LOGD("channel '%s' - Registered", inputChannel->getName().string()); #endif sp<Looper> looper = android_os_MessageQueue_getLooper(env, messageQueueObj); { // acquire lock AutoMutex _l(mLock); if (getConnectionIndex(inputChannel) >= 0) { LOGW("Attempted to register already registered input channel '%s'", inputChannel->getName().string()); return BAD_VALUE; } uint16_t connectionId = mNextConnectionId++; sp<Connection> connection = new Connection(connectionId, inputChannel, looper); status_t result = connection->inputConsumer.initialize(); if (result) { LOGW("Failed to initialize input consumer for input channel '%s', status=%d", inputChannel->getName().string(), result); return result; } connection->inputHandlerObjGlobal = env->NewGlobalRef(inputHandlerObj); int32_t receiveFd = inputChannel->getReceivePipeFd(); mConnectionsByReceiveFd.add(receiveFd, connection); looper->addFd(receiveFd, 0, ALOOPER_EVENT_INPUT, handleReceiveCallback, this); } // release lock android_view_InputChannel_setDisposeCallback(env, inputChannelObj, handleInputChannelDisposed, this); return OK; }

也許更想知道的是消息隊列在什么地方，進入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. }
13. synchronized (sLock) {
14. if (DEBUG) {
15. Slog.d(TAG, "Registering input channel '" + inputChannel + "'");
16. }
18. nativeRegisterInputChannel(inputChannel, inputHandler, messageQueue);
19. }
20. }
public static void registerInputChannel(InputChannel inputChannel, InputHandler inputHandler, MessageQueue messageQueue) { if (inputChannel == null) { throw new IllegalArgumentException("inputChannel must not be null"); } if (inputHandler == null) { throw new IllegalArgumentException("inputHandler must not be null"); } if (messageQueue == null) { throw new IllegalArgumentException("messageQueue must not be null"); } synchronized (sLock) { if (DEBUG) { Slog.d(TAG, "Registering input channel '" + inputChannel + "'"); } nativeRegisterInputChannel(inputChannel, inputHandler, messageQueue); } }
在ViewRoot.java中有這么幾行
Cpp代碼
1. InputQueue.registerInputChannel(mInputChannel, mInputHandler,
2. Looper.myQueue());
InputQueue.registerInputChannel(mInputChannel, mInputHandler, 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代碼
2. 回調的java代碼的方法入口為：InputQueue.java中的。
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. }
回調的java代碼的方法入口為：InputQueue.java中的。 @SuppressWarnings("unused") private static void dispatchMotionEvent(InputHandler inputHandler, MotionEvent event, long finishedToken) { Runnable finishedCallback = FinishedCallback.obtain(finishedToken); inputHandler.handleMotion(event, finishedCallback); }
這樣就回調到了ViewRoot中

dispatchTouches

只說觸摸屏，虛擬鍵類似，觸摸屏調用的是

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 控制台輸入輸出機制實例 java的輸入輸出 Python輸入輸出及循環 python基本輸入輸出函數 carsim輸入輸出變量 MATLAB 的輸入輸出命令 python文件與輸入輸出 Linux基礎之輸入輸出 mapreduce 輸入輸出類型 Java筆試之輸入輸出