此处记录按键事件从Framework到应用层的传递流程。WMS中接收到消息后，会调用ViewRootImpl中的dispatchInputEvent方法，
附上核心流程图
Android按键事件流程
输入事件认识
Android所有输入事件都会封装为InputEvent事件然后进行分发，InputEvent又分为两种类型，实体按键事件(KeyEvent)，触摸事件(MotionEvent)。这些事件流入到上层之后才会进行分别进行处理。
下面源码分析
按键事件流入
InputEvent就包含了KeyEvent,接下来就看该输入事件如何传递和分别处理的，首先是ViewRootImpl的dispatchInputEvent方法
frameworks/base/core/java/android/view/ViewRootImpl.java
public void dispatchInputEvent(InputEvent event) {
dispatchInputEvent(event, null);
}
public void dispatchInputEvent(InputEvent event, InputEventReceiver receiver) {
SomeArgs args = SomeArgs.obtain();
args.arg1 = event;
args.arg2 = receiver; // 此处receiver为null
Message msg = mHandler.obtainMessage(MSG_DISPATCH_INPUT_EVENT, args);
msg.setAsynchronous(true);
//发送MSG_DISPATCH_INPUT_EVENT消息
mHandler.sendMessage(msg);
}
mHandler是其内部类ViewRootHandler,接收到消息如下
final class ViewRootHandler extends Handler {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
...
case MSG_DISPATCH_INPUT_EVENT: {
SomeArgs args = (SomeArgs)msg.obj;
InputEvent event = (InputEvent)args.arg1;
InputEventReceiver receiver = (InputEventReceiver)args.arg2;
enqueueInputEvent(event, receiver, 0, true);
args.recycle();
} break;
}
}
走enqueueInputEvent方法
void enqueueInputEvent(InputEvent event,
InputEventReceiver receiver, int flags, boolean processImmediately) {
adjustInputEventForCompatibility(event);
// 1. 将输入事件event封装为QueuedInputEvent
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 {
// 2. 追加新事件到mPendingInputEventTail上,形成事件链表
last.mNext = q;
mPendingInputEventTail = q;
}
mPendingInputEventCount += 1;
if (processImmediately) {
// 3. 处理输入事件
doProcessInputEvents();
} else {
scheduleProcessInputEvents();
}
}
void doProcessInputEvents() {
// Deliver all pending input events in the queue.
while (mPendingInputEventHead != null) {
QueuedInputEvent q = mPendingInputEventHead;
mPendingInputEventHead = q.mNext;
if (mPendingInputEventHead == null) {
mPendingInputEventTail = null;
}
q.mNext = null;
...
// 4. 分发QueuedInputEvent队列中的所有事件
deliverInputEvent(q);
}
...
}
InputEvent事件会形成一个事件链表，最后循环分发链表队列中的事件
private void deliverInputEvent(QueuedInputEvent q) {
if (mInputEventConsistencyVerifier != null) {
mInputEventConsistencyVerifier.onInputEvent(q.mEvent, 0);
}
// 关于InputStage下面详解，它表示了输入事件的一个分发阶段,eg: ime之前处理，ime处理，ime之后处理等
InputStage stage;
if (q.shouldSendToSynthesizer()) {
stage = mSyntheticInputStage;
} else {
// 是否跳过键盘消息(IME),如果true,返回EarlyPostImeInputStage对象，否则返回NativePreImeInputStage对象
stage = q.shouldSkipIme() ? mFirstPostImeInputStage : mFirstInputStage;
}
if (stage != null) {
stage.deliver(q);
} else {
finishInputEvent(q);
}
}
NativePreImeInputStage是在ViewRootImpl中的setView()创建，而setview方法是在完成view绘制时调用的。
ViewRootImpl.java
public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
synchronized (this) {
if (mView == null) {
mView = view;
...
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;
}
}
}
先接着看deliverInputEvent方法中的stage.deliver(q);
abstract class InputStage {
/**
* Delivers an event to be processed.
*/
public final void deliver(QueuedInputEvent q) {
/// M: [ANR] Add for monitoring stage status. {
ViewDebugManager.getInstance().debugInputStageDeliverd(this,
System.currentTimeMillis());
/// }
// 当前事件还没有处理，因此不包含FLAG_FINISHED标致
if ((q.mFlags & QueuedInputEvent.FLAG_FINISHED) != 0) {
forward(q);
// 一般不会丢弃输入事件
} else if (shouldDropInputEvent(q)) {
finish(q, false);
} else {
ViewDebugManager.getInstance().debugInputDispatchState(q.mEvent, this.toString());
// 1. 执行apply方法，传入onProcess的返回结果，该方法由子类重写
apply(q, onProcess(q));
}
}
...
/**
* Applies a result code from {@link #onProcess} to the specified event.
*/
protected void apply(QueuedInputEvent q, int result) {
if (result == FORWARD) {
forward(q);
} else if (result == FINISH_HANDLED) {
finish(q, true);
} else if (result == FINISH_NOT_HANDLED) {
finish(q, false);
} else {
throw new IllegalArgumentException("Invalid result: " + result);
}
}
/**
* Called when an event is ready to be processed.
* @return A result code indicating how the event was handled.
*/
protected int onProcess(QueuedInputEvent q) {
return FORWARD;
}
...
}
上面提到的所有InputState都继承自InputStage
如果不跳过IME消息，则inputStage为NativePreImeInputStage，其是由ViewPreImeInputStage，ImeInputStage，EarlyPostImeInputStage，NativePostImeInputStage，ViewPostImeInputStage，SyntheticInputStage作为嵌套参数构成的，所以调用NativePreImeInputStage的deliver(q)，会依次调用到每个InputState的子类的onProcess()方法
这里先介绍下InputStage
InputStage
输入事件的传递过程如下，每个前面处理事件的阶段都有拦截传递的能力。
- NativePreImeInputStage 分发早于IME的InputEvent事件到NativeActivity中去处理, NativeActivity和普通acitivty的功能区别不大,只是很多代码都在native层去实现,这样执行效率更高,并且NativeActivity在游戏开发中很实用。 不支持触摸事件。
- ViewPreImeInputStage 分发早于IME的InputEvent到View框架处理，会调用acitivity的所有view的onkeyPreIme方法,这样就给View在输入法处理key事件之前先得到消息并处理的机会。 不支持触摸事件
- ImeInputStage 分发InputEvent到IME处理 ImeInputStage的onProcess方法会调用InputMethodManager的dispatchInputEvent方法处理消息。 不支持触摸事件。
- EarlyPostImeInputStage 输入法之后输入事件就会流到该阶段，此时 屏幕上有焦点的View会高亮显示,用来提示用户焦点所在。支持触摸事件。
- NativePostImeInputStage 分发InputEvent事件到NativeActivity,为了让IME处理完消息后能先于普通的Activity处理消息。此时支持触摸事件。
- ViewPostImeInputStage 分发InputEvent事件到View框架，支持触摸事件。
- SyntheticInputStage 未处理的InputEvent都会传到这个阶段,例如手机上的虚拟按键消息
所有InputStage类的构造方法都会传入一个InputStage类的变量,这样最终会形成流水线线式的处理结构,也就是采用了责任链模式，每经过一个InputStage对象的处理都会进行判断,看是否还需要将 events继续向前传输,如果需要就调用forward()函数让该变量中存储的下一个InputStage对象处理该events,如果不需要就调用finish()函数结束events的传输
我们所关心的View框架的输入事件，故着重分析ViewPostImeInputStage
/**
* Delivers post-ime input events to the view hierarchy.
*/
final class ViewPostImeInputStage extends InputStage {
...
@Override
protected int onProcess(QueuedInputEvent q) {
if (q.mEvent instanceof KeyEvent) {
// 处理按键事件
return processKeyEvent(q);
} else {
// else中处理触摸事件,触摸事件又会根据不同类型的触摸做不同的处理，例如鼠标触摸，轨迹球(Android很早的一种交互方式，现在没有手机用)触摸,一般的手指触摸
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);
}
}
}
}
此处我们分析按键事件
private int processKeyEvent(QueuedInputEvent q) {
// 转为KeyEvent事件
final KeyEvent event = (KeyEvent)q.mEvent;
// Deliver the key to the view hierarchy.
// 1. 先由DecorView进行按键事件派发
if (mView.dispatchKeyEvent(event)) {
return FINISH_HANDLED;
}
...
int groupNavigationDirection = 0;
// 根据TAB和SHIFT键的按下来判断焦点方向为向前还是向后
if (event.getAction() == KeyEvent.ACTION_DOWN
&& event.getKeyCode() == KeyEvent.KEYCODE_TAB) {
if (KeyEvent.metaStateHasModifiers(event.getMetaState(), KeyEvent.META_META_ON)) {
groupNavigationDirection = View.FOCUS_FORWARD;
} else if (KeyEvent.metaStateHasModifiers(event.getMetaState(),
KeyEvent.META_META_ON | KeyEvent.META_SHIFT_ON)) {
groupNavigationDirection = View.FOCUS_BACKWARD;
}
}
// If a modifier is held, try to interpret the key as a shortcut.
if (event.getAction() == KeyEvent.ACTION_DOWN
&& !KeyEvent.metaStateHasNoModifiers(event.getMetaState())
&& event.getRepeatCount() == 0
&& !KeyEvent.isModifierKey(event.getKeyCode())
&& groupNavigationDirection == 0) {
// 交由DecorView处理快捷键分发
if (mView.dispatchKeyShortcutEvent(event)) {
return FINISH_HANDLED;
}
...
}
// mFallbackEventHandler会处理系统的一些按键，针对的是所有窗口
// Apply the fallback event policy.
if (mFallbackEventHandler.dispatchKeyEvent(event)) {
return FINISH_HANDLED;
}
...
// Handle automatic focus changes.
if (event.getAction() == KeyEvent.ACTION_DOWN) {
if (groupNavigationDirection != 0) {
if (performKeyboardGroupNavigation(groupNavigationDirection)) {
return FINISH_HANDLED;
}
} else {
// 2. 处理键盘的上下左右的焦点查找
if (performFocusNavigation(event)) {
return FINISH_HANDLED;
}
}
}
return FORWARD;
}
注释1处，mView处理按键事件， mView具体指的是？ 如果是Activity和Dialog，mView就是DecorView，是所有view的根;如果是Toast,mView是id为com.android.internal.R.id.message,这点在Toast.makeText方法中可以看出。此处只分析Activity。
本文主要分析View框架的按键事件派发
按键事件派发
1. DecorView.dispatchKeyEvent方法
DecorView.java
@Override
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 ((mWindow.mPanelChordingKey > 0) && (mWindow.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 ((mWindow.mPreparedPanel != null) && mWindow.mPreparedPanel.isOpen) {
if (mWindow.performPanelShortcut(mWindow.mPreparedPanel, keyCode, event, 0)) {
return true;
}
}
}
if (!mWindow.isDestroyed()) {
// cb是Activiy或者Dialog，我们只分析Activity
// mFeatureId在installDecor是构造的DecorView传入的为-1,故调用Activity的dispatchKeyEvent
final Window.Callback cb = mWindow.getCallback();
final boolean handled = cb != null && mFeatureId < 0 ? cb.dispatchKeyEvent(event)
: super.dispatchKeyEvent(event);
if (handled) {
return true;
}
}
return isDown ? mWindow.onKeyDown(mFeatureId, event.getKeyCode(), event)
: mWindow.onKeyUp(mFeatureId, event.getKeyCode(), event);
}
2. Activity的dispatchKeyEvent
Activity.java
public boolean dispatchKeyEvent(KeyEvent event) {
onUserInteraction();
// Let action bars open menus in response to the menu key prioritized over
// the window handling it
final int keyCode = event.getKeyCode();
// 如果按键是menu事件，则先回调Actionbar的onMenuKeyEvent()事件处理，如果返回没有处理才会继续往下走
if (keyCode == KeyEvent.KEYCODE_MENU &&
mActionBar != null && mActionBar.onMenuKeyEvent(event)) {
return true;
}
Window win = getWindow();
// 1. 调用Phonewindow的superDispatchKeyEvent,最终会调用到DecorView的dispatchKeyEvent方法中
if (win.superDispatchKeyEvent(event)) {
return true;
}
View decor = mDecor;
if (decor == null) decor = win.getDecorView();
// 2. 如果Phonewindow 分发后返回false，则交由KeyEvent派发事件，调用Activity的onKeyDown/Up()方法
return event.dispatch(this, decor != null
? decor.getKeyDispatcherState() : null, this);
}
继续分析注释1，看如何派发输入事件到ViewGroup
PhoneWindow.java
@Override
public boolean superDispatchKeyEvent(KeyEvent event) {
// mDecor是DecorView
return mDecor.superDispatchKeyEvent(event);
}
发现又进入到DecorView，但这次调用的方法是superDispatchKeyEvent
DecorView.java
public boolean superDispatchKeyEvent(KeyEvent event) {
// Give priority to closing action modes if applicable.
// 对BACK按键做处理，如果存在ActionMode则先退出ActionMode,ActionMode相当于一个临时的ActionBar,具体使用还是google吧,此处不是重点
if (event.getKeyCode() == KeyEvent.KEYCODE_BACK) {
final int action = event.getAction();
// Back cancels action modes first.
if (mPrimaryActionMode != null) {
if (action == KeyEvent.ACTION_UP) {
mPrimaryActionMode.finish();
}
return true;
}
}
// 1. DecorView父类是FrameLayout，但其没有实现dispatchKeyEvent方法，故该处调用的是ViewGroup的方法
return super.dispatchKeyEvent(event);
}
注释1会调用其父类ViewGroup的dispatchKeyEvent()方法
3. ViewGroup的dispatchKeyEvent
@Override
public boolean dispatchKeyEvent(KeyEvent event) {
if (mInputEventConsistencyVerifier != null) {
mInputEventConsistencyVerifier.onKeyEvent(event, 1);
}
// 1. 如果viewgroup获得焦点且边界确定，则调用父view的也就是View的dispatchKeyEvent
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) {
// 2. 交由获取焦点的子view进行按键事件的派发
if (mFocused.dispatchKeyEvent(event)) {
return true;
}
}
if (mInputEventConsistencyVerifier != null) {
mInputEventConsistencyVerifier.onUnhandledEvent(event, 1);
}
return false;
}
注释2中mFocused存在于每个ViewGroup,其标识了ViewGroup的直接子View是否拥有或者包含焦点，通过mFocused.dispatchKeyEvent即可递归调用找到最终获取焦点的View，然后调用该View的dispatchKeyEvent()方法,如注释1.
4. View的dispatchKeyEvent
View.java
public boolean dispatchKeyEvent(KeyEvent event) {
if (mInputEventConsistencyVerifier != null) {
mInputEventConsistencyVerifier.onKeyEvent(event, 0);
}
// Give any attached key listener a first crack at the event.
//noinspection SimplifiableIfStatement
ListenerInfo li = mListenerInfo;
// 1. 当对view设置了OnKeyListener,且该view处于enabled状态，则调用OnKeyListener的onKey()方法
if (li != null && li.mOnKeyListener != null && (mViewFlags & ENABLED_MASK) == ENABLED
&& li.mOnKeyListener.onKey(this, event.getKeyCode(), event)) {
return true;
}
// 2. KeyEvent派发事件，receiver为view,会回调View的onKeyDown/Up()方法
if (event.dispatch(this, mAttachInfo != null
? mAttachInfo.mKeyDispatchState : null, this)) {
return true;
}
if (mInputEventConsistencyVerifier != null) {
mInputEventConsistencyVerifier.onUnhandledEvent(event, 0);
}
return false;
}
注释1中对View是否设置了OnKeyListener做了判断，如果设置，则先回调onKey()方法
注释2，在onKey()返回false情况下会通过KeyEvent的dispatch方法调用View的onKeyDown/Up()方法。
KeyEvent的dispatch(),该方法在View#dispatchKeyEvent()方法中，如果onKey()返回false会调用，参数传入的是View;该方法也会在Activity#dispatchKeyEvent()方法中win.superDispatchKeyEvent()方法返回false后进行调用，只不过参数传入的是Activity，最终会调用Activity或者View的onKeyDown/Up()方法。
KeyEvent.java
public final boolean dispatch(Callback receiver, DispatcherState state,
Object target) {
switch (mAction) {
case ACTION_DOWN: {
mFlags &= ~FLAG_START_TRACKING;
// 1. 执行Activity或者View的onKeyDown()方法
boolean res = receiver.onKeyDown(mKeyCode, this);
if (state != null) {
if (res && mRepeatCount == 0 && (mFlags&FLAG_START_TRACKING) != 0) {
state.startTracking(this, target);
} else if (isLongPress() && state.isTracking(this)) {
try {
if (receiver.onKeyLongPress(mKeyCode, this)) {
state.performedLongPress(this);
res = true;
}
} catch (AbstractMethodError e) {
}
}
}
return res;
}
case ACTION_UP:
if (state != null) {
state.handleUpEvent(this);
}
// 2. 执行Activity或者View的onKeyUp()方法
return receiver.onKeyUp(mKeyCode, this);
...
}
return false;
}
receiver可能是Activity对象，也可能是view对象，具体情况具体分析
View对象的onKeyDown(),onKeyUp()
public boolean onKeyDown(int keyCode, KeyEvent event) {
// isConfirmKey中会对keycode判断是否是KEYCODE_DPAD_CENTER,KEYCODE_ENTER,KEYCODE_SPACE,KEYCODE_NUMPAD_ENTER几个表示确定的键，也就是可以触发点击作用的键
if (KeyEvent.isConfirmKey(keyCode)) {
// 如果view处于DISABLED状态，则直接返回true
if ((mViewFlags & ENABLED_MASK) == DISABLED) {
return true;
}
if (event.getRepeatCount() == 0) {
// Long clickable items don't necessarily have to be clickable.
// View的CLICKABLE 和 LONG_CLICABLE是独立的，互不影响
final boolean clickable = (mViewFlags & CLICKABLE) == CLICKABLE
|| (mViewFlags & LONG_CLICKABLE) == LONG_CLICKABLE;
if (clickable || (mViewFlags & TOOLTIP) == TOOLTIP) {
// For the purposes of menu anchoring and drawable hotspots,
// key events are considered to be at the center of the view.
final float x = getWidth() / 2f;
final float y = getHeight() / 2f;
if (clickable) {
// 设置按下状态，比如更换view颜色，切换图片等
setPressed(true, x, y);
}
// 该方法做的事情是发送一个可以判断长按时间的演示runnable，时间一到则执行长按操作
checkForLongClick(0, x, y);
return true;
}
}
}
return false;
}
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();
if (!event.isCanceled()) {
// 回调OnClickListener的onClick()方法
return performClick();
}
}
}
}
return false;
}
如果View设置了onClickListener()方法，则按下enter键后抬起时会执行onClick()方法
如果View的onKeyDown/Up()也返回false，则dispatchKeyEvent()方法会一直返回至Activity中，交由其onKeyDown/Up()处理
Activity对象的onKeyDown(),onKeyUp()
public boolean onKeyDown(int keyCode, KeyEvent event) {
if (keyCode == KeyEvent.KEYCODE_BACK) {
if (getApplicationInfo().targetSdkVersion
>= Build.VERSION_CODES.ECLAIR) {
// >= android2.1则跟踪按键传递过程
event.startTracking();
} else {
// android2.1之前按下返回键直接返回
onBackPressed();
}
return true;
}
...
return handled;
}
}
public boolean onKeyUp(int keyCode, KeyEvent event) {
// 如果android版本>= 2.1 回调onBackPressed()方法退出Activity
if (getApplicationInfo().targetSdkVersion
>= Build.VERSION_CODES.ECLAIR) {
if (keyCode == KeyEvent.KEYCODE_BACK && event.isTracking()
&& !event.isCanceled()) {
onBackPressed();
return true;
}
}
return false;
}
如果Activity里面的任何view、布局都没有处理按键，就会传递到Activity的onKeyDown，onKeyUp。比如，当在EditText中输入文字时，Activity的onKeyDown，onKeyUp不会接收到按键事件，因为EditText有自己的处理按键事件的方法，如果此时把焦点从EditText移走，onKeyDown，onKeyUp就会接收到按键事件。
Activity中onKeyDown/Up()也不做处理返回false时，事件一路返回至DecorView的dispatchKeyEvent()方法中，此时继续调用PhoneWindow的onKeyDown/Up()方法
PhoneWindow的onKeyDown/Up()
PhoneWindow.java
protected boolean onKeyDown(int featureId, int keyCode, KeyEvent event) {
final KeyEvent.DispatcherState dispatcher =
mDecor != null ? mDecor.getKeyDispatcherState() : null;
switch (keyCode) {
case KeyEvent.KEYCODE_VOLUME_UP:
case KeyEvent.KEYCODE_VOLUME_DOWN:
case KeyEvent.KEYCODE_VOLUME_MUTE: {
// If we have a session send it the volume command, otherwise
// use the suggested stream.
if (mMediaController != null) {
int direction = 0;
switch (keyCode) {
case KeyEvent.KEYCODE_VOLUME_UP:
direction = AudioManager.ADJUST_RAISE;
break;
case KeyEvent.KEYCODE_VOLUME_DOWN:
direction = AudioManager.ADJUST_LOWER;
break;
case KeyEvent.KEYCODE_VOLUME_MUTE:
direction = AudioManager.ADJUST_TOGGLE_MUTE;
break;
}
mMediaController.adjustVolume(direction, AudioManager.FLAG_SHOW_UI);
} else {
MediaSessionLegacyHelper.getHelper(getContext()).sendVolumeKeyEvent(
event, mVolumeControlStreamType, false);
}
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;
}
onKeyDown/onKeyUp方法主要针对当前获得焦点的窗口对一些特殊按键进行处理，包括音量+/-,多媒体控制按键,MENU,BACK
总结
按键事件从Framework层到View框架整体流程如流程图，我们主要关心是Activity,ViewGroup和View的事件派发。
Activity可以通过dispatchKeyEvent()将KeyEvent派发给ViewGroup直到找到获取焦点的View(当然可能就是ViewGroup获取焦点),获取焦点的View先去判断OnKeyListener存在与否，存在回调onKey(),如果不存在或者返回false，则回调其onKeyDown/Up()方法，onClick()方法在onKeyUp()方法中会进行回调，此时如果还是返回false，则Activity中的onKeyDown/Up()方法得以调用，最后没有处理则交给PhoneWindow的onKeyDown/Up()。我们也可以通过重写对应方法来达到事件消费,也就是不继续走剩余事件传递流程。
注意：PhoneFallbackEventHandler在ViewRoolImpl中提到过，其也是对特殊按键进行处理，但是那是针对所有的窗口，包括当前获得焦点的窗口，而PhoneWindow只针对当前获得焦点的窗口。PhoneFallbackEventHandler是在使用代码如下
ViewRootImpl.java
private int processKeyEvent(QueuedInputEvent q) {
...
// Apply the fallback event policy. mFallbackEventHandler就是PhoneFallbackEventHandler
if (mFallbackEventHandler.dispatchKeyEvent(event)) {
return FINISH_HANDLED;
}
...
}
PhoneFallbackEventHandler
public boolean dispatchKeyEvent(KeyEvent event) {
final int action = event.getAction();
final int keyCode = event.getKeyCode();
if (action == KeyEvent.ACTION_DOWN) {
return onKeyDown(keyCode, event);
} else {
return onKeyUp(keyCode, event);
}
}
boolean onKeyDown(int keyCode, KeyEvent event) {
final KeyEvent.DispatcherState dispatcher = mView.getKeyDispatcherState();
switch (keyCode) {
case KeyEvent.KEYCODE_VOLUME_UP:
case KeyEvent.KEYCODE_VOLUME_DOWN:
case KeyEvent.KEYCODE_VOLUME_MUTE: {
MediaSessionLegacyHelper.getHelper(mContext).sendVolumeKeyEvent(
event, AudioManager.USE_DEFAULT_STREAM_TYPE, false);
return true;
}
case KeyEvent.KEYCODE_MEDIA_PLAY:
case KeyEvent.KEYCODE_MEDIA_PAUSE:
case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
/* Suppress PLAY/PAUSE toggle when phone is ringing or in-call
* to avoid music playback */
if (getTelephonyManager().getCallState() != TelephonyManager.CALL_STATE_IDLE) {
return true; // suppress key event
}
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:
case KeyEvent.KEYCODE_MEDIA_AUDIO_TRACK: {
handleMediaKeyEvent(event);
return true;
}
case KeyEvent.KEYCODE_CALL: {
...
}
}
主要是针对音量键，媒体相关，Call和Camera键进行处理。
特殊按键处理
第一次拦截在interceptKeyBeforeQueueing中，
result &= ~ACTION_PASS_TO_USER或者0，将会拦截事件，不在向下传递
第二次在拦截在interceptKeyBeforeDispatching，
return -1，事件将被拦截不在向下传递
例如对Home键做操作,由于Home并不会下发至View,故应用是无法监听,但我们可以在interceptKeyBeforeDispatching中对其进行客制化,例如将其remap返回键KEYCODE_BACK下发,这时PhoneWindowManager就会收到被remap后的KEYCODE_BACK,进而最后交由View框架处理.
PhoneWindowManager.java
public long interceptKeyBeforeDispatching(WindowState win, KeyEvent event, int policyFlags) {
final boolean keyguardOn = keyguardOn();
final int keyCode = event.getKeyCode();
final int repeatCount = event.getRepeatCount();
final int metaState = event.getMetaState();
final int flags = event.getFlags();
final boolean down = event.getAction() == KeyEvent.ACTION_DOWN;
......
if (keyCode == KeyEvent.KEYCODE_HOME) {
// If we have released the home key, and didn't do anything else
// while it was pressed, then it is time to go home!
if (!down) {
// wangyannan begin
Log.i("wangyannan","foreground");
/**
*通过inputManager注入KEYCODE_BACK事件，相当于在按home键时接收到的为back事件
*/
InputManager inputManager = (InputManager) mContext.getSystemService(Context.INPUT_SERVICE);
KeyEvent ke1 = new KeyEvent(event.getDownTime(), event.getEventTime(),
KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_BACK, event.getRepeatCount());
KeyEvent ke2 = new KeyEvent(event.getDownTime(), event.getEventTime(),
KeyEvent.ACTION_UP, KeyEvent.KEYCODE_BACK, event.getRepeatCount());
inputManager.injectInputEvent(ke1, InputManager.INJECT_INPUT_EVENT_MODE_ASYNC);
inputManager.injectInputEvent(ke2, InputManager.INJECT_INPUT_EVENT_MODE_ASYNC);
return -1;
}
//wangyannan end
cancelPreloadRecentApps();
......
handleShortPressOnHome();
return -1;//返回-1则不响应home键
}
......
}
}
//wangyannan begin
例如某个Activity监听按键,对HOME键做处理
XXXActivity.java
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
switch (keyCode){
case KeyEvent.KEYCODE_BACK:
// 如果该条件成立,则为系统原本的按键事件,否则为重定向的时间
if(event.getFlags()!=0&&event.getDeviceId()!=-1&&event.getSource()!=0){
//实际接收到的back事件
Toast.makeText(this,"没有重定向",Toast.LENGTH_SHORT).show();
}else{
//接受到的back事件为代码中注入的back事件
Toast.makeText(this,"重定向",Toast.LENGTH_SHORT).show();
}
return ture;
}
return super.onKeyDown(keyCode, event);
}