通过上篇的介绍，我们知道在对KeyEvent的处理中有非常重要的一环，那就是KeyEvent在focus view的path上自上而下的分发，
换句话说只有focus的view才有资格参与KeyEvent的处理，所以说focused view在KeyEvent的处理中很重要，我们需要弄清楚明白
focus view是如何设置以及改变的。
通过Android官方文档
http://developer.android.com/reference/android/view/View.html
中关于Focus Handling的介绍，
我们知道framework会根据用户的输入处理常规的focus移动，包括当删除、隐藏或添加新的view时改变focus。一个view有资格获得
focus的前提是isFocusable()方法返回true，你可以通过setFocusable(boolean)方法来设置它。另外当在touch mode下的时候，还
需要isFocusableInTouchMode()也返回true，你也可以通过setFocusableInTouchMode(boolean)来设置它。focus的移动是基于这
样的算法，它尝试在某个给定的方向上找最临近的view，设置它为新的focus。在极个别情况，如果默认的算法不符合你的需求，你也可以
在xml布局文件中通过显式指定nextFocusDown/Left/Right/Up这些属性来表明focus移动的顺序。在运行时刻，你也可以通过调用
View.requestFocus()方法来动态地让某个view获得focus。作为开始，我们先看看这几个具备获得焦点前提的方法，如下：
* Returns whether this View is able to take focus.
*
@return
True if this view can take focus, or false otherwise.
* @attr ref android.R.styleable#View_focusable
@ViewDebug.ExportedProperty(category
= "focus"
)
public
final
boolean
isFocusable() {
return
FOCUSABLE == (mViewFlags &
FOCUSABLE_MASK); // 各种位操作，不熟悉、习惯的同学可以翻本C语言的书看看，
} // 这里顺便推荐下《C Primer Plus》,一本足矣，而且里面
// 有一章是专门介绍bit操作的应用的，非常赞！！！
* When a view is focusable, it may not want to take focus when in touch mode.
* For example, a button would like focus when the user is navigating via a D-pad
* so that the user can click on it, but once the user starts touching the screen,
* the button shouldn't take focus
*
@return
Whether the view is focusable in touch mode.
* @attr ref android.R.styleable#View_focusableInTouchMode
@ViewDebug.ExportedProperty
public
final
boolean
isFocusableInTouchMode() {
return
FOCUSABLE_IN_TOUCH_MODE == (mViewFlags &
FOCUSABLE_IN_TOUCH_MODE);
* Set whether this view can receive the focus.
* Setting this to false will also ensure that this view is not focusable
* in touch mode.
*
@param
focusable If true, this view can receive the focus.
*
@see
#setFocusableInTouchMode(boolean)
* @attr ref android.R.styleable#View_focusable
public
void
setFocusable(
boolean
focusable) {
if
(!
focusable) { // 注意：是false的时候，会顺便保证在touch mode下也不能获得focus
setFlags(
0
, FOCUSABLE_IN_TOUCH_MODE);
setFlags(focusable
?
FOCUSABLE : NOT_FOCUSABLE, FOCUSABLE_MASK); // 设置FOCUSABLEB位
* Set whether this view can receive focus while in touch mode.
* Setting this to true will also ensure that this view is focusable.
*
@param
focusableInTouchMode If true, this view can receive the focus while
* in touch mode.
*
@see
#setFocusable(boolean)
* @attr ref android.R.styleable#View_focusableInTouchMode
public
void
setFocusableInTouchMode(
boolean
focusableInTouchMode) {
//
Focusable in touch mode should always be set before the focusable flag
//
otherwise, setting the focusable flag will trigger a focusableViewAvailable()
//
which, in touch mode, will not successfully request focus on this view
//
because the focusable in touch mode flag is not set
setFlags(focusableInTouchMode ? FOCUSABLE_IN_TOUCH_MODE : 0
, FOCUSABLE_IN_TOUCH_MODE);
if
(focusableInTouchMode) { // 如果是true顺便打开FOCUSABLE位
setFlags(FOCUSABLE, FOCUSABLE_MASK);
接下来我们就看看本文的重点View.requestFocus()等相关方法，代码如下：
* Call this to try to give focus to a specific view or to one of its
* descendants.
* A view will not actually take focus if it is not focusable ({
@link
#isFocusable} returns
* false), or if it is focusable and it is not focusable in touch mode
* ({
@link
#isFocusableInTouchMode}) while the device is in touch mode.
* See also {
@link
#focusSearch(int)}, which is what you call to say that you
* have focus, and you want your parent to look for the next one.
* This is equivalent to calling {
@link
#requestFocus(int, Rect)} with arguments
* {
@link
#FOCUS_DOWN} and <code>null</code>.
*
@return
Whether this view or one of its descendants actually took focus.
public
final
boolean
requestFocus() {
return
requestFocus(View.FOCUS_DOWN);
* Call this to try to give focus to a specific view or to one of its
* descendants and give it a hint about what direction focus is heading.
* A view will not actually take focus if it is not focusable ({
@link
#isFocusable} returns
* false), or if it is focusable and it is not focusable in touch mode
* ({
@link
#isFocusableInTouchMode}) while the device is in touch mode.
* See also {
@link
#focusSearch(int)}, which is what you call to say that you
* have focus, and you want your parent to look for the next one.
* This is equivalent to calling {
@link
#requestFocus(int, Rect)} with
* <code>null</code> set for the previously focused rectangle.
*
@param
direction One of FOCUS_UP, FOCUS_DOWN, FOCUS_LEFT, and FOCUS_RIGHT
*
@return
Whether this view or one of its descendants actually took focus.
public
final
boolean
requestFocus(
int
direction) {
return
requestFocus(direction,
null
);
* Call this to try to give focus to a specific view or to one of its descendants
* and give it hints about the direction and a specific rectangle that the focus
* is coming from. The rectangle can help give larger views a finer grained hint
* about where focus is coming from, and therefore, where to show selection, or
* forward focus change internally.
* A view will not actually take focus if it is not focusable ({
@link
#isFocusable} returns
* false), or if it is focusable and it is not focusable in touch mode
* ({
@link
#isFocusableInTouchMode}) while the device is in touch mode.
* A View will not take focus if it is not visible.
* A View will not take focus if one of its parents has
* {
@link
android.view.ViewGroup#getDescendantFocusability()} equal to
* {
@link
ViewGroup#FOCUS_BLOCK_DESCENDANTS}.
* See also {
@link
#focusSearch(int)}, which is what you call to say that you
* have focus, and you want your parent to look for the next one.
* You may wish to override this method if your custom {
@link
View} has an internal
* {
@link
View} that it wishes to forward the request to.
*
@param
direction One of FOCUS_UP, FOCUS_DOWN, FOCUS_LEFT, and FOCUS_RIGHT
*
@param
previouslyFocusedRect The rectangle (in this View's coordinate system)
* to give a finer grained hint about where focus is coming from. May be null
* if there is no hint.
*
@return
Whether this view or one of its descendants actually took focus.
public
boolean
requestFocus(
int
direction, Rect previouslyFocusedRect) {
return
requestFocusNoSearch(direction, previouslyFocusedRect);
private
boolean
requestFocusNoSearch(
int
direction, Rect previouslyFocusedRect) { // 此方法就是最终被调用的版本
//
need to be focusable
if
((mViewFlags & FOCUSABLE_MASK) != FOCUSABLE || // 不是FOCUSABLE，即没资格获取焦点
(mViewFlags
& VISIBILITY_MASK) !=
VISIBLE) { // 或者不是VISIBLE的，都直接返回false，表示请求获取焦点失败
return
false
; // 所以除了上文提到的2个获取focus的前提，其实这里的VISIBLE也应该算是第3个前提吧！
//
need to be focusable in touch mode if in touch mode
if
(isInTouchMode() && // 同样在touch mode下，也要检测FOCUSABLE_IN_TOUCH_MODE标志
(FOCUSABLE_IN_TOUCH_MODE
!= (mViewFlags &
FOCUSABLE_IN_TOUCH_MODE))) {
return
false
; // 不满足也直接返回false，表示失败
//
need to not have any parents blocking us
if
(hasAncestorThatBlocksDescendantFocus()) { // parents阻止我们获得焦点的话，我们也只能以失败告终
return
false
;
// 以上重重关卡都通过了，才会走到这里，真正设置focus
handleFocusGainInternal(direction, previouslyFocusedRect);
return
true
;
* Give this view focus. This will cause
* {
@link
#onFocusChanged(boolean, int, android.graphics.Rect)} to be called.
* Note: this does not check whether this {
@link
View} should get focus, it just
* gives it focus no matter what. It should only be called internally by framework
* code that knows what it is doing, namely {
@link
#requestFocus(int, Rect)}.
*
@param
direction values are {
@link
View#FOCUS_UP}, {
@link
View#FOCUS_DOWN},
* {
@link
View#FOCUS_LEFT} or {
@link
View#FOCUS_RIGHT}. This is the direction which
* focus moved when requestFocus() is called. It may not always
* apply, in which case use the default View.FOCUS_DOWN.
*
@param
previouslyFocusedRect The rectangle of the view that had focus
* prior in this View's coordinate system.
void
handleFocusGainInternal(
int
direction, Rect previouslyFocusedRect) {
if
(DBG) {
System.out.println(
this
+ " requestFocus()"
);
if
((mPrivateFlags & PFLAG_FOCUSED) == 0
) { // 只有当前View不是focused view时才会发生一系列操作，否则do nothing
mPrivateFlags
|=
PFLAG_FOCUSED; // 如果没focus的话，先设置此view的focused标志，isFocused，hasFocus等方法会检测此标志
View oldFocus
= (mAttachInfo !=
null
) ? getRootView().findFocus() :
null
; // 找到之前的focus
if
(mParent !=
null
) {
mParent.requestChildFocus(
this
,
this
); // 如果有mParent，则将此新focus请求向上传递
if
(mAttachInfo !=
null
) { // callback接口，将focus change事件notify出去
mAttachInfo.mTreeObserver.dispatchOnGlobalFocusChange(oldFocus,
this
);
onFocusChanged(
true
, direction, previouslyFocusedRect);
refreshDrawableState();
接着我们看下关于PFLAG_FOCUSED标志位相关的几个方法，如下：
* Returns true if this view has focus
*
@return
True if this view has focus, false otherwise.
@ViewDebug.ExportedProperty(category
= "focus"
)
public
boolean
isFocused() {
return
(mPrivateFlags & PFLAG_FOCUSED) != 0
;
* Find the view in the hierarchy rooted at this view that currently has
* focus.
*
@return
The view that currently has focus, or null if no focused view can
* be found.
public
View findFocus() {
return
(mPrivateFlags & PFLAG_FOCUSED) != 0 ?
this
:
null
;
* Returns true if this view has focus iteself, or is the ancestor of the
* view that has focus.
*
@return
True if this view has or contains focus, false otherwise.
@ViewDebug.ExportedProperty(category
= "focus"
)
public
boolean
hasFocus() { // 对View来说，hasFocus和isFocus是相同的，ViewGroup类重载了此方法
return
(mPrivateFlags & PFLAG_FOCUSED) != 0
;
最后，我们看看ViewParent接口(以及其实现ViewGroup)的requestChildFocus()实现，代码如下：
* Called when a child of this parent wants focus
*
@param
child The child of this ViewParent that wants focus. This view
* will contain the focused view. It is not necessarily the view that
* actually has focus.
*
@param
focused The view that is a descendant of child that actually has
* focus
public
void
requestChildFocus(View child, View focused); // parent中的某个child请求获得focus，child要么是focused，
// 要么是focused的parent
//
我们可以看到其实现类有ViewGroup、ScrollView等，这里我们看下ViewGroup类的，其他的有兴趣的同学可以自行研究
@Override
public
void
requestChildFocus(View child, View focused) {
if
(DBG) {
System.out.println(
this
+ " requestChildFocus()"
);
if
(getDescendantFocusability() ==
FOCUS_BLOCK_DESCENDANTS) {
return
; // 如果此ViewGroup被设置为阻止任何children获得focus，则直接返回
//
Unfocus us, if necessary
super
.unFocus(); // 先unFocus 此ViewGroup
//
We had a previous notion of who had focus. Clear it.
if
(mFocused !=
child) { // 如果mFocused不同于传递进来的child，则更新mFocused
if
(mFocused !=
null
) {
mFocused.unFocus(); // 让旧的放弃focus
mFocused
=
child; // 更新mFocused
if
(mParent !=
null
) { // 接着沿着focus path往上传递（递归调用）
mParent.requestChildFocus(
this
, focused); // 注意这里的第2个参数，一直是传递进来的focused不变
我们注意到只有ViewGroup才有mFocused字段，表示focus path上的一个节点。我们看看与之相关的代码：
// The view contained within this ViewGroup that has or contains focus.
private View mFocused; // 此ViewGroup中的child view，它要么是focused view本身要么包含focused view
@Override
void handleFocusGainInternal(int direction, Rect previouslyFocusedRect) { // 此方法重载了View中的
if (mFocused != null) { // 添加了对mFocused的处理
mFocused.unFocus(); // 让mFocused unFocus在这种情况下
mFocused = null;
super.handleFocusGainInternal(direction, previouslyFocusedRect);
* {@inheritDoc}
public void clearChildFocus(View child) {
if (DBG) {
System.out.println(this + " clearChildFocus()");
mFocused = null; // 清空
if (mParent != null) { // 将事件告诉parent
mParent.clearChildFocus(this);
* {@inheritDoc}
@Override
public void clearFocus() {
if (DBG) {
System.out.println(this + " clearFocus()");
if (mFocused == null) { // 如果没有mFocused，则ViewGroup自身clearFocus
super.clearFocus();
} else { // 否则，让mFocused clearFocus，并且重置为null
View focused = mFocused;
mFocused = null;
focused.clearFocus();
* {@inheritDoc}
@Override
void unFocus() { // 大体同clearFocus，只是调的是unFocus方法
if (DBG) {
System.out.println(this + " unFocus()");
if (mFocused == null) {
super.unFocus();
} else {
mFocused.unFocus();
mFocused = null;
* Returns the focused child of this view, if any. The child may have focus
* or contain focus.
* @return the focused child or null.
public View getFocusedChild() { // 返回这个字段，供客户端代码使用
return mFocused;
* Returns true if this view has or contains focus
* @return true if this view has or contains focus
@Override
public boolean hasFocus() { // ViewGroup自己是focused或者其子、孙后代包含focused view
return (mPrivateFlags & PFLAG_FOCUSED) != 0 || mFocused != null;
* (non-Javadoc)
* @see android.view.View#findFocus()
@Override
public View findFocus() {
if (DBG) {
System.out.println("Find focus in " + this + ": flags="
+ isFocused() + ", child=" + mFocused);
if (isFocused()) { // 自己是focused，直接返回this
return this;
if (mFocused != null) { // 否则，mFocused不为空，则沿着这条线往下继续找
return mFocused.findFocus();
return null;
* {@inheritDoc}
@Override
public boolean hasFocusable() {
if ((mViewFlags & VISIBILITY_MASK) != VISIBLE) {
return false;
if (isFocusable()) {
return true;
final int descendantFocusability = getDescendantFocusability();
if (descendantFocusability != FOCUS_BLOCK_DESCENDANTS) {
final int count = mChildrenCount;
final View[] children = mChildren;
for (int i = 0; i < count; i++) {
final View child = children[i];
if (child.hasFocusable()) {
return true;
return false;
接着我们看下View自己的unFocus、clearFocus实现，代码如下：
* Called internally by the view system when a new view is getting focus.
* This is what clears the old focus.
* <b>NOTE:</b> The parent view's focused child must be updated manually
* after calling this method. Otherwise, the view hierarchy may be left in
* an inconstent state.
void unFocus() {
if (DBG) {
System.out.println(this + " unFocus()");
clearFocusInternal(false, false);
* Called when this view wants to give up focus. If focus is cleared
* {@link #onFocusChanged(boolean, int, android.graphics.Rect)} is called.
* <strong>Note:</strong> When a View clears focus the framework is trying
* to give focus to the first focusable View from the top. Hence, if this
* View is the first from the top that can take focus, then all callbacks
* related to clearing focus will be invoked after wich the framework will
* give focus to this view.
public void clearFocus() {
if (DBG) {
System.out.println(this + " clearFocus()");
clearFocusInternal(true, true);
* Clears focus from the view, optionally propagating the change up through
* the parent hierarchy and requesting that the root view place new focus.
* @param propagate whether to propagate the change up through the parent
* hierarchy
* @param refocus when propagate is true, specifies whether to request the
* root view place new focus
void clearFocusInternal(boolean propagate, boolean refocus) {
if ((mPrivateFlags & PFLAG_FOCUSED) != 0) { // 如果当前是focused，先清掉PFLAG_FOCUSED位
mPrivateFlags &= ~PFLAG_FOCUSED;
if (propagate && mParent != null) {
mParent.clearChildFocus(this); // 如果向上传播的话，调用parent.clearChildFocus方法
onFocusChanged(false, 0, null); // 调用callback方法
refreshDrawableState(); // 刷新drawable状态
if (propagate && (!refocus || !rootViewRequestFocus())) {
notifyGlobalFocusCleared(this);
通过上一篇的介绍，我们知道KeyEvent的派发就是在view层次结构的focus path上自上而下发生的，具体参见View.dispatchKeyEvent
的方法doc。刚开始我一直不明白这里的focus path是怎么形成的，怎么按着这个链传递的。这里为了帮助大家理解，我举一个典型的例子，
通过例子可以很清楚的看到传递过程。比方说我们的view层次结构是这样的，C是个Button，B是C的parent，LinearLayout，A是B的parent，
FrameLayout。这里我们先假设C、B、A都是有资格且其parent都不阻止它获得焦点，当我们在代码里调用C.requestFocus()时发生的调用
序列如下：
1. --> B.requestChildFocus(C, C); 当此方法发生后产生的结果是：B.mFocused = C;接着产生2调用；
2. --> A.requestChildFocus(B, C); 同样的，当此方法发生后，A.mFocused = B; 接着往上传递直到parent为空时停止。
当C.requestFocus()调用结束时，如果没有各种失败的case发生，那么C就是当前view层次结构中的focus了，也就是C.isFocused()方法
此时会返回true。看到了吗？通过这个递归调用，focus path的链就形成了，从最顶层的A能通过其mFocused字段找到B，从找到的B能通过
其mFocused字段找到C，以此类推。为了加深这个印象，我们最后再看眼ViewGroup.dispatchKeyEvent()方法:
@Override
public boolean dispatchKeyEvent(KeyEvent event) {
/// 2.2.1.1...
if (mInputEventConsistencyVerifier != null) {
mInputEventConsistencyVerifier.onKeyEvent(event, 1);
if ((mPrivateFlags & (PFLAG_FOCUSED | PFLAG_HAS_BOUNDS))
== (PFLAG_FOCUSED | PFLAG_HAS_BOUNDS)) { // ViewGroup是focused，则优先交给它自己处理
/// 2.2.1.2.
if (super.dispatchKeyEvent(event)) {
return true;
} else if (mFocused != null && (mFocused.mPrivateFlags & PFLAG_HAS_BOUNDS)
== PFLAG_HAS_BOUNDS) { // 否则就沿着mFocused形成的focus path向下传递
/// 2.2.1.3.
if (mFocused.dispatchKeyEvent(event)) {
return true;
if (mInputEventConsistencyVerifier != null) {
mInputEventConsistencyVerifier.onUnhandledEvent(event, 1);
/// 2.2.1.4.
return false;
现在再回过头来看这里的逻辑，是不是感觉特别简单呢？那是因为你已经完全弄清楚了mFocused的由来以及各种变化过程。至此view层次
结构中关于focus的变化过程已经全部分析完毕了，enjoy。
