Android按键事件传递流程(二)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

for (int i = 0; i < eventCount; i++) {

int fd = eventItems[i].data.fd;

uint32_t epollEvents = eventItems[i].events;

if (fd == mWakeReadPipeFd) {

if (epollEvents & EPOLLIN) {

awoken();

} else {

ALOGW("Ignoring unexpected epoll events 0x%x on wake read pipe.", epollEvents);

}

} else {

ssize_t requestIndex = mRequests.indexOfKey(fd);

if (requestIndex >= 0) {

int events = 0;

if (epollEvents & EPOLLIN) events |= EVENT_INPUT;

if (epollEvents & EPOLLOUT) events |= EVENT_OUTPUT;

if (epollEvents & EPOLLERR) events |= EVENT_ERROR;

if (epollEvents & EPOLLHUP) events |= EVENT_HANGUP;

pushResponse(events, mRequests.valueAt(requestIndex));

} else {

ALOGW("Ignoring unexpected epoll events 0x%x on fd %d that is "

"no longer registered.", epollEvents, fd);

}

}

1

while (mMessageEnvelopes.size() != 0) {

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

for (size_t i = 0; i < mResponses.size(); i++) {

Response& response = mResponses.editItemAt(i);

if (response.request.ident == POLL_CALLBACK) {

int fd = response.request.fd;

int events = response.events;

void* data = response.request.data;

#if DEBUG_POLL_AND_WAKE || DEBUG_CALLBACKS

ALOGD("%p ~ pollOnce - invoking fd event callback %p: fd=%d, events=0x%x, data=%p",

this, response.request.callback.get(), fd, events, data);

#endif

int callbackResult = response.request.callback->handleEvent(fd, events, data);

if (callbackResult == 0) {

removeFd(fd);

}

// Clear the callback reference in the response structure promptly because we

// will not clear the response vector itself until the next poll.

response.request.callback.clear();

result = POLL_CALLBACK;

}

1

int callbackResult = response.request.callback->handleEvent(fd, events, data);

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

int NativeInputEventReceiver::handleEvent(int receiveFd, int events, void* data) {

    if (events & (ALOOPER_EVENT_ERROR | ALOOPER_EVENT_HANGUP)) {

#if DEBUG_DISPATCH_CYCLE

        // This error typically occurs when the publisher has closed the input channel

        // as part of removing a window or finishing an IME session, in which case

        // the consumer will soon be disposed as well.

        ALOGD("channel '%s' ~ Publisher closed input channel or an error occurred.  "

                "events=0x%x", getInputChannelName(), events);

#endif

        return 0; // remove the callback

    }

    if (events & ALOOPER_EVENT_INPUT) {

        JNIEnv* env = AndroidRuntime::getJNIEnv();

        status_t status = consumeEvents(env, false /*consumeBatches*/, -1, NULL);

        mMessageQueue->raiseAndClearException(env, "handleReceiveCallback");

        return status == OK || status == NO_MEMORY ? 1 : 0;

    }

    if (events & ALOOPER_EVENT_OUTPUT) {

        for (size_t i = 0; i < mFinishQueue.size(); i++) {

            const Finish& finish = mFinishQueue.itemAt(i);

            status_t status = mInputConsumer.sendFinishedSignal(finish.seq, finish.handled);

            if (status) {

                mFinishQueue.removeItemsAt(0, i);

                if (status == WOULD_BLOCK) {

#if DEBUG_DISPATCH_CYCLE

                    ALOGD("channel '%s' ~ Sent %u queued finish events; %u left.",

                            getInputChannelName(), i, mFinishQueue.size());

#endif

                    return 1; // keep the callback, try again later

                }

                ALOGW("Failed to send finished signal on channel '%s'.  status=%d",

                        getInputChannelName(), status);

                if (status != DEAD_OBJECT) {

                    JNIEnv* env = AndroidRuntime::getJNIEnv();

                    String8 message;

                    message.appendFormat("Failed to finish input event.  status=%d", status);

                    jniThrowRuntimeException(env, message.string());

                    mMessageQueue->raiseAndClearException(env, "finishInputEvent");

                }

                return 0; // remove the callback

            }

        }

#if DEBUG_DISPATCH_CYCLE

        ALOGD("channel '%s' ~ Sent %u queued finish events; none left.",

                getInputChannelName(), mFinishQueue.size());

#endif

        mFinishQueue.clear();

        setFdEvents(ALOOPER_EVENT_INPUT);

        return 1;

    }

    ALOGW("channel '%s' ~ Received spurious callback for unhandled poll event.  "

            "events=0x%x", getInputChannelName(), events);

    return 1;

}

1

2

3

4

5

6

if (events & ALOOPER_EVENT_INPUT) {

    JNIEnv* env = AndroidRuntime::getJNIEnv();

    status_t status = consumeEvents(env, false /*consumeBatches*/, -1, NULL);

    mMessageQueue->raiseAndClearException(env, "handleReceiveCallback");

    return status == OK || status == NO_MEMORY ? 1 : 0;

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

status_t NativeInputEventReceiver::consumeEvents(JNIEnv* env,

bool consumeBatches, nsecs_t frameTime, bool* outConsumedBatch) {

#if DEBUG_DISPATCH_CYCLE

ALOGD("channel '%s' ~ Consuming input events, consumeBatches=%s, frameTime=%lld.",

getInputChannelName(), consumeBatches ? "true" : "false", frameTime);

#endif

if (consumeBatches) {

mBatchedInputEventPending = false;

}

if (outConsumedBatch) {

*outConsumedBatch = false;

}

ScopedLocalRef<jobject> receiverObj(env, NULL);

bool skipCallbacks = false;

for (;;) {

uint32_t seq;

InputEvent* inputEvent;

status_t status = mInputConsumer.consume(&mInputEventFactory,

consumeBatches, frameTime, &seq, &inputEvent);

if (status) {

if (status == WOULD_BLOCK) {

if (!skipCallbacks && !mBatchedInputEventPending

&& mInputConsumer.hasPendingBatch()) {

// There is a pending batch.  Come back later.

if (!receiverObj.get()) {

receiverObj.reset(jniGetReferent(env, mReceiverWeakGlobal));

if (!receiverObj.get()) {

ALOGW("channel '%s' ~ Receiver object was finalized "

"without being disposed.", getInputChannelName());

return DEAD_OBJECT;

}

}

mBatchedInputEventPending = true;

#if DEBUG_DISPATCH_CYCLE

ALOGD("channel '%s' ~ Dispatching batched input event pending notification.",

getInputChannelName());

#endif

env->CallVoidMethod(receiverObj.get(),

gInputEventReceiverClassInfo.dispatchBatchedInputEventPending);

if (env->ExceptionCheck()) {

ALOGE("Exception dispatching batched input events.");

mBatchedInputEventPending = false; // try again later

}

}

return OK;

}

ALOGE("channel '%s' ~ Failed to consume input event.  status=%d",

getInputChannelName(), status);

return status;

}

assert(inputEvent);

if (!skipCallbacks) {

if (!receiverObj.get()) {

receiverObj.reset(jniGetReferent(env, mReceiverWeakGlobal));

if (!receiverObj.get()) {

ALOGW("channel '%s' ~ Receiver object was finalized "

"without being disposed.", getInputChannelName());

return DEAD_OBJECT;

}

}

jobject inputEventObj;

switch (inputEvent->getType()) {

case AINPUT_EVENT_TYPE_KEY:

#if DEBUG_DISPATCH_CYCLE

ALOGD("channel '%s' ~ Received key event.", getInputChannelName());

#endif

inputEventObj = android_view_KeyEvent_fromNative(env,

static_cast<KeyEvent*>(inputEvent));

break;

case AINPUT_EVENT_TYPE_MOTION: {

#if DEBUG_DISPATCH_CYCLE

ALOGD("channel '%s' ~ Received motion event.", getInputChannelName());

#endif

MotionEvent* motionEvent = static_cast<MotionEvent*>(inputEvent);

if ((motionEvent->getAction() & AMOTION_EVENT_ACTION_MOVE) && outConsumedBatch) {

*outConsumedBatch = true;

}

inputEventObj = android_view_MotionEvent_obtainAsCopy(env, motionEvent);

break;

}

default:

assert(false); // InputConsumer should prevent this from ever happening

inputEventObj = NULL;

}

if (inputEventObj) {

#if DEBUG_DISPATCH_CYCLE

ALOGD("channel '%s' ~ Dispatching input event.", getInputChannelName());

#endif

env->CallVoidMethod(receiverObj.get(),

gInputEventReceiverClassInfo.dispatchInputEvent, seq, inputEventObj);

if (env->ExceptionCheck()) {

ALOGE("Exception dispatching input event.");

skipCallbacks = true;

}

env->DeleteLocalRef(inputEventObj);

} else {

ALOGW("channel '%s' ~ Failed to obtain event object.", getInputChannelName());

skipCallbacks = true;

}

}

if (skipCallbacks) {

mInputConsumer.sendFinishedSignal(seq, false);

}

}

}

1

2

status_t status = mInputConsumer.consume(&mInputEventFactory,

                consumeBatches, frameTime, &seq, &inputEvent);

1

status_t result = mChannel->receiveMessage(&mMsg);

1

2

3

do {

    nRead = ::recv(mFd, msg, sizeof(InputMessage), MSG_DONTWAIT);

} while (nRead == -1 && errno == EINTR);

1

2

3

4

5

6

7

8

9

10

11

12

13

14

switch (mMsg.header.type) {

case InputMessage::TYPE_KEY: {

KeyEvent* keyEvent = factory->createKeyEvent();

if (!keyEvent) return NO_MEMORY;

initializeKeyEvent(keyEvent, &mMsg);

*outSeq = mMsg.body.key.seq;

*outEvent = keyEvent;

#if DEBUG_TRANSPORT_ACTIONS

ALOGD("channel '%s' consumer ~ consumed key event, seq=%u",

mChannel->getName().string(), *outSeq);

#endif

break;

}

1

2

3

4

5

6

7

8

if (!receiverObj.get()) {

receiverObj.reset(jniGetReferent(env, mReceiverWeakGlobal));

if (!receiverObj.get()) {

ALOGW("channel '%s' ~ Receiver object was finalized "

"without being disposed.", getInputChannelName());

return DEAD_OBJECT;

}

}

1

2

3

4

5

6

7

8

9

jobject inputEventObj;

switch (inputEvent->getType()) {

case AINPUT_EVENT_TYPE_KEY:

#if DEBUG_DISPATCH_CYCLE

ALOGD("channel '%s' ~ Received key event.", getInputChannelName());

#endif

inputEventObj = android_view_KeyEvent_fromNative(env,

static_cast<KeyEvent*>(inputEvent));

break;

1

2

env->CallVoidMethod(receiverObj.get(),

    gInputEventReceiverClassInfo.dispatchInputEvent, seq, inputEventObj);

1

2

3

4

private void dispatchInputEvent(int seq, InputEvent event) {

    mSeqMap.put(event.getSequenceNumber(), seq);

    onInputEvent(event);

}

1

enqueueInputEvent(event, this, 0, true);

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

void enqueueInputEvent(InputEvent event,

InputEventReceiver receiver, int flags, boolean processImmediately) {

QueuedInputEvent q = obtainQueuedInputEvent(event, receiver, flags);

// Always enqueue the input event in order, regardless of its time stamp.

// We do this because the application or the IME may inject key events

// in response to touch events and we want to ensure that the injected keys

// are processed in the order they were received and we cannot trust that

// the time stamp of injected events are monotonic.

QueuedInputEvent last = mPendingInputEventTail;

if (last == null) {

mPendingInputEventHead = q;

mPendingInputEventTail = q;

} else {

last.mNext = q;

mPendingInputEventTail = q;

}

mPendingInputEventCount += 1;

Trace.traceCounter(Trace.TRACE_TAG_INPUT, mPendingInputEventQueueLengthCounterName,

mPendingInputEventCount);

if (processImmediately) {

doProcessInputEvents();

} else {

scheduleProcessInputEvents();

}

}

1

2

3

4

5

6

7

8

9

public final void deliver(QueuedInputEvent q) {

    if ((q.mFlags & QueuedInputEvent.FLAG_FINISHED) != 0) {

forward(q);

    } else if (shouldDropInputEvent(q)) {

finish(q, false);

    } else {

apply(q, onProcess(q));

    }

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

// Set up the input pipeline.

CharSequence counterSuffix = attrs.getTitle();

mSyntheticInputStage = new SyntheticInputStage();

InputStage viewPostImeStage = new ViewPostImeInputStage(mSyntheticInputStage);

InputStage nativePostImeStage = new NativePostImeInputStage(viewPostImeStage,

"aq:native-post-ime:" + counterSuffix);

InputStage earlyPostImeStage = new EarlyPostImeInputStage(nativePostImeStage);

InputStage imeStage = new ImeInputStage(earlyPostImeStage,

"aq:ime:" + counterSuffix);

InputStage viewPreImeStage = new ViewPreImeInputStage(imeStage);

InputStage nativePreImeStage = new NativePreImeInputStage(viewPreImeStage,

"aq:native-pre-ime:" + counterSuffix);

mFirstInputStage = nativePreImeStage;

mFirstPostImeInputStage = earlyPostImeStage;

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

protected int onProcess(QueuedInputEvent q) {

    if (q.mEvent instanceof KeyEvent) {

return processKeyEvent(q);

    } else {

// If delivering a new non-key event, make sure the window is

// now allowed to start updating.

handleDispatchDoneAnimating();

final int source = q.mEvent.getSource();

if ((source & InputDevice.SOURCE_CLASS_POINTER) != 0) {

return processPointerEvent(q);

} else if ((source & InputDevice.SOURCE_CLASS_TRACKBALL) != 0) {

return processTrackballEvent(q);

} else {

return processGenericMotionEvent(q);

}

    }

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

private int processKeyEvent(QueuedInputEvent q) {

final KeyEvent event = (KeyEvent)q.mEvent;

if (event.getAction() != KeyEvent.ACTION_UP) {

// If delivering a new key event, make sure the window is

// now allowed to start updating.

handleDispatchDoneAnimating();

}

// Deliver the key to the view hierarchy.

if (mView.dispatchKeyEvent(event)) {

return FINISH_HANDLED;

}

if (shouldDropInputEvent(q)) {

return FINISH_NOT_HANDLED;

}

// If the Control modifier is held, try to interpret the key as a shortcut.

if (event.getAction() == KeyEvent.ACTION_DOWN

&& event.isCtrlPressed()

&& event.getRepeatCount() == 0

&& !KeyEvent.isModifierKey(event.getKeyCode())) {

if (mView.dispatchKeyShortcutEvent(event)) {

return FINISH_HANDLED;

}

if (shouldDropInputEvent(q)) {

return FINISH_NOT_HANDLED;

}

}

// Apply the fallback event policy.

if (mFallbackEventHandler.dispatchKeyEvent(event)) {

return FINISH_HANDLED;

}

if (shouldDropInputEvent(q)) {

return FINISH_NOT_HANDLED;

}

// Handle automatic focus changes.

if (event.getAction() == KeyEvent.ACTION_DOWN) {

int direction = 0;

switch (event.getKeyCode()) {

case KeyEvent.KEYCODE_DPAD_LEFT:

if (event.hasNoModifiers()) {

direction = View.FOCUS_LEFT;

}

break;

case KeyEvent.KEYCODE_DPAD_RIGHT:

if (event.hasNoModifiers()) {

direction = View.FOCUS_RIGHT;

}

break;

case KeyEvent.KEYCODE_DPAD_UP:

if (event.hasNoModifiers()) {

direction = View.FOCUS_UP;

}

break;

case KeyEvent.KEYCODE_DPAD_DOWN:

if (event.hasNoModifiers()) {

direction = View.FOCUS_DOWN;

}

break;

case KeyEvent.KEYCODE_TAB:

if (event.hasNoModifiers()) {

direction = View.FOCUS_FORWARD;

} else if (event.hasModifiers(KeyEvent.META_SHIFT_ON)) {

direction = View.FOCUS_BACKWARD;

}

break;

}

if (direction != 0) {

View focused = mView.findFocus();

if (focused != null) {

View v = focused.focusSearch(direction);

if (v != null && v != focused) {

// do the math the get the interesting rect

// of previous focused into the coord system of

// newly focused view

focused.getFocusedRect(mTempRect);

if (mView instanceof ViewGroup) {

((ViewGroup) mView).offsetDescendantRectToMyCoords(

focused, mTempRect);

((ViewGroup) mView).offsetRectIntoDescendantCoords(

v, mTempRect);

}

if (v.requestFocus(direction, mTempRect)) {

playSoundEffect(SoundEffectConstants

.getContantForFocusDirection(direction));

return FINISH_HANDLED;

}

}

// Give the focused view a last chance to handle the dpad key.

if (mView.dispatchUnhandledMove(focused, direction)) {

return FINISH_HANDLED;

}

} else {

// find the best view to give focus to in this non-touch-mode with no-focus

View v = focusSearch(null, direction);

if (v != null && v.requestFocus(direction)) {

return FINISH_HANDLED;

}

}

}

}

return FORWARD;

}

1

2

3

4

// Deliver the key to the view hierarchy.

if (mView.dispatchKeyEvent(event)) {

    return FINISH_HANDLED;

}

1

2

3

4

5

6

7

8

9

10

11

12

// If the Control modifier is held, try to interpret the key as a shortcut.

if (event.getAction() == KeyEvent.ACTION_DOWN

&& event.isCtrlPressed()

&& event.getRepeatCount() == 0

&& !KeyEvent.isModifierKey(event.getKeyCode())) {

if (mView.dispatchKeyShortcutEvent(event)) {

    return FINISH_HANDLED;

}

if (shouldDropInputEvent(q)) {

    return FINISH_NOT_HANDLED;

}

}

1

2

3

4

// Apply the fallback event policy.

if (mFallbackEventHandler.dispatchKeyEvent(event)) {

    return FINISH_HANDLED;

}

1

2

3

// Handle automatic focus changes.

if (event.getAction() == KeyEvent.ACTION_DOWN) {

    ......

1

2

3

4

// Deliver the key to the view hierarchy.

if (mView.dispatchKeyEvent(event)) {

    return FINISH_HANDLED;

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

public boolean dispatchKeyEvent(KeyEvent event) {

final int keyCode = event.getKeyCode();

final int action = event.getAction();

final boolean isDown = action == KeyEvent.ACTION_DOWN;

if (isDown && (event.getRepeatCount() == 0)) {

// First handle chording of panel key: if a panel key is held

// but not released, try to execute a shortcut in it.

if ((mPanelChordingKey > 0) && (mPanelChordingKey != keyCode)) {

boolean handled = dispatchKeyShortcutEvent(event);

if (handled) {

return true;

}

}

// If a panel is open, perform a shortcut on it without the

// chorded panel key

if ((mPreparedPanel != null) && mPreparedPanel.isOpen) {

if (performPanelShortcut(mPreparedPanel, keyCode, event, 0)) {

return true;

}

}

}

if (!isDestroyed()) {

final Callback cb = getCallback();

final boolean handled = cb != null && mFeatureId < 0 ? cb.dispatchKeyEvent(event)

: super.dispatchKeyEvent(event);

if (handled) {

return true;

}

}

return isDown ? PhoneWindow.this.onKeyDown(mFeatureId, event.getKeyCode(), event)

: PhoneWindow.this.onKeyUp(mFeatureId, event.getKeyCode(), event);

}

1

2

3

4

5

6

7

8

if (!isDestroyed()) {

    final Callback cb = getCallback();

    final boolean handled = cb != null && mFeatureId < 0 ? cb.dispatchKeyEvent(event)

: super.dispatchKeyEvent(event);

    if (handled) {

return true;

    }

}

1

2

return isDown ? PhoneWindow.this.onKeyDown(mFeatureId, event.getKeyCode(), event)

                    : PhoneWindow.this.onKeyUp(mFeatureId, event.getKeyCode(), event);

1

2

mWindow = PolicyManager.makeNewWindow(this);

mWindow.setCallback(this);

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

public boolean dispatchKeyEvent(KeyEvent event) {

    onUserInteraction();

// Let action bars open menus in response to the menu key prioritized over

// the window handling it

    if (event.getKeyCode() == KeyEvent.KEYCODE_MENU &&

mActionBar != null && mActionBar.onMenuKeyEvent(event)) {

return true;

    }

    Window win = getWindow();

    if (win.superDispatchKeyEvent(event)) {

return true;

    }

    View decor = mDecor;

    if (decor == null) decor = win.getDecorView();

    return event.dispatch(this, decor != null

? decor.getKeyDispatcherState() : null, this);

}

1

onUserInteraction();

1

2

3

4

if (event.getKeyCode() == KeyEvent.KEYCODE_MENU &&

        mActionBar != null && mActionBar.onMenuKeyEvent(event)) {

    return true;

}

1

2

3

4

Window win = getWindow();

    if (win.superDispatchKeyEvent(event)) {

        return true;

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

public boolean superDispatchKeyEvent(KeyEvent event) {

    // Give priority to closing action modes if applicable.

    if (event.getKeyCode() == KeyEvent.KEYCODE_BACK) {

        final int action = event.getAction();

    // Back cancels action modes first.

    if (mActionMode != null) {

if (action == KeyEvent.ACTION_UP) {

    mActionMode.finish();

}

return true;

    }

    }

    return super.dispatchKeyEvent(event);

}

1

2

3

View decor = mDecor;

    if (decor == null) decor = win.getDecorView();

    return event.dispatch(this, decor != null ? decor.getKeyDispatcherState() : null, this);

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

public boolean dispatchKeyEvent(KeyEvent event) {

    if (mInputEventConsistencyVerifier != null) {

mInputEventConsistencyVerifier.onKeyEvent(event, 1);

    }

if ((mPrivateFlags & (PFLAG_FOCUSED | PFLAG_HAS_BOUNDS))

== (PFLAG_FOCUSED | PFLAG_HAS_BOUNDS)) {

if (super.dispatchKeyEvent(event)) {

return true;

}

} else if (mFocused != null && (mFocused.mPrivateFlags & PFLAG_HAS_BOUNDS)

== PFLAG_HAS_BOUNDS) {

if (mFocused.dispatchKeyEvent(event)) {

return true;

}

}

if (mInputEventConsistencyVerifier != null) {

    mInputEventConsistencyVerifier.onUnhandledEvent(event, 1);

}

    return false;

}

1

2

3

if (mInputEventConsistencyVerifier != null) {

    mInputEventConsistencyVerifier.onKeyEvent(event, 1);

}

1

2

3

4

5

6

7

8

9

10

11

if ((mPrivateFlags & (PFLAG_FOCUSED | PFLAG_HAS_BOUNDS))

                == (PFLAG_FOCUSED | PFLAG_HAS_BOUNDS)) {

            if (super.dispatchKeyEvent(event)) {

                return true;

            }

} else if (mFocused != null && (mFocused.mPrivateFlags & PFLAG_HAS_BOUNDS)

                == PFLAG_HAS_BOUNDS) {

            if (mFocused.dispatchKeyEvent(event)) {

                return true;

            }

}

1

2

3

4

5

ListenerInfo li = mListenerInfo;

if (li != null && li.mOnKeyListener != null && (mViewFlags & ENABLED_MASK) == ENABLED

&& li.mOnKeyListener.onKey(this, event.getKeyCode(), event)) {

    return true;

}

1

if (li != null && li.mOnKeyListener != null

1

2

3

if (event.dispatch(this, mAttachInfo != null ? mAttachInfo.mKeyDispatchState : null, this)) {

    return true;

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

public final boolean dispatch(Callback receiver, DispatcherState state,

Object target) {

switch (mAction) {

case ACTION_DOWN: {

mFlags &= ~FLAG_START_TRACKING;

if (DEBUG) Log.v(TAG, "Key down to " + target + " in " + state

+ ": " + this);

boolean res = receiver.onKeyDown(mKeyCode, this);

if (state != null) {

if (res && mRepeatCount == 0 && (mFlags&FLAG_START_TRACKING) != 0) {

if (DEBUG) Log.v(TAG, "  Start tracking!");

state.startTracking(this, target);

} else if (isLongPress() && state.isTracking(this)) {

try {

if (receiver.onKeyLongPress(mKeyCode, this)) {

if (DEBUG) Log.v(TAG, "  Clear from long press!");

state.performedLongPress(this);

res = true;

}

} catch (AbstractMethodError e) {

}

}

}

return res;

}

case ACTION_UP:

if (DEBUG) Log.v(TAG, "Key up to " + target + " in " + state

+ ": " + this);

if (state != null) {

state.handleUpEvent(this);

}

return receiver.onKeyUp(mKeyCode, this);

case ACTION_MULTIPLE:

final int count = mRepeatCount;

final int code = mKeyCode;

if (receiver.onKeyMultiple(code, count, this)) {

return true;

}

if (code != KeyEvent.KEYCODE_UNKNOWN) {

mAction = ACTION_DOWN;

mRepeatCount = 0;

boolean handled = receiver.onKeyDown(code, this);

if (handled) {

mAction = ACTION_UP;

receiver.onKeyUp(code, this);

}

mAction = ACTION_MULTIPLE;

mRepeatCount = count;

return handled;

}

return false;

}

return false;

}

1

2

mFlags &= ~FLAG_START_TRACKING

boolean res = receiver.onKeyDown(mKeyCode, this);

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

if (state != null) {

    if (res && mRepeatCount == 0 && (mFlags&FLAG_START_TRACKING) != 0) {

if (DEBUG) Log.v(TAG, "  Start tracking!");

state.startTracking(this, target);

    } else if (isLongPress() && state.isTracking(this)) {

try {

            if (receiver.onKeyLongPress(mKeyCode, this)) {

        if (DEBUG) Log.v(TAG, "  Clear from long press!");

         state.performedLongPress(this);

        res = true;

    }

} catch (AbstractMethodError e) {

        }

    }

}

1

2

3

public boolean onKeyLongPress(int keyCode, KeyEvent event) {

    return false;

}

1

return receiver.onKeyUp(mKeyCode, this);

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

public boolean onKeyDown(int keyCode, KeyEvent event) {

    boolean result = false;

    if (KeyEvent.isConfirmKey(keyCode)) {

if ((mViewFlags & ENABLED_MASK) == DISABLED) {

return true;

}

// Long clickable items don't necessarily have to be clickable

if (((mViewFlags & CLICKABLE) == CLICKABLE ||

(mViewFlags & LONG_CLICKABLE) == LONG_CLICKABLE) &&

(event.getRepeatCount() == 0)) {

setPressed(true);

checkForLongClick(0);

return true;

}

}

    return result;

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

public boolean onKeyUp(int keyCode, KeyEvent event) {

    if (KeyEvent.isConfirmKey(keyCode)) {

        if ((mViewFlags & ENABLED_MASK) == DISABLED) {

    return true;

        }

       if ((mViewFlags & CLICKABLE) == CLICKABLE && isPressed()) {

            setPressed(false);

           if (!mHasPerformedLongPress) {

             // This is a tap, so remove the longpress check

        removeLongPressCallback();

        return performClick();

    }

        }

    }

    return false;

}

1

2

3

4

5

if (!mHasPerformedLongPress) {

    // This is a tap, so remove the longpress check

    removeLongPressCallback();

    return performClick();

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

public boolean performClick() {

    final boolean result;

    final ListenerInfo li = mListenerInfo;

    if (li != null && li.mOnClickListener != null) {

playSoundEffect(SoundEffectConstants.CLICK);

li.mOnClickListener.onClick(this);

result = true;

    } else {

result = false;

    }

    sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);

    return result;

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

public boolean onKeyDown(int keyCode, KeyEvent event)  {

    if (keyCode == KeyEvent.KEYCODE_BACK) {

if (getApplicationInfo().targetSdkVersion >= Build.VERSION_CODES.ECLAIR) {

    event.startTracking();

} else {

    onBackPressed();

}

return true;

}

if (mDefaultKeyMode == DEFAULT_KEYS_DISABLE) {

    return false;

} else if (mDefaultKeyMode == DEFAULT_KEYS_SHORTCUT) {

        Window w = getWindow();

if (w.hasFeature(Window.FEATURE_OPTIONS_PANEL) &&

w.performPanelShortcut(Window.FEATURE_OPTIONS_PANEL, keyCode, event,

Menu.FLAG_ALWAYS_PERFORM_CLOSE)) {

            return true;

}

return false;

} else {

// Common code for DEFAULT_KEYS_DIALER & DEFAULT_KEYS_SEARCH_*

boolean clearSpannable = false;

boolean handled;

if ((event.getRepeatCount() != 0) || event.isSystem()) {

clearSpannable = true;

handled = false;

} else {

handled = TextKeyListener.getInstance().onKeyDown(

null, mDefaultKeySsb, keyCode, event);

if (handled && mDefaultKeySsb.length() > 0) {

// something useable has been typed - dispatch it now.

final String str = mDefaultKeySsb.toString();

clearSpannable = true;

switch (mDefaultKeyMode) {

case DEFAULT_KEYS_DIALER:

Intent intent = new Intent(Intent.ACTION_DIAL,  Uri.parse("tel:" + str));

intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

startActivity(intent);

break;

case DEFAULT_KEYS_SEARCH_LOCAL:

startSearch(str, false, null, false);

break;

case DEFAULT_KEYS_SEARCH_GLOBAL:

startSearch(str, false, null, true);

break;

}

}

}

if (clearSpannable) {

mDefaultKeySsb.clear();

mDefaultKeySsb.clearSpans();

Selection.setSelection(mDefaultKeySsb,0);

}

return handled;

}

}

1

2

3

4

5

6

7

8

if (keyCode == KeyEvent.KEYCODE_BACK) {

    if (getApplicationInfo().targetSdkVersion >= Build.VERSION_CODES.ECLAIR) {

event.startTracking();

} else {

onBackPressed();

}

    return true;

}

1

2

3

4

5

6

7

8

9

10

public boolean onKeyUp(int keyCode, KeyEvent event) {

    if (getApplicationInfo().targetSdkVersion >= Build.VERSION_CODES.ECLAIR) {

if (keyCode == KeyEvent.KEYCODE_BACK && event.isTracking()

&& !event.isCanceled()) {

onBackPressed();

return true;

}

}

    return false;

}

1

2

return isDown ? PhoneWindow.this.onKeyDown(mFeatureId, event.getKeyCode(), event)

                    : PhoneWindow.this.onKeyUp(mFeatureId, event.getKeyCode(), event);

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

protected boolean onKeyDown(int featureId, int keyCode, KeyEvent event) {

/* ****************************************************************************

* HOW TO DECIDE WHERE YOUR KEY HANDLING GOES.

*

* If your key handling must happen before the app gets a crack at the event,

* it goes in PhoneWindowManager.

*

* If your key handling should happen in all windows, and does not depend on

* the state of the current application, other than that the current

* application can override the behavior by handling the event itself, it

* should go in PhoneFallbackEventHandler.

*

* Only if your handling depends on the window, and the fact that it has

* a DecorView, should it go here.

* ****************************************************************************/

final KeyEvent.DispatcherState dispatcher =

mDecor != null ? mDecor.getKeyDispatcherState() : null;

//Log.i(TAG, "Key down: repeat=" + event.getRepeatCount()

//        + " flags=0x" + Integer.toHexString(event.getFlags()));

switch (keyCode) {

case KeyEvent.KEYCODE_VOLUME_UP:

case KeyEvent.KEYCODE_VOLUME_DOWN: {

int direction = keyCode == KeyEvent.KEYCODE_VOLUME_UP ? AudioManager.ADJUST_RAISE

: AudioManager.ADJUST_LOWER;

// If we have a session send it the volume command, otherwise

// use the suggested stream.

if (mMediaController != null) {

mMediaController.adjustVolume(direction, AudioManager.FLAG_SHOW_UI);

} else {

MediaSessionLegacyHelper.getHelper(getContext()).sendAdjustVolumeBy(

mVolumeControlStreamType, direction,

AudioManager.FLAG_SHOW_UI | AudioManager.FLAG_VIBRATE);

}

return true;

}

case KeyEvent.KEYCODE_VOLUME_MUTE: {

getAudioManager().handleKeyDown(event, mVolumeControlStreamType);

return true;

}

// These are all the recognized media key codes in

// KeyEvent.isMediaKey()

case KeyEvent.KEYCODE_MEDIA_PLAY:

case KeyEvent.KEYCODE_MEDIA_PAUSE:

case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:

case KeyEvent.KEYCODE_MUTE:

case KeyEvent.KEYCODE_HEADSETHOOK:

case KeyEvent.KEYCODE_MEDIA_STOP:

case KeyEvent.KEYCODE_MEDIA_NEXT:

case KeyEvent.KEYCODE_MEDIA_PREVIOUS:

case KeyEvent.KEYCODE_MEDIA_REWIND:

case KeyEvent.KEYCODE_MEDIA_RECORD:

case KeyEvent.KEYCODE_MEDIA_FAST_FORWARD: {

if (mMediaController != null) {

if (mMediaController.dispatchMediaButtonEvent(event)) {

return true;

}

}

return false;

}

case KeyEvent.KEYCODE_MENU: {

onKeyDownPanel((featureId < 0) ? FEATURE_OPTIONS_PANEL : featureId, event);

return true;

}

case KeyEvent.KEYCODE_BACK: {

if (event.getRepeatCount() > 0) break;

if (featureId < 0) break;

// Currently don't do anything with long press.

if (dispatcher != null) {

dispatcher.startTracking(event, this);

}

return true;

}

}

return false;

}

1

2

3

4

5

6

7

8

9

10

11

12

13

if (r.window == null && !a.mFinished && willBeVisible) {

    r.window = r.activity.getWindow();

    View decor = r.window.getDecorView();

    decor.setVisibility(View.INVISIBLE);

    ViewManager wm = a.getWindowManager();

    WindowManager.LayoutParams l = r.window.getAttributes();

    a.mDecor = decor;

    l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;

    l.softInputMode |= forwardBit;

    if (a.mVisibleFromClient) {

        a.mWindowAdded = true;

        wm.addView(decor, l);

}

1

mWindow = PolicyManager.makeNewWindow(this);

1

2

3

public Window makeNewWindow(Context context) {

    return new PhoneWindow(context);

}

1

2

3

4

5

6

public final View getDecorView() {

    if (mDecor == null) {

        installDecor();

    }

    return mDecor;

}

1

ViewManager wm = a.getWindowManager();

1

mWindowManager = mWindow.getWindowManager();

1

2

3

4

if (wm == null) {

    wm = (WindowManager)mContext.getSystemService(Context.WINDOW_SERVICE);

}

mWindowManager = ((WindowManagerImpl)wm).createLocalWindowManager(this);

1

2

3

public WindowManagerImpl createLocalWindowManager(Window parentWindow) {

      return new WindowManagerImpl(mDisplay, parentWindow);

}

1

wm.addView(decor, l);

1

2

3

4

public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {

    applyDefaultToken(params);

    mGlobal.addView(view, params, mDisplay, mParentWindow);

}

1

root.setView(view, wparams, panelParentView);

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

void NativeInputManager::interceptKeyBeforeQueueing(const KeyEvent* keyEvent,

uint32_t& policyFlags) {

// Policy:

// - Ignore untrusted events and pass them along.

// - Ask the window manager what to do with normal events and trusted injected events.

// - For normal events wake and brighten the screen if currently off or dim.

if (mInteractive) {

policyFlags |= POLICY_FLAG_INTERACTIVE;

}

if ((policyFlags & POLICY_FLAG_TRUSTED)) {

nsecs_t when = keyEvent->getEventTime();

JNIEnv* env = jniEnv();

jobject keyEventObj = android_view_KeyEvent_fromNative(env, keyEvent);

jint wmActions;

if (keyEventObj) {

wmActions = env->CallIntMethod(mServiceObj,

gServiceClassInfo.interceptKeyBeforeQueueing,

keyEventObj, policyFlags);

if (checkAndClearExceptionFromCallback(env, "interceptKeyBeforeQueueing")) {

wmActions = 0;

}

android_view_KeyEvent_recycle(env, keyEventObj);

env->DeleteLocalRef(keyEventObj);

} else {

ALOGE("Failed to obtain key event object for interceptKeyBeforeQueueing.");

wmActions = 0;

}

handleInterceptActions(wmActions, when, /*byref*/ policyFlags);

} else {

if (mInteractive) {

policyFlags |= POLICY_FLAG_PASS_TO_USER;

}

}

}

1

2

3

if (mInteractive) {

    policyFlags |= POLICY_FLAG_INTERACTIVE;

}

1

jobject keyEventObj = android_view_KeyEvent_fromNative(env, keyEvent);

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

jobject android_view_KeyEvent_fromNative(JNIEnv* env, const KeyEvent* event) {

    jobject eventObj = env->CallStaticObjectMethod(gKeyEventClassInfo.clazz,

            gKeyEventClassInfo.obtain,

            nanoseconds_to_milliseconds(event->getDownTime()),

            nanoseconds_to_milliseconds(event->getEventTime()),

            event->getAction(),

            event->getKeyCode(),

            event->getRepeatCount(),

            event->getMetaState(),

            event->getDeviceId(),

            event->getScanCode(),

            event->getFlags(),

            event->getSource(),

            NULL);

    if (env->ExceptionCheck()) {

        ALOGE("An exception occurred while obtaining a key event.");

        LOGE_EX(env);

        env->ExceptionClear();

        return NULL;

    }

    return eventObj;

}

1

2

3

wmActions = env->CallIntMethod(mServiceObj,

                    gServiceClassInfo.interceptKeyBeforeQueueing,

                    keyEventObj, policyFlags);

1

handleInterceptActions(wmActions, when, /*byref*/ policyFlags);

1

2

3

4

5

6

7

8

9

10

void NativeInputManager::handleInterceptActions(jint wmActions, nsecs_t when,

        uint32_t& policyFlags) {

    if (wmActions & WM_ACTION_PASS_TO_USER) {

        policyFlags |= POLICY_FLAG_PASS_TO_USER;

    } else {

#if DEBUG_INPUT_DISPATCHER_POLICY

        ALOGD("handleInterceptActions: Not passing key to user.");

#endif

    }

}

1

2

3

4

// Native callback.

private int interceptKeyBeforeQueueing(KeyEvent event, int policyFlags) {

    return mWindowManagerCallbacks.interceptKeyBeforeQueueing(event, policyFlags);

}

1

2

3

4

5

6

/* Provides an opportunity for the window manager policy to intercept early key

* processing as soon as the key has been read from the device. */

@Override

public int interceptKeyBeforeQueueing(KeyEvent event, int policyFlags) {

    return mService.mPolicy.interceptKeyBeforeQueueing(event, policyFlags);

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

void InputDispatcher::doInterceptKeyBeforeDispatchingLockedInterruptible(

        CommandEntry* commandEntry) {

    KeyEntry* entry = commandEntry->keyEntry;

    KeyEvent event;

    initializeKeyEvent(&event, entry);

    mLock.unlock();

    nsecs_t delay = mPolicy->interceptKeyBeforeDispatching(commandEntry->inputWindowHandle,

            &event, entry->policyFlags);

    mLock.lock();

    if (delay < 0) {

        entry->interceptKeyResult = KeyEntry::INTERCEPT_KEY_RESULT_SKIP;

    } else if (!delay) {

        entry->interceptKeyResult = KeyEntry::INTERCEPT_KEY_RESULT_CONTINUE;

    } else {

        entry->interceptKeyResult = KeyEntry::INTERCEPT_KEY_RESULT_TRY_AGAIN_LATER;

        entry->interceptKeyWakeupTime = now() + delay;

    }

    entry->release();

}

1

mPolicy->interceptKeyBeforeDispatching

1

2

3

4

// Apply the fallback event policy.

if (mFallbackEventHandler.dispatchKeyEvent(event)) {

    return FINISH_HANDLED;

}